Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

fix(device-link): sync host project names to controllers

xuzini-xzn6087fa7ae3be
diff --git a/apps/desktop/src/main/device-link/__tests__/dispatchSendSafety.test.ts b/apps/desktop/src/main/device-link/__tests__/dispatchSendSafety.test.ts
index 1f67048bb3..47feb9f439 100644
--- a/apps/desktop/src/main/device-link/__tests__/dispatchSendSafety.test.ts
+++ b/apps/desktop/src/main/device-link/__tests__/dispatchSendSafety.test.ts
@@ -87,6 +87,25 @@ beforeEach(() => {
__testing.reset();
});
+// Test value: public push dispatch must deliver the new metadata invalidation to both controllers.
+// Existing forwarding cases did not cover alias topics or the bot-authorization queue's empty payload.
+// Minimal input: one {} invalidation and two sessions subscribers; unit tier, no network.
+it('forwards project alias invalidations through the production bot authorization queue to every subscriber', async () => {
+ const client = mkClient();
+ __testing.setActiveClient(client as never);
+ subscriptions.subscribe('mobile', ['sessions'], 'mobile', []);
+ subscriptions.subscribe('desktop', ['sessions'], 'desktop', []);
+ setRemoteBotSessionLookup(async () => 'ordinary');
+ try {
+ __testing.forwardPush('local-db:project-aliases:changed', {});
+ await vi.waitFor(() => expect(client.sendPush).toHaveBeenCalledTimes(2));
+ expect(client.sendPush).toHaveBeenCalledWith('mobile', 'local-db:project-aliases:changed', {});
+ expect(client.sendPush).toHaveBeenCalledWith('desktop', 'local-db:project-aliases:changed', {});
+ } finally {
+ setRemoteBotSessionLookup(null);
+ }
+});
+
it('strips Desktop credential links from authorization history and live metadata pushes', () => {
const card = { v: 1, sessionId: 's1', createdAt: 1, target: { kind: 'plugin', id: 'p' },
snapshot: { kind: 'plugin_setup', requestId: 'r', revision: 1, ghost: { id: 'p', name: 'Plugin' },
diff --git a/apps/desktop/src/main/localDb/__tests__/projectAliases.test.ts b/apps/desktop/src/main/localDb/__tests__/projectAliases.test.ts
index 92b8182760..9aaf09f99a 100644
--- a/apps/desktop/src/main/localDb/__tests__/projectAliases.test.ts
+++ b/apps/desktop/src/main/localDb/__tests__/projectAliases.test.ts
@@ -16,6 +16,15 @@ vi.mock('electron', () => ({
handle: vi.fn(),
},
}));
+vi.mock('../../device-link/broadcast-tap.js', () => ({
+ captureDataOwnerBroadcastScope: () => ({}),
+ isDataOwnerBroadcastScopeCurrent: () => true,
+ tapWindowBroadcast: vi.fn(),
+}));
+vi.mock('../../security/trustedAppRenderer.js', () => ({
+ assertTrustedAppRendererEvent: vi.fn(),
+ isTrustedAppRendererWindow: () => true,
+}));
describe('projectAliases localDb helpers', () => {
let currentClient: DbClient | null = null;
diff --git a/apps/desktop/src/main/localDb/ipc/__tests__/projectAliasesBroadcast.test.ts b/apps/desktop/src/main/localDb/ipc/__tests__/projectAliasesBroadcast.test.ts
new file mode 100644
index 0000000000..fb1ba9268d
--- /dev/null
+++ b/apps/desktop/src/main/localDb/ipc/__tests__/projectAliasesBroadcast.test.ts
@@ -0,0 +1,126 @@
+/**
+ * Test value: real snapshot/mutation handlers expose only host-owned names and scoped invalidations.
+ * Regression: project renames never reached device-link; existing SQLite tests did not exercise
+ * IPC authorization or broadcasts. Minimal input is one local/SSH alias plus a device override,
+ * or an owner change during the awaited read/write. Unit tier with injected DB/renderer boundaries.
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const h = vi.hoisted(() => ({
+ trusted: { webContents: { send: vi.fn() } },
+ untrusted: { webContents: { send: vi.fn() } },
+ ownerStamp: { dataOwnerId: 'owner-a', ownerGeneration: 2 },
+ scopeCurrent: true,
+ read: vi.fn(),
+ tx: vi.fn(),
+ tap: vi.fn(),
+ handle: vi.fn(),
+ assertTrusted: vi.fn(),
+ remoteInvoke: false,
+}));
+vi.mock('electron', () => ({
+ BrowserWindow: { getAllWindows: () => [h.trusted, h.untrusted] },
+ ipcMain: { handle: h.handle },
+}));
+vi.mock('../../client/current', () => ({
+ getDbClient: () => ({
+ drizzle: { select: () => ({ from: () => ({ orderBy: h.read }) }) },
+ tx: h.tx,
+ }),
+}));
+vi.mock('../../../device-link/broadcast-tap.js', () => ({
+ captureDataOwnerBroadcastScope: () => ({ ownerScopeKey: 'owner-a:2', ownerStamp: h.ownerStamp }),
+ isDataOwnerBroadcastScopeCurrent: () => h.scopeCurrent,
+ tapWindowBroadcast: h.tap,
+}));
+vi.mock('../../../security/trustedAppRenderer.js', () => ({
+ assertTrustedAppRendererEvent: h.assertTrusted,
+ isTrustedAppRendererWindow: (window: unknown) => window === h.trusted,
+}));
+vi.mock('../../../device-link/invoke-context.js', () => ({
+ isDeviceLinkInvoke: () => h.remoteInvoke,
+}));
+
+import {
+ readHostProjectAliasesSnapshot,
+ registerProjectAliasesIpc,
+ upsertProjectAlias,
+} from '../projectAliases';
+
+describe('project alias remote snapshot and owner boundary', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ h.scopeCurrent = true;
+ h.remoteInvoke = false;
+ h.assertTrusted.mockReset();
+ h.read.mockResolvedValue([]);
+ h.tx.mockResolvedValue(null);
+ });
+
+ it('requires a trusted local sender while permitting already-authorized device-link invocations', async () => {
+ registerProjectAliasesIpc();
+ const handler = h.handle.mock.calls.find(([channel]) => channel === 'sidebar-settings:get-project-aliases')![1];
+ h.assertTrusted.mockImplementationOnce(() => { throw new Error('UNAUTHORIZED'); });
+ await expect(handler({})).rejects.toThrow('UNAUTHORIZED');
+ expect(h.read).not.toHaveBeenCalled();
+ h.remoteInvoke = true;
+ await expect(handler({})).resolves.toMatchObject({ aliases: [] });
+ expect(h.assertTrusted).toHaveBeenCalledTimes(1);
+ });
+
+ it('registers a separate snapshot and excludes controller-local device overrides', async () => {
+ h.read.mockResolvedValue([
+ { projectKey: 'local:C:/Repo', alias: 'Local project', updatedAt: 1 },
+ { projectKey: 'remote:ssh-a:/repo', alias: 'SSH project', updatedAt: 2 },
+ { projectKey: 'device:other:/repo', alias: 'Private override', updatedAt: 3 },
+ ]);
+ registerProjectAliasesIpc();
+ expect(h.handle).toHaveBeenCalledWith('sidebar-settings:get-project-aliases', expect.any(Function));
+ expect(await readHostProjectAliasesSnapshot()).toEqual({
+ aliases: [
+ { projectKey: 'local:C:/Repo', alias: 'Local project' },
+ { projectKey: 'remote:ssh-a:/repo', alias: 'SSH project' },
+ ],
+ platform: process.platform,
+ ownerStamp: h.ownerStamp,
+ });
+ });
+
+ it('broadcasts persisted rename and deletion invalidations with the captured owner stamp', async () => {
+ await upsertProjectAlias('local:/repo', 'New name');
+ await upsertProjectAlias('local:/repo', '');
+ expect(h.tap).toHaveBeenCalledTimes(2);
+ expect(h.tap).toHaveBeenLastCalledWith('local-db:project-aliases:changed', {}, h.ownerStamp);
+ expect(h.trusted.webContents.send).toHaveBeenLastCalledWith(
+ 'local-db:project-aliases:changed', {}, h.ownerStamp,
+ );
+ expect(h.untrusted.webContents.send).not.toHaveBeenCalled();
+ });
+
+ it('does not emit an old owner write after an account switch', async () => {
+ let complete!: (value: null) => void;
+ h.tx.mockImplementationOnce(() => new Promise((resolve) => { complete = resolve; }));
+ const pending = upsertProjectAlias('local:/repo', 'Old account name');
+ h.scopeCurrent = false;
+ complete(null);
+ await pending;
+ expect(h.tap).not.toHaveBeenCalled();
+ expect(h.trusted.webContents.send).not.toHaveBeenCalled();
+ });
+
+ it('rejects a snapshot that finishes after its owner becomes stale', async () => {
+ h.read.mockImplementationOnce(async () => {
+ h.scopeCurrent = false;
+ return [{ projectKey: 'local:/repo', alias: 'Old account name', updatedAt: 1 }];
+ });
+ await expect(readHostProjectAliasesSnapshot()).rejects.toThrow('PRECONDITION_FAILED');
+ });
+
+ it('does not broadcast a failed mutation or hide a failed snapshot read', async () => {
+ h.tx.mockRejectedValueOnce(new Error('write failed'));
+ await expect(upsertProjectAlias('local:/repo', 'Name')).rejects.toThrow('write failed');
+ expect(h.tap).not.toHaveBeenCalled();
+ h.read.mockRejectedValueOnce(new Error('read failed'));
+ await expect(readHostProjectAliasesSnapshot()).rejects.toThrow('read failed');
+ });
+});
diff --git a/apps/desktop/src/main/localDb/ipc/projectAliases.ts b/apps/desktop/src/main/localDb/ipc/projectAliases.ts
index 2703967d88..acf718500d 100644
--- a/apps/desktop/src/main/localDb/ipc/projectAliases.ts
+++ b/apps/desktop/src/main/localDb/ipc/projectAliases.ts
@@ -1,5 +1,10 @@
import { BrowserWindow, ipcMain } from 'electron';
import { desc } from 'drizzle-orm';
+import {
+ PROJECT_ALIASES_GET_CHANNEL,
+ PROJECT_ALIASES_CHANGED_CHANNEL,
+ type HostProjectAliasesSnapshot,
+} from '@cindy/maker-shared/project-alias-sync';
import { normalizeProjectKey, projectKeyComparisonKey } from '../../../shared/projectKeys.js';
import type { ProjectAlias } from '../../../shared/projectAliases.js';
@@ -7,6 +12,14 @@ import type { DbClient } from '../client/DbClient.js';
import { getDbClient } from '../client/current';
import { projectAliases } from '../schema';
import { requireObject, requireString, throwIpcError } from '../../utils/ipcValidate';
+import {
+ captureDataOwnerBroadcastScope,
+ isDataOwnerBroadcastScopeCurrent,
+ tapWindowBroadcast,
+ type DataOwnerBroadcastScope,
+} from '../../device-link/broadcast-tap.js';
+import { assertTrustedAppRendererEvent, isTrustedAppRendererWindow } from '../../security/trustedAppRenderer.js';
+import { isDeviceLinkInvoke } from '../../device-link/invoke-context.js';
const MAX_ALIAS_LENGTH = 80;
@@ -39,10 +52,14 @@ function requireProjectKey(raw: unknown): string {
return normalized;
}
-function broadcastProjectAliasesChanged(): void {
+function broadcastProjectAliasesChanged(scope: DataOwnerBroadcastScope): void {
+ if (!isDataOwnerBroadcastScopeCurrent(scope)) return;
for (const w of BrowserWindow.getAllWindows()) {
- if (!w.isDestroyed()) w.webContents.send('local-db:project-aliases:changed');
+ if (isTrustedAppRendererWindow(w)) {
+ w.webContents.send(PROJECT_ALIASES_CHANGED_CHANNEL, {}, scope.ownerStamp);
+ }
}
+ tapWindowBroadcast(PROJECT_ALIASES_CHANGED_CHANNEL, {}, scope.ownerStamp);
}
export async function listProjectAliases(client: DbClient = getDbClient()): Promise<ProjectAlias[]> {
@@ -54,12 +71,29 @@ export async function listProjectAliases(client: DbClient = getDbClient()): Prom
return rows.map(aliasToCamel);
}
+/** Read-only host projection; controller-local overrides never propagate to a third device. */
+export async function readHostProjectAliasesSnapshot(): Promise<HostProjectAliasesSnapshot> {
+ const scope = captureDataOwnerBroadcastScope();
+ const rows = await listProjectAliases();
+ if (!isDataOwnerBroadcastScopeCurrent(scope)) {
+ throwIpcError('PRECONDITION_FAILED', 'active account changed during project alias read');
+ }
+ return {
+ aliases: rows
+ .filter((row) => row.projectKey.startsWith('local:') || row.projectKey.startsWith('remote:'))
+ .map(({ projectKey, alias }) => ({ projectKey, alias })),
+ platform: process.platform,
+ ...(scope.ownerStamp ? { ownerStamp: scope.ownerStamp } : {}),
+ };
+}
+
export async function upsertProjectAlias(
projectKeyRaw: unknown,
aliasRaw: unknown,
localPlatform: NodeJS.Platform = process.platform,
scope?: { client: DbClient; assertCurrent: () => void },
): Promise<ProjectAlias | null> {
+ const broadcastScope = captureDataOwnerBroadcastScope();
const projectKey = requireProjectKey(projectKeyRaw);
const alias = sanitizeAlias(aliasRaw);
const now = Date.now();
@@ -78,7 +112,7 @@ export async function upsertProjectAlias(
updatedAt: now,
});
scope?.assertCurrent();
- broadcastProjectAliasesChanged();
+ broadcastProjectAliasesChanged(broadcastScope);
return saved == null
? null
: {
@@ -96,6 +130,10 @@ export async function deleteProjectAlias(
}
export function registerProjectAliasesIpc(): void {
+ ipcMain.handle(PROJECT_ALIASES_GET_CHANNEL, async (event) => {
+ if (!isDeviceLinkInvoke()) assertTrustedAppRendererEvent(event);
+ return readHostProjectAliasesSnapshot();
+ });
ipcMain.handle('local-db:project-aliases:list', async () => listProjectAliases());
ipcMain.handle('local-db:project-aliases:set', async (_event, input: unknown) => {
diff --git a/apps/desktop/src/renderer/__tests__/projectGrouping.test.ts b/apps/desktop/src/renderer/__tests__/projectGrouping.test.ts
index cc3fd230e3..83702ec6da 100644
--- a/apps/desktop/src/renderer/__tests__/projectGrouping.test.ts
+++ b/apps/desktop/src/renderer/__tests__/projectGrouping.test.ts
@@ -1,3 +1,9 @@
+/**
+ * Alias regression coverage uses the production grouping projection: the same remote directory
+ * must display its host alias, retain local overrides, and avoid leaking a name across identities.
+ * Existing grouping tests only supplied controller-local names. Minimal input: one remote session
+ * and its host snapshot (or two host identities sharing a legacy group). Pure unit tier.
+ */
/**
* projectGrouping — vitest unit tests
*
@@ -74,6 +80,49 @@ function s(partial: Partial<Session>): Session {
/* ============================== normalizeWorkingDir ============================== */
+describe('host project alias display', () => {
+ it('mirrors each host independently and keeps controller-local overrides first', () => {
+ const sessions = [
+ s({ workingDir: '/repo', deviceLinkDeviceId: 'a' }),
+ s({ workingDir: '/repo', deviceLinkDeviceId: 'b' }),
+ ];
+ const remoteProjectAliases = new Map([
+ ['a', { platform: 'darwin', aliases: [{ projectKey: 'local:/repo', alias: 'Host A' }] }],
+ ['b', { platform: 'darwin', aliases: [{ projectKey: 'local:/repo', alias: 'Host B' }] }],
+ ]);
+ const groups = groupSessions(sessions, {
+ remoteProjectAliases,
+ projectAliases: new Map([['device:a:/repo', 'My override']]),
+ });
+ expect(groups.projects.find((project) => project.deviceLinkDeviceId === 'a')?.displayName).toBe('My override');
+ expect(groups.projects.find((project) => project.deviceLinkDeviceId === 'b')?.displayName).toBe('Host B');
+ remoteProjectAliases.set('b', { platform: 'darwin', aliases: [] });
+ expect(groupSessions(sessions, { remoteProjectAliases }).projects.find((project) => project.deviceLinkDeviceId === 'b')?.displayName).not.toBe('Host B');
+ });
+
+ it('matches Windows host aliases without changing the controller project key spelling', () => {
+ const groups = groupSessions([s({ workingDir: 'C:/Repo/.worktrees/branch', deviceLinkDeviceId: 'a' })], {
+ remoteProjectAliases: new Map([['a', {
+ platform: 'win32', aliases: [{ projectKey: 'local:c:/repo', alias: 'Windows project' }],
+ }]]),
+ });
+ expect(groups.projects[0]).toMatchObject({ projectKey: 'device:a:C:/Repo', displayName: 'Windows project' });
+ });
+
+ it('resolves unique SSH identities and does not borrow a name for a mixed local/SSH group', () => {
+ const ssh = s({ workingDir: '/repo', deviceLinkDeviceId: 'a', remoteHostId: 'ssh-a' });
+ const local = s({ workingDir: '/repo', deviceLinkDeviceId: 'a' });
+ const remoteProjectAliases = new Map([['a', {
+ platform: 'darwin', aliases: [
+ { projectKey: 'local:/repo', alias: 'Local host project' },
+ { projectKey: 'remote:ssh-a:/repo', alias: 'SSH project' },
+ ],
+ }]]);
+ expect(groupSessions([ssh], { remoteProjectAliases }).projects[0].displayName).toBe('SSH project');
+ expect(groupSessions([local, ssh], { remoteProjectAliases }).projects[0].displayName).toBe('repo');
+ });
+});
+
describe('normalizeWorkingDir', () => {
it('returns null for nullish / empty / whitespace', () => {
expect(normalizeWorkingDir(null)).toBeNull();
diff --git a/apps/desktop/src/renderer/__tests__/projectGroupsSelector.test.ts b/apps/desktop/src/renderer/__tests__/projectGroupsSelector.test.ts
index 6e4e3bc321..aa78bbc054 100644
--- a/apps/desktop/src/renderer/__tests__/projectGroupsSelector.test.ts
+++ b/apps/desktop/src/renderer/__tests__/projectGroupsSelector.test.ts
@@ -1,3 +1,8 @@
+/**
+ * Alias regression: the production memoized selector must refresh its displayed name when only
+ * the host snapshot changes. Existing option cases never passed a remote alias map. One unchanged
+ * remote session plus rename/delete snapshots reproduces the stale-cache bug. Pure unit tier.
+ */
import { describe, expect, it } from 'vitest';
import type { Session } from '@/lib/ccAgent.types';
import { groupSessions, type GroupSessionsOptions } from '@/features/cc-agent/lib/projectGrouping';
@@ -238,6 +243,21 @@ describe('project grouping projection', () => {
expect(select(updated, options).bots[0].sessions[0]).toBe(updated[0]);
});
+ // Main's structural reuse must not retain old project names when only the host snapshot changes.
+ it('refreshes a remote project name without requiring its session rows to change', () => {
+ const rows = [session('a', { deviceLinkDeviceId: 'device', workingDir: '/repo' })];
+ const select = createProjectGroupsSelector();
+ expect(select(rows).projects[0].displayName).toBe('repo');
+ const withName = (alias: string): GroupSessionsOptions => ({
+ remoteProjectAliases: new Map([['device', {
+ aliases: [{ projectKey: 'local:/repo', alias }], platform: 'darwin',
+ }]]),
+ });
+ expect(select(rows, withName('Renamed')).projects[0].displayName).toBe('Renamed');
+ expect(select(rows, withName('Changed again')).projects[0].displayName).toBe('Changed again');
+ expect(select(rows, { remoteProjectAliases: new Map() }).projects[0].displayName).toBe('repo');
+ });
+
it('reuses equal persistent catalogues but refreshes changed project metadata', () => {
const rows = [session('a')];
const projects = [
diff --git a/apps/desktop/src/renderer/__tests__/remoteProjectAliases.test.ts b/apps/desktop/src/renderer/__tests__/remoteProjectAliases.test.ts
new file mode 100644
index 0000000000..10caff3be6
--- /dev/null
+++ b/apps/desktop/src/renderer/__tests__/remoteProjectAliases.test.ts
@@ -0,0 +1,110 @@
+/**
+ * Test value: the public renderer mirror must show host aliases without crossing account/link scopes.
+ * The shared mirror suite cannot cover Desktop owner stamps or authenticated preload ingress.
+ * Minimal regressions: one stale read after account/revocation, or generation 8 -> reset -> 1;
+ * an older read must not lower a newer push watermark. Unit tier; no DOM or real transport needed.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { setDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
+import { resetRemoteDataOwnerPushFence } from '@/lib/remoteDataOwnerPushFence';
+import { remoteProjectAliases } from '@/features/device-link/remoteProjectAliases';
+
+const snapshot = (name: string, owner = 'owner') => ({
+ aliases: [{ projectKey: 'local:/repo', alias: name }],
+ platform: 'darwin',
+ ownerStamp: { dataOwnerId: owner, ownerGeneration: 1 },
+});
+const invoke = vi.fn();
+
+beforeEach(() => {
+ remoteProjectAliases.clear();
+ resetRemoteDataOwnerPushFence();
+ setDataOwnerGeneration('owner', 1);
+ invoke.mockReset();
+ vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
+});
+afterEach(() => {
+ remoteProjectAliases.clear();
+ resetRemoteDataOwnerPushFence();
+ setDataOwnerGeneration(null, 0);
+ vi.unstubAllGlobals();
+});
+
+describe('Desktop project alias mirror adapter', () => {
+ it('reads the owning host without writing local aliases and preserves other device snapshots', async () => {
+ invoke.mockResolvedValueOnce(snapshot('A')).mockResolvedValueOnce(snapshot('B'));
+ await remoteProjectAliases.refresh('a', () => true);
+ await remoteProjectAliases.refresh('b', () => true);
+ expect(invoke).toHaveBeenCalledWith('a', 'sidebar-settings:get-project-aliases', []);
+ expect(remoteProjectAliases.getSnapshot().get('a')?.aliases[0].alias).toBe('A');
+ expect(remoteProjectAliases.getSnapshot().get('b')?.aliases[0].alias).toBe('B');
+ remoteProjectAliases.remove('a');
+ expect(remoteProjectAliases.getSnapshot().has('a')).toBe(false);
+ expect(remoteProjectAliases.getSnapshot().get('b')?.aliases[0].alias).toBe('B');
+ });
+
+ it('rejects a different source owner and hides the previous owner immediately on account change', async () => {
+ invoke.mockResolvedValueOnce({ aliases: [{ projectKey: 'local:/repo', alias: 'Unstamped' }], platform: 'darwin' });
+ await remoteProjectAliases.refresh('a', () => true);
+ expect(remoteProjectAliases.getSnapshot().size).toBe(0);
+ invoke.mockResolvedValueOnce(snapshot('Wrong account', 'other'));
+ await remoteProjectAliases.refresh('a', () => true);
+ expect(remoteProjectAliases.getSnapshot().size).toBe(0);
+ invoke.mockResolvedValueOnce(snapshot('Owner project'));
+ await remoteProjectAliases.refresh('a', () => true);
+ expect(remoteProjectAliases.getSnapshot().size).toBe(1);
+ setDataOwnerGeneration('other', 2);
+ expect(remoteProjectAliases.getSnapshot().size).toBe(0);
+ });
+
+ it('accepts a restarted host generation after suspension while rejecting older reads within one link', async () => {
+ invoke.mockResolvedValueOnce({ ...snapshot('Before restart'), ownerStamp: { dataOwnerId: 'owner', ownerGeneration: 8 } });
+ await remoteProjectAliases.refresh('a', () => true);
+ invoke.mockResolvedValueOnce(snapshot('Old generation'));
+ await remoteProjectAliases.refresh('a', () => true);
+ expect(remoteProjectAliases.getSnapshot().get('a')?.aliases[0].alias).toBe('Before restart');
+ remoteProjectAliases.suspend('a');
+ invoke.mockResolvedValueOnce(snapshot('After restart'));
+ await remoteProjectAliases.refresh('a', () => true);
+ expect(remoteProjectAliases.getSnapshot().get('a')?.aliases[0].alias).toBe('After restart');
+ });
+
+ it('keeps a newer push watermark when an older read settles and rejects stale local notifications', async () => {
+ invoke.mockResolvedValueOnce(snapshot('Initial'));
+ await remoteProjectAliases.refresh('a', () => true);
+ let complete!: (value: unknown) => void;
+ invoke.mockImplementationOnce(() => new Promise((resolve) => { complete = resolve; }));
+ const pending = remoteProjectAliases.refresh('a', () => true);
+ await vi.waitFor(() => expect(invoke).toHaveBeenCalledTimes(2));
+ const stamp = { dataOwnerId: 'owner', ownerGeneration: 8 };
+ expect(remoteProjectAliases.acceptChanged('a', stamp, undefined, () => false)).toBe(false);
+ expect(remoteProjectAliases.acceptChanged('a', stamp, { dataOwnerId: 'owner', ownerGeneration: 0 }, () => true)).toBe(false);
+ expect(remoteProjectAliases.acceptChanged('a', stamp, undefined, () => true)).toBe(true);
+ complete(snapshot('Stale response'));
+ await pending;
+ expect(remoteProjectAliases.getSnapshot().get('a')?.aliases[0].alias).toBe('Initial');
+ expect(remoteProjectAliases.acceptChanged('a', { ...stamp, ownerGeneration: 7 }, undefined, () => true)).toBe(false);
+ invoke.mockResolvedValueOnce({ ...snapshot('Fresh'), ownerStamp: stamp });
+ await remoteProjectAliases.refresh('a', () => true);
+ expect(remoteProjectAliases.getSnapshot().get('a')?.aliases[0].alias).toBe('Fresh');
+ });
+
+ it('discards a read settled after account change or device revocation', async () => {
+ let complete!: (value: unknown) => void;
+ invoke.mockImplementation(() => new Promise((resolve) => { complete = resolve; }));
+ const oldAccount = remoteProjectAliases.refresh('a', () => true);
+ await vi.waitFor(() => expect(invoke).toHaveBeenCalledTimes(1));
+ setDataOwnerGeneration('other', 2);
+ complete(snapshot('Old account'));
+ await oldAccount;
+ expect(remoteProjectAliases.getSnapshot().size).toBe(0);
+ let eligible = true;
+ const revoked = remoteProjectAliases.refresh('a', () => eligible);
+ await vi.waitFor(() => expect(invoke).toHaveBeenCalledTimes(2));
+ eligible = false;
+ remoteProjectAliases.remove('a');
+ complete(snapshot('Revoked', 'other'));
+ await revoked;
+ expect(remoteProjectAliases.getSnapshot().size).toBe(0);
+ });
+});
diff --git a/apps/desktop/src/renderer/__tests__/remoteProjectsStartup.test.tsx b/apps/desktop/src/renderer/__tests__/remoteProjectsStartup.test.tsx
index de8e5352e5..c7aa4c8ce2 100644
--- a/apps/desktop/src/renderer/__tests__/remoteProjectsStartup.test.tsx
+++ b/apps/desktop/src/renderer/__tests__/remoteProjectsStartup.test.tsx
@@ -43,6 +43,9 @@ import { remoteProjectsStore } from '@/features/device-link/remoteProjectsStore'
import { useDeviceLinkRemoteProjects } from '@/features/device-link/useDeviceLinkRemoteProjects';
import { useDeviceLinkSettings } from '@/hooks/useDeviceLinkSettings';
import { clearCachedDevice } from '@/features/device-link/mirrorCacheClient';
+import { remoteProjectAliases } from '@/features/device-link/remoteProjectAliases';
+import { setDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
+import { resetRemoteDataOwnerPushFence } from '@/lib/remoteDataOwnerPushFence';
afterEach(() => {
cleanup();
@@ -50,6 +53,8 @@ afterEach(() => {
state.refresh.mockClear();
state.readCache.mockReset().mockResolvedValue([]);
vi.mocked(clearCachedDevice).mockClear();
+ setDataOwnerGeneration(null, 0);
+ resetRemoteDataOwnerPushFence();
Reflect.deleteProperty(window, 'electronAPI');
});
@@ -132,6 +137,68 @@ it('ignores a directory snapshot started before confirmed deletion', async () =>
unmount();
});
+// Test value: real synchronizer hook must publish rename snapshots across bootstrap/push/recovery.
+// Existing bootstrap cases only covered task rows. One peer plus a renamed host snapshot reproduces
+// the missing-project-name synchronization; revoked peers must disappear. Unit/jsdom, fake timers.
+it('refreshes project names on bootstrap, invalidation and reconnect and clears revoked mirrors', async () => {
+ setDataOwnerGeneration('owner', 1);
+ vi.useFakeTimers();
+ const listeners: Record<string, (...args: any[]) => void> = {};
+ let alias = 'Initial name';
+ const invoke = vi.fn(async () => ({
+ aliases: [{ projectKey: 'local:/repo', alias }],
+ platform: 'darwin',
+ ownerStamp: { dataOwnerId: 'owner', ownerGeneration: 1 },
+ }));
+ const api = {
+ invoke,
+ getState: async () => ({ linkStatus: 'online' }),
+ listDevices: async () => ({ devices: [
+ { deviceId: 'peer', name: 'Peer', online: true, remoteControlEnabled: true, isSelf: false },
+ ] }),
+ subscribe: vi.fn(async () => {}),
+ unsubscribe: vi.fn(async () => {}),
+ ...Object.fromEntries([
+ 'ResponsivenessChanged', 'PresenceChanged', 'StatusChanged', 'AccessRevoked',
+ 'ControlTargetChanged', 'RemotePush', 'PeerLinkReset',
+ ].map((name) => [`on${name}`, (callback: (...args: any[]) => void) => {
+ listeners[name] = callback;
+ return () => {};
+ }])),
+ };
+ Object.defineProperty(window, 'electronAPI', { configurable: true, value: { deviceLink: api } });
+ renderHook(() => useDeviceLinkRemoteProjects());
+ await act(async () => { await vi.advanceTimersByTimeAsync(0); });
+ expect(remoteProjectAliases.getSnapshot().get('peer')?.aliases[0].alias).toBe('Initial name');
+ expect(invoke).toHaveBeenCalledWith('peer', 'sidebar-settings:get-project-aliases', []);
+
+ alias = 'Renamed live';
+ await act(async () => {
+ listeners.RemotePush({ deviceId: 'peer', channel: 'local-db:project-aliases:changed', payload: {},
+ ownerStamp: { dataOwnerId: 'owner', ownerGeneration: 1 } });
+ await vi.advanceTimersByTimeAsync(0);
+ });
+ expect(remoteProjectAliases.getSnapshot().get('peer')?.aliases[0].alias).toBe('Renamed live');
+
+ await act(async () => { listeners.StatusChanged({ status: 'connecting' }); });
+ expect(remoteProjectAliases.getSnapshot().get('peer')?.aliases[0].alias).toBe('Renamed live');
+ alias = 'Renamed offline';
+ await act(async () => {
+ listeners.StatusChanged({ status: 'online' });
+ await vi.advanceTimersByTimeAsync(0);
+ });
+ expect(remoteProjectAliases.getSnapshot().get('peer')?.aliases[0].alias).toBe('Renamed offline');
+
+ alias = 'After peer reset';
+ await act(async () => {
+ listeners.PeerLinkReset({ deviceId: 'peer' });
+ await vi.advanceTimersByTimeAsync(0);
+ });
+ expect(remoteProjectAliases.getSnapshot().get('peer')?.aliases[0].alias).toBe('After peer reset');
+ await act(async () => { listeners.AccessRevoked({ deviceId: 'peer' }); });
+ expect(remoteProjectAliases.getSnapshot().has('peer')).toBe(false);
+});
+
it.each(['connecting', 'unknown', 'late-subscribe', 'late-snapshot', 'circuit-subscribe', 'circuit-snapshot'])('handles initial %s state without redundant bootstrap', async (initialStatus) => {
vi.useFakeTimers();
const listeners: Record<string, (...args: any[]) => void> = {};
diff --git a/apps/desktop/src/renderer/features/cc-agent/hooks/useProjectGroups.ts b/apps/desktop/src/renderer/features/cc-agent/hooks/useProjectGroups.ts
index e5cb1bc8e4..cb65f25114 100644
--- a/apps/desktop/src/renderer/features/cc-agent/hooks/useProjectGroups.ts
+++ b/apps/desktop/src/renderer/features/cc-agent/hooks/useProjectGroups.ts
@@ -6,13 +6,14 @@
* Row-only patches reuse membership and ordering, keeping unrelated nodes stable.
*/
-import { useMemo } from 'react';
+import { useMemo, useSyncExternalStore } from 'react';
import { createProjectGroupsSelector } from '../lib/projectGroupsSelector';
import type { Session } from '@/lib/ccAgent.types';
import { useRemoteSshHosts } from '@/hooks/useRemoteSshHosts';
import { buildBotSessionOwners } from '@/features/bots/botSessionOwners';
import { useBotProfiles } from '@/features/bots/botStore';
+import { remoteProjectAliases } from '@/features/device-link/remoteProjectAliases';
import {
type PersistentLocalProject,
type ProjectGroupsResult,
@@ -34,6 +35,7 @@ export function useProjectGroups(
): ProjectGroupsResult {
const sshHosts = useRemoteSshHosts();
const selectGroups = useMemo(() => createProjectGroupsSelector(), []);
+ const hostProjectAliases = useSyncExternalStore(remoteProjectAliases.subscribe, remoteProjectAliases.getSnapshot);
/*
伙伴归属表。会话行本身不带 botId,归属只有伙伴档案知道 —— 档案还没加载完的
那一瞬间这张表是空的,伙伴任务就走原来的分组落到别处,**不会消失**。
@@ -45,6 +47,7 @@ export function useProjectGroups(
if (equivalentResult) return equivalentResult;
return selectGroups(sessions, {
projectAliases,
+ remoteProjectAliases: hostProjectAliases,
includePinnedInProjects,
botOwnerBySessionId,
persistentLocalProjects,
@@ -55,6 +58,7 @@ export function useProjectGroups(
selectGroups,
sessions,
projectAliases,
+ hostProjectAliases,
includePinnedInProjects,
persistentLocalProjects,
localPlatform,
diff --git a/apps/desktop/src/renderer/features/cc-agent/lib/projectGrouping.ts b/apps/desktop/src/renderer/features/cc-agent/lib/projectGrouping.ts
index eeda0eb72e..5f090dc064 100644
--- a/apps/desktop/src/renderer/features/cc-agent/lib/projectGrouping.ts
+++ b/apps/desktop/src/renderer/features/cc-agent/lib/projectGrouping.ts
@@ -42,6 +42,7 @@ import { extractDisplayName, splitPathSegments, tailJoin } from '../../../../sha
export { extractDisplayName } from '../../../../shared/projectDisplayName';
import type { DeviceLinkConnectionStatus, Session } from '@/lib/ccAgent.types';
+import { resolveProjectAliasForSessions, type ProjectAliasesByDevice } from '@cindy/maker-shared/project-alias-sync';
import { isOrcaLeadSession, isOrcaWorkerSession } from '@/lib/orcaSessionIdentity';
import { normalizeWorkingDirForGrouping } from '../../../../shared/workingDir';
import {
@@ -138,6 +139,7 @@ export interface ProjectGroupsResult {
export interface GroupSessionsOptions {
projectAliases?: ReadonlyMap<string, string> | Record<string, string>;
+ remoteProjectAliases?: ProjectAliasesByDevice;
/**
* Build a project catalogue that also contains individually pinned sessions.
* The normal sidebar keeps this false so a pinned conversation only appears
@@ -752,7 +754,10 @@ export function groupSessions(
let name: string;
let segments: number;
- const alias = aliases.get(projectKeyComparisonKey(projectKey, localPlatform) ?? projectKey);
+ const alias = aliases.get(projectKeyComparisonKey(projectKey, localPlatform) ?? projectKey)
+ ?? (options.remoteProjectAliases
+ ? resolveProjectAliasForSessions(sess, options.remoteProjectAliases)
+ : null);
if (alias) {
name = alias;
segments = 0;
diff --git a/apps/desktop/src/renderer/features/cc-agent/lib/projectGroupsSelector.ts b/apps/desktop/src/renderer/features/cc-agent/lib/projectGroupsSelector.ts
index 4df76e6121..664ba4460e 100644
--- a/apps/desktop/src/renderer/features/cc-agent/lib/projectGroupsSelector.ts
+++ b/apps/desktop/src/renderer/features/cc-agent/lib/projectGroupsSelector.ts
@@ -58,6 +58,7 @@ function samePersistentProjects(
function sameOptions(a: GroupSessionsOptions, b: GroupSessionsOptions): boolean {
return (
a.projectAliases === b.projectAliases &&
+ a.remoteProjectAliases === b.remoteProjectAliases &&
a.includePinnedInProjects === b.includePinnedInProjects &&
a.includeDraftsInProjects === b.includeDraftsInProjects &&
a.localPlatform === b.localPlatform &&
diff --git a/apps/desktop/src/renderer/features/device-link/remoteProjectAliases.ts b/apps/desktop/src/renderer/features/device-link/remoteProjectAliases.ts
new file mode 100644
index 0000000000..b6010afca2
--- /dev/null
+++ b/apps/desktop/src/renderer/features/device-link/remoteProjectAliases.ts
@@ -0,0 +1,71 @@
+import {
+ createProjectAliasMirror,
+ PROJECT_ALIASES_GET_CHANNEL,
+ type ProjectAliasesByDevice,
+} from '@cindy/maker-shared/project-alias-sync';
+import {
+ getDataOwnerGeneration,
+ isDataOwnerGenerationCurrent,
+ isDataOwnerPushCurrent,
+ type DataOwnerGeneration,
+} from '@/contexts/dataOwnerGeneration';
+import { parseSyncedProjectOrderOwnerStamp, type SyncedProjectOrderOwnerStamp } from '@cindy/maker-shared/project-order-sync';
+
+const mirror = createProjectAliasMirror();
+const EMPTY: ProjectAliasesByDevice = new Map();
+let owner: DataOwnerGeneration | null = null;
+const ownerStamps = new Map<string, SyncedProjectOrderOwnerStamp>();
+
+function selectOwner(requestOwner: DataOwnerGeneration): void {
+ if (owner && isDataOwnerGenerationCurrent(owner)) return;
+ ownerStamps.clear();
+ mirror.clear();
+ owner = requestOwner;
+}
+
+function acceptOwnerStamp(deviceId: string, raw: unknown): boolean {
+ const stamp = parseSyncedProjectOrderOwnerStamp(raw);
+ if (!stamp || stamp.dataOwnerId !== owner?.dataOwnerId) return false;
+ const previous = ownerStamps.get(deviceId);
+ if (previous && stamp.ownerGeneration < previous.ownerGeneration) return false;
+ ownerStamps.set(deviceId, stamp);
+ return true;
+}
+
+/** Renderer-only display mirror. Its lifecycle is owned by the existing remote-project synchronizer. */
+export const remoteProjectAliases = {
+ subscribe: mirror.subscribe,
+ getSnapshot: (): ProjectAliasesByDevice =>
+ owner && isDataOwnerGenerationCurrent(owner) ? mirror.getSnapshot() : EMPTY,
+ clear(): void {
+ owner = null;
+ ownerStamps.clear();
+ mirror.clear();
+ },
+ remove(deviceId: string): void {
+ ownerStamps.delete(deviceId);
+ mirror.remove(deviceId);
+ },
+ suspend(deviceId: string): void {
+ ownerStamps.delete(deviceId);
+ mirror.suspend(deviceId);
+ },
+ acceptChanged(deviceId: string, ownerStamp: unknown, localOwnerStamp: unknown, isEligible: () => boolean): boolean {
+ const requestOwner = getDataOwnerGeneration();
+ if (!requestOwner.dataOwnerId || !isEligible() || !isDataOwnerPushCurrent(localOwnerStamp)) return false;
+ selectOwner(requestOwner);
+ return acceptOwnerStamp(deviceId, ownerStamp);
+ },
+ refresh(deviceId: string, isEligible: () => boolean, invalidate = false): Promise<void> {
+ const requestOwner = getDataOwnerGeneration();
+ if (!requestOwner.dataOwnerId || !isEligible()) return Promise.resolve();
+ selectOwner(requestOwner);
+ return mirror[invalidate ? 'invalidate' : 'refresh'](
+ deviceId,
+ () => window.electronAPI.deviceLink.invoke(deviceId, PROJECT_ALIASES_GET_CHANNEL, []),
+ (snapshot) => isEligible()
+ && isDataOwnerGenerationCurrent(requestOwner)
+ && (snapshot === undefined || acceptOwnerStamp(deviceId, snapshot.ownerStamp)),
+ );
+ },
+};
diff --git a/apps/desktop/src/renderer/features/device-link/useDeviceLinkRemoteProjects.ts b/apps/desktop/src/renderer/features/device-link/useDeviceLinkRemoteProjects.ts
index e59e94dca1..7662e8b8c7 100644
--- a/apps/desktop/src/renderer/features/device-link/useDeviceLinkRemoteProjects.ts
+++ b/apps/desktop/src/renderer/features/device-link/useDeviceLinkRemoteProjects.ts
@@ -36,6 +36,7 @@ import { useEffect, useRef } from 'react';
import { isSharedTaskPeer } from '@cindy/device-link';
import { projectScheduleEvent } from '@cindy/maker-shared/schedule-events';
import { historyTurnEnded } from '@cindy/maker-shared/message-window';
+import { PROJECT_ALIASES_CHANGED_CHANNEL } from '@cindy/maker-shared/project-alias-sync';
import { useAuth } from '@/contexts/AuthContext';
import { isDeviceLinkRemotePushCurrent } from '@/lib/remoteDataOwnerPushFence';
import { createLogger } from '@/lib/logger';
@@ -72,6 +73,7 @@ import {
prefetchDeviceGitSafetySettings,
} from '@/hooks/useGitSafetySettings';
import { extractIpcError } from '@/utils/ipcError';
+import { remoteProjectAliases } from './remoteProjectAliases';
const log = createLogger('device-link-remote-projects');
@@ -396,6 +398,7 @@ export function useDeviceLinkRemoteProjects(
const ownerBoundaryGeneration = `${dataOwnerId ?? ''}`;
useEffect(() => {
clearMirrorCacheAccountState();
+ remoteProjectAliases.clear();
// 清完必须**主动补读 session-list** 直到拿到新账号的 owner 锚点:
// 1. 主 effect 只依赖 isAuthenticated / selfDeviceId,A→B 直接切换(两者都不变)时不会
// 重跑,而读 session-list 的调用挂在主 effect 里 —— 不补读的话 B 的排程回写会一直
@@ -413,6 +416,7 @@ export function useDeviceLinkRemoteProjects(
if (!isAuthenticated || !selfDeviceId) {
// 同 'stopped' / unmount:cancel 在 clear 之后,免得 clear 的同步通知又排一次回写。
remoteProjectsStore.clear();
+ remoteProjectAliases.clear();
cancelSessionListPersist();
// 登出分支:上面的 dataOwnerId effect 已清 mirror 状态,这里补 cancel 去抖回写。
return;
@@ -522,6 +526,7 @@ export function useDeviceLinkRemoteProjects(
sessionsSubscribeRetry.delete(deviceId);
revokedDevicesStore.markRevoked(deviceId);
remoteProjectsStore.removeDevice(deviceId);
+ remoteProjectAliases.remove(deviceId);
removeRemoteSessionActivityForDevice(deviceId);
// 被控端明确拒绝我们:盘上那份镜像缓存也不该留(尊重对方的拒绝,不在本机留副本)。
cacheHydrationBlocked.add(deviceId);
@@ -540,6 +545,10 @@ export function useDeviceLinkRemoteProjects(
const canBootstrap = (deviceId: string, lifecycleEpoch: number): boolean =>
!disposed && linkOnline !== false && eligible.has(deviceId) && !unresponsiveDevicesStore.has(deviceId) &&
remoteProjectsStore.getDeviceLifecycleEpoch(deviceId) === lifecycleEpoch;
+ const refreshAliases = (deviceId: string, invalidate = false): Promise<void> => {
+ const lifecycleEpoch = remoteProjectsStore.getDeviceLifecycleEpoch(deviceId);
+ return remoteProjectAliases.refresh(deviceId, () => canBootstrap(deviceId, lifecycleEpoch), invalidate);
+ };
const runSubscribeAndBootstrap = async (
deviceId: string,
name: string,
@@ -580,6 +589,7 @@ export function useDeviceLinkRemoteProjects(
if (!canContinue()) return;
// bootstrap 期间被撤销(subscribe 成功、list 被拒)→ refreshRemoteDeviceSessions 返 'revoked'
// (而非静默 give-up)→ 这里 handleRevoked,而不是继续预取能力 / 清撤销标记无视拒绝。
+ void refreshAliases(deviceId);
const result = await refreshRemoteDeviceSessions(deviceId, name, { scope: 'both' });
if (!canContinue()) return;
if (result === 'revoked') return void handleRevoked(deviceId);
@@ -693,8 +703,10 @@ export function useDeviceLinkRemoteProjects(
}
if (action === 'disconnect') {
remoteProjectsStore.markDeviceDisconnected(d.deviceId);
+ remoteProjectAliases.suspend(d.deviceId);
} else {
remoteProjectsStore.removeDevice(d.deviceId);
+ remoteProjectAliases.remove(d.deviceId);
removeRemoteSessionActivityForDevice(d.deviceId);
// 设备明确离场(关被控 / 本机禁用控制 / 是自己):它的冷缓存一起清掉,
// 否则下次冷启动会把一台已经不该出现的设备画回侧边栏。
@@ -741,6 +753,7 @@ export function useDeviceLinkRemoteProjects(
cancelDeviceReseeds(deviceId);
clearArchivedSessionRetry(deviceId);
remoteProjectsStore.removeDevice(deviceId);
+ remoteProjectAliases.remove(deviceId);
removeRemoteSessionActivityForDevice(deviceId);
// 权威列表里没有它 = 明确离场,和撤销 / 关被控同一档:登记进 hydration 黑名单,
// 否则在途的那次 readCachedSessionList 落地后又把它种回来,而紧随的 reseed 在
@@ -831,6 +844,7 @@ export function useDeviceLinkRemoteProjects(
}
// sessions:list 是 200 条有界窗口;refresh 层会保留窗口外 active 行,并有界补查
// 缺席缓存 id 的终态,不能直接把响应缺席解释成删除。
+ void refreshAliases(deviceId);
const result = await refreshRemoteDeviceSessions(deviceId, name, {
scope: 'both',
snapshotMode: 'merge',
@@ -872,7 +886,10 @@ export function useDeviceLinkRemoteProjects(
if (!linkStatusPushSeen) linkOnline = state.linkStatus === 'online';
// Presence can start bootstrap before this initial snapshot settles.
// Reuse disconnect cleanup to clear loading and invalidate in-flight snapshots.
- if (!linkStatusPushSeen && !linkOnline) remoteProjectsStore.markAllDisconnected();
+ if (!linkStatusPushSeen && !linkOnline) {
+ remoteProjectsStore.markAllDisconnected();
+ for (const deviceId of eligible.keys()) remoteProjectAliases.suspend(deviceId);
+ }
if (!controlTargetPushSeen) disabledControlDeviceIds = new Set(state.disabledControlDeviceIds ?? []);
// 「无响应」熔断镜像的初值:按设备合并,已被 push 覆盖的设备以 push 为准
// (store 初始为空,快照只需补写 unresponsive 的未覆盖设备)。
@@ -902,6 +919,12 @@ export function useDeviceLinkRemoteProjects(
// 两套缓存订阅会把完整结果原子推给已挂载选择器,刷新期间保留旧列表避免空白跳变。
const offRemotePush = window.electronAPI.deviceLink.onRemotePush((push, localOwnerStamp) => {
if (disposed || !eligible.has(push.deviceId)) return;
+ if (push.channel === PROJECT_ALIASES_CHANGED_CHANNEL) {
+ const lifecycleEpoch = remoteProjectsStore.getDeviceLifecycleEpoch(push.deviceId);
+ if (remoteProjectAliases.acceptChanged(push.deviceId, push.ownerStamp, localOwnerStamp,
+ () => canBootstrap(push.deviceId, lifecycleEpoch))) void refreshAliases(push.deviceId, true);
+ return;
+ }
if (!isDeviceLinkRemotePushCurrent(push, localOwnerStamp)) return;
if (windowRole === 'main' && push.channel === 'local-db:sessions:patched') {
const payload = push.payload as { sessionId?: string; patch?: { lastTurnEndedAt?: unknown } } | null;
@@ -942,6 +965,7 @@ export function useDeviceLinkRemoteProjects(
linkOnline = p.status === 'online';
if (p.status !== 'online') {
clearAllArchivedSessionRetries();
+ for (const deviceId of eligible.keys()) remoteProjectAliases.suspend(deviceId);
// relay 瞬时重连(connecting):保留远程会话镜像,只标记 disconnected,让 All Sessions
// 不因网络抖动反复增删/重排。eligible 保留不动 → 重连 online 时下面的分支自动
// 重 subscribe+bootstrap。stopped(登出 / 停服)才清空。
@@ -955,6 +979,7 @@ export function useDeviceLinkRemoteProjects(
// (非登出)」会在约 1.2s 后抹掉侧边栏冷缓存 —— 而「停服后重启、relay 仍未恢复」
// 正是这份缓存要解决的场景(review: P2)。整体删除只归 owner 边界的 clearAll。
remoteProjectsStore.clear();
+ remoteProjectAliases.clear();
cancelSessionListPersist();
clearRemoteSessionActivity();
// 'stopped'(登出 / 停服)还要清掉「已撤销」标记:否则切换栏的 buildSwitcherDevices 仍会拿
@@ -973,12 +998,19 @@ export function useDeviceLinkRemoteProjects(
if (!disposed) handleRevoked(p.deviceId);
});
+ // A peer reset can lose invalidations while relay presence stays online.
+ const offPeerReset = window.electronAPI.deviceLink.onPeerLinkReset?.(({ deviceId }) => {
+ remoteProjectAliases.suspend(deviceId);
+ if (!disposed) void refreshAliases(deviceId);
+ });
+
const offControlTarget = window.electronAPI.deviceLink.onControlTargetChanged((p) => {
if (disposed) return;
controlTargetPushSeen = true;
disabledControlDeviceIds = new Set(p.disabledControlDeviceIds ?? []);
if (!p.enabled) {
cancelDeviceReseeds(p.deviceId);
+ remoteProjectAliases.remove(p.deviceId);
clearArchivedSessionRetry(p.deviceId);
const wasEligible = eligible.delete(p.deviceId);
if (wasEligible) {
@@ -1015,6 +1047,7 @@ export function useDeviceLinkRemoteProjects(
cancelDeviceReseeds(deviceId);
clearArchivedSessionRetry(deviceId);
sessionsSubscribeRetry.delete(deviceId);
+ remoteProjectAliases.remove(deviceId);
if (eligible.delete(deviceId)) {
window.electronAPI.deviceLink.unsubscribe(deviceId, ['sessions']).catch(() => {});
}
@@ -1049,6 +1082,7 @@ export function useDeviceLinkRemoteProjects(
offRemotePush();
offStatus();
offAccessRevoked();
+ offPeerReset?.();
offControlTarget();
offRename();
offRemoval();
@@ -1067,6 +1101,7 @@ export function useDeviceLinkRemoteProjects(
// cancel 放在 clear 之后(同 'stopped' 分支):这里 offShardChange 已退订,clear 通知不到
// 任何订阅者,但顺序保持一致,免得将来有人在两者之间插入新的订阅。
remoteProjectsStore.clear();
+ remoteProjectAliases.clear();
cancelSessionListPersist();
clearRemoteSessionActivity();
revokedDevicesStore.clearAll();
diff --git a/apps/mobile/app/devices/[deviceId].tsx b/apps/mobile/app/devices/[deviceId].tsx
index 817e92283d..f859c14ab2 100644
--- a/apps/mobile/app/devices/[deviceId].tsx
+++ b/apps/mobile/app/devices/[deviceId].tsx
@@ -45,6 +45,8 @@ import { formatRemoteError } from '@/device-link/remoteStatus';
import { isExplicitRemoteNotFoundError } from '@/session/newSessionWorktree';
import { withTransientRemoteRetry } from '@/device-link/remoteRetry';
import { useRemoteSyncTask } from '@/device-link/remoteSyncTask';
+import { useRemoteProjectAliases } from '@/session/remoteProjectAliases';
+import { resolveMobileProjectRouteTitle } from '@/session/projectAliasPresentation';
import {
automationGroupKey,
buildRemoteSessionListContext,
@@ -171,7 +173,7 @@ function DeviceDetailScreenContent() {
const deviceName = readRouteString(params.name) ?? readRouteString(params.deviceName) ?? deviceId;
// 从首页「查看全部 N 条对话」进来时带 workingDir + 项目名 → 仅显示该项目的会话(项目作用域)。
const projectWorkingDir = readRouteString(params.workingDir);
- const projectName = readRouteString(params.projectName);
+ const routeProjectName = readRouteString(params.projectName);
// 从自动化组「查看全部 N 次运行」进来时带组键 + 任务名 → 仅显示该任务的运行(自动化任务作用域)。
const automationScopeKey = readRouteString(params.automationGroupKey);
const automationScopeName = readRouteString(params.automationName);
@@ -192,6 +194,7 @@ function DeviceDetailScreenContent() {
const scheduleEventSnapshot = useRemoteScheduleEventSnapshot(deviceId);
const scheduleMirrorInvalidations = useRemoteScheduleMirrorInvalidations();
const allSessions = useRemoteSessions();
+ const projectAliases = useRemoteProjectAliases();
// filter 必须 memo:裸 filter 每次渲染都产新数组,会让下游全部 [sessions, ...] 依赖的
// useMemo 逐 emit 失效,派生链(索引 → sections → 全列表行)整体重建(2026-07-18
// 重渲染风暴)。store 层已保证 allSessions 引用在内容未变时稳定,这里不能亲手打破。
@@ -202,6 +205,13 @@ function DeviceDetailScreenContent() {
() => selectVisibleDeviceSessions(allSessions, deviceId, projectWorkingDir),
[allSessions, deviceId, projectWorkingDir],
);
+ const projectName = useMemo(() => resolveMobileProjectRouteTitle({
+ deviceId,
+ workingDir: projectWorkingDir,
+ routeTitle: routeProjectName,
+ sessions,
+ projectAliases,
+ }), [deviceId, projectAliases, projectWorkingDir, routeProjectName, sessions]);
const messageVersion = useRemoteMessageVersion();
const storeVersion = useRemoteSessionStoreVersion();
const [statusFilter, setStatusFilter] = useState<RemoteSessionStatusFilter>(
@@ -230,8 +240,8 @@ function DeviceDetailScreenContent() {
reachable: !deviceUnresponsive,
}] : []), [deviceId, deviceName, deviceUnresponsive]);
const searchProjects = useMemo(
- () => listConversationSearchProjects(sessions, deviceId ? new Set([deviceId]) : undefined),
- [deviceId, sessions],
+ () => listConversationSearchProjects(sessions, deviceId ? new Set([deviceId]) : undefined, projectAliases),
+ [deviceId, projectAliases, sessions],
);
const indexedSearch = useConversationSearch({
enabled: !automationScopeKey && !!deviceId,
@@ -431,6 +441,8 @@ function DeviceDetailScreenContent() {
const sections = useMemo(
() => buildRemoteSessionSections(sessions, Date.now(), {
+ projectAliases,
+ projectAliasDeviceId: deviceId,
messagePreviewIndex,
pendingInteractionIndex,
scheduleIndex,
@@ -446,6 +458,8 @@ function DeviceDetailScreenContent() {
}),
[
automationScopeKey,
+ deviceId,
+ projectAliases,
i18nInstance.language,
messagePreviewIndex,
pendingInteractionIndex,
diff --git a/apps/mobile/src/__tests__/conversationSearch.test.ts b/apps/mobile/src/__tests__/conversationSearch.test.ts
index 0fc040ea3d..34a810c011 100644
--- a/apps/mobile/src/__tests__/conversationSearch.test.ts
+++ b/apps/mobile/src/__tests__/conversationSearch.test.ts
@@ -285,6 +285,24 @@ describe('searchCachedDeviceSessions', () => {
});
describe('helpers', () => {
+ it('shows project aliases in search filters without changing their stable keys or mixing SSH identities', () => {
+ const local = session({ id: 'local', title: 'Local', workingDir: '/repo/app' });
+ const projectAliases = new Map([['dev-a', {
+ platform: 'darwin',
+ aliases: [{ projectKey: 'local:/repo/app', alias: '黑盒自动化' }],
+ }]]);
+ expect(listConversationSearchProjects([local], undefined, projectAliases)).toMatchObject([
+ { key: 'dev-a:/repo/app', title: '黑盒自动化', workingDir: '/repo/app' },
+ ]);
+ expect(listConversationSearchProjects([
+ local,
+ session({ id: 'ssh', title: 'Remote', workingDir: '/repo/app', remoteHostId: 'ssh-a' }),
+ ], undefined, projectAliases)).toMatchObject([{ key: 'dev-a:/repo/app', title: 'app', count: 2 }]);
+ expect(listConversationSearchProjects([local], undefined, new Map([['dev-a', {
+ platform: 'darwin', aliases: [],
+ }]]))).toMatchObject([{ title: 'app' }]);
+ });
+
it('classifies CHANNEL_NOT_ALLOWED wrappers', () => {
expect(isConversationSearchChannelNotAllowed({
code: 'DEVICE_LINK_CHANNEL_NOT_ALLOWED',
diff --git a/apps/mobile/src/__tests__/homeDisplaySettings.test.ts b/apps/mobile/src/__tests__/homeDisplaySettings.test.ts
index 5d67d7861f..89d93905a8 100644
--- a/apps/mobile/src/__tests__/homeDisplaySettings.test.ts
+++ b/apps/mobile/src/__tests__/homeDisplaySettings.test.ts
@@ -225,8 +225,9 @@ describe('task info and retained Home behavior', () => {
it('keeps real project candidates available despite nonmatching search and status', () => {
const sessions = ['A', 'B'].map((name) => ({ ...item(name).session, title: name, workingDir: '/' + name,
workspaceKind: 'project', status: 'active', deviceLinkDeviceId: 'd', deviceLinkDeviceName: 'Computer' }));
+ // Keep the existing production-expression fixture complete when aliases become an optional Home input.
const result = surfaceValue('projectFilterUniverse', { useMemo, buildMobileHomePresentation,
- deviceModels: [], scheduleIndex: new Map(), selectedDeviceId: null, homeSessions: sessions,
+ projectAliases: new Map(), deviceModels: [], scheduleIndex: new Map(), selectedDeviceId: null, homeSessions: sessions,
t: (key: string) => key, searchQuery: 'no match', statusFilter: 'running' });
expect(result.projects.map((project: { workingDir: string }) => project.workingDir).sort()).toEqual(['/A', '/B']);
});
diff --git a/apps/mobile/src/__tests__/mobileHomeListCache.test.ts b/apps/mobile/src/__tests__/mobileHomeListCache.test.ts
index 7cbfaad44c..3c9991e78c 100644
--- a/apps/mobile/src/__tests__/mobileHomeListCache.test.ts
+++ b/apps/mobile/src/__tests__/mobileHomeListCache.test.ts
@@ -131,6 +131,7 @@ describe('mobileHomeListCache', () => {
source: 'scheduler',
orcaRole: 'lead',
worktreePath: '/repo/demo/.claude/worktrees/x',
+ remoteHostId: 'ssh-build-machine',
}),
]);
@@ -140,6 +141,7 @@ describe('mobileHomeListCache', () => {
expect(cached.source).toBe('scheduler');
expect(cached.orcaRole).toBe('lead');
expect(cached.worktreePath).toBe('/repo/demo/.claude/worktrees/x');
+ expect(cached.remoteHostId).toBe('ssh-build-machine');
expect(cached.hasDraft).toBe(true);
expect(cached.hasPausedQueue).toBe(true);
// 显示菜单「任务信息」的 Token / 费用在行内展示,冷启动也要有。
diff --git a/apps/mobile/src/__tests__/orcaCollab.test.ts b/apps/mobile/src/__tests__/orcaCollab.test.ts
index 4941982740..1a16a4d8bc 100644
--- a/apps/mobile/src/__tests__/orcaCollab.test.ts
+++ b/apps/mobile/src/__tests__/orcaCollab.test.ts
@@ -327,7 +327,8 @@ describe('selectVisibleDeviceSessions', () => {
declarations.join(String.fromCharCode(10)) + '; return { filterCounts, sections };', {
useMemo: (compute: () => unknown) => compute(), selectVisibleDeviceSessions,
buildRemoteSessionSections, summarizeRemoteSessionOverview,
- allSessions, deviceId: 'dev-a', projectWorkingDir: '/repo/cindy',
+ // The real detail sections now also consume alias metadata; worker filtering remains unchanged.
+ projectAliases: new Map(), allSessions, deviceId: 'dev-a', projectWorkingDir: '/repo/cindy',
messagePreviewIndex: new Map(), pendingInteractionIndex: new Map(), scheduleIndex: new Map(),
searchQuery: '', statusFilter: 'all', automationScopeKey: null,
i18nInstance: i18n, t: i18n.t.bind(i18n),
diff --git a/apps/mobile/src/__tests__/projectAliasPresentation.test.ts b/apps/mobile/src/__tests__/projectAliasPresentation.test.ts
new file mode 100644
index 0000000000..9f097f7827
--- /dev/null
+++ b/apps/mobile/src/__tests__/projectAliasPresentation.test.ts
@@ -0,0 +1,32 @@
+// Unit regression: desktop project renames must update an already-open project route title.
+// Existing grouping tests do not cover a retained route hint or a mixed local/SSH group.
+// Minimal input: one /repo/app route, followed by a new host alias and then its removal.
+import { describe, expect, it } from 'vitest';
+import type { HostProjectAliasesSnapshot } from '@cindy/maker-shared/project-alias-sync';
+import { resolveMobileProjectRouteTitle } from '@/session/projectAliasPresentation';
+import type { RemoteSession } from '@/session/types';
+
+const session = { workingDir: '/repo/app', deviceLinkDeviceId: 'desktop' } as RemoteSession;
+const input = {
+ deviceId: 'desktop', workingDir: '/repo/app', routeTitle: '进入时旧名', sessions: [session],
+};
+const aliases = (name?: string): Map<string, HostProjectAliasesSnapshot> => new Map([['desktop', {
+ platform: 'darwin',
+ aliases: name ? [{ projectKey: 'local:/repo/app', alias: name }] : [],
+}]]);
+
+describe('project detail route title', () => {
+ it('updates an already-open header and restores the directory name when its alias is removed', () => {
+ expect(resolveMobileProjectRouteTitle({ ...input, projectAliases: new Map() })).toBe('进入时旧名');
+ expect(resolveMobileProjectRouteTitle({ ...input, projectAliases: aliases('改名后的项目') })).toBe('改名后的项目');
+ expect(resolveMobileProjectRouteTitle({ ...input, projectAliases: aliases() })).toBe('app');
+ });
+
+ it('does not assign a local alias to a mixed local and SSH project group', () => {
+ expect(resolveMobileProjectRouteTitle({
+ ...input,
+ sessions: [session, { ...session, remoteHostId: 'ssh-a' }],
+ projectAliases: aliases('本地专属名'),
+ })).toBe('app');
+ });
+});
diff --git a/apps/mobile/src/__tests__/projectAliasProvider.test.tsx b/apps/mobile/src/__tests__/projectAliasProvider.test.tsx
new file mode 100644
index 0000000000..1d152c50ba
--- /dev/null
+++ b/apps/mobile/src/__tests__/projectAliasProvider.test.tsx
@@ -0,0 +1,176 @@
+// @vitest-environment jsdom
+// Unit regression: use the real DeviceLinkProvider, registry and mirror so metadata stays current across owner release/background.
+// Generic mirror tests cannot detect Provider wiring errors. Minimal failure: home owns sessions while another
+// page releases session:task, or the last owner leaves/returns before the first alias response.
+import { act, createElement } from 'react';
+import { createRoot, type Root } from 'react-dom/client';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { Envelope, InvokePayload, InvokeResultPayload, LinkAcceptPayload } from '@cindy/device-link';
+import { PROJECT_ALIASES_GET_CHANNEL, PROJECT_ALIASES_CHANGED_CHANNEL } from '@cindy/maker-shared/project-alias-sync';
+import { DeviceLinkProvider, useDeviceLink, type DeviceLinkContextValue } from '@/device-link/DeviceLinkContext';
+import { remoteProjectAliasesSnapshot, useRemoteProjectAliases } from '@/session/remoteProjectAliases';
+import { buildMobileHomePresentation } from '@/session/mobileHome';
+
+const auth = vi.hoisted(() => ({
+ isAuthenticated: true,
+ accountGeneration: 0,
+ user: { id: 'test-account' },
+ getAccessToken: vi.fn(async () => 'test-token'),
+ apiFetch: vi.fn(async () => ({ devices: [] })),
+}));
+vi.mock('@/auth/AuthContext', () => ({ useAuth: () => auth }));
+const appState = vi.hoisted(() => ({ state: 'active', change: (_next: string) => {} }));
+vi.mock('react-native', () => ({
+ Platform: { OS: 'android' },
+ AppState: {
+ get currentState() { return appState.state; },
+ addEventListener: (_event: string, listener: typeof appState.change) => {
+ appState.change = listener;
+ return { remove() {} };
+ },
+ },
+}));
+vi.mock('expo-network', () => ({ getNetworkStateAsync: vi.fn(async () => ({ isConnected: true })), addNetworkStateListener: () => ({ remove() {} }) }));
+vi.mock('expo-secure-store', () => ({
+ getItemAsync: vi.fn(async () => null), setItemAsync: vi.fn(async () => {}), deleteItemAsync: vi.fn(async () => {}),
+}));
+vi.mock('@react-native-async-storage/async-storage', () => ({ default: {
+ getItem: vi.fn(async () => null), setItem: vi.fn(async () => {}), removeItem: vi.fn(async () => {}),
+ getAllKeys: vi.fn(async () => []), multiRemove: vi.fn(async () => {}),
+} }));
+// Native WebView lifecycle has separate coverage; this suite exercises Provider subscriptions.
+vi.mock('@/device-link/DirectLinkTransport', () => ({ DirectLinkTransport: () => null }));
+vi.mock('expo-updates', () => ({ updateId: null, runtimeVersion: null, isEmbeddedLaunch: true }));
+vi.mock('@/device-link/rnWebSocket', () => ({ createRnWebSocket: vi.fn() }));
+vi.mock('@/debug/mobileDebugLog', () => ({ mobileDebugLog: vi.fn() }));
+vi.mock('@/debug/visualMock', () => ({ prepareVisualMockDeviceLinkContext: vi.fn() }));
+
+// Keep the actual Provider, registry, ACK table and alias mirror. Only the wire is fake.
+const transport = vi.hoisted(() => {
+ class Client {
+ invoke = vi.fn<(_device: string, request: InvokePayload) => Promise<InvokeResultPayload>>();
+ openLink = vi.fn(async (): Promise<LinkAcceptPayload> => ({ appVersion: 'test', allowlistHash: 'test' }));
+ start = vi.fn();
+ stop = vi.fn();
+ connectNow = vi.fn();
+ notifyNetworkChanged = vi.fn();
+ getStatus = () => 'online';
+ hasServerCapability = () => false;
+ isOutboundExplicitlyClosed = () => false;
+ hasPendingRequestsTo = () => false;
+ onStatusChange = () => () => {};
+ onPresenceChanged = () => () => {};
+ onPeerTransportReset = () => () => {};
+ onConnectionIssue = () => () => {};
+ frame: (envelope: Envelope) => void = () => {};
+ onFrame(listener: Client['frame']) { this.frame = listener; return () => {}; }
+ onReliableFrameBeforeLink = () => () => {};
+ }
+ return { Client, clients: [] as Client[] };
+});
+vi.mock('@cindy/device-link', async (importOriginal) => ({
+ ...await importOriginal<typeof import('@cindy/device-link')>(),
+ DeviceLinkClient: class extends transport.Client {
+ constructor() { super(); transport.clients.push(this); }
+ },
+}));
+
+Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
+let root: Root;
+let context: DeviceLinkContextValue;
+let aliasReads: Array<(alias: string | null) => void>;
+let container: HTMLDivElement;
+const sessions = [{ id: 'one', title: 'unchanged task', workingDir: '/repo/app', deviceLinkDeviceId: 'host',
+ workspaceKind: 'project' as const, status: 'active' as const, agentKind: 'cc' as const, model: 'model',
+ createdAt: '2026-10-23T00:00:00.000Z', updatedAt: '2026-10-23T00:00:00.000Z' }];
+function Probe() {
+ context = useDeviceLink();
+ const projectAliases = useRemoteProjectAliases();
+ return createElement('div', null, buildMobileHomePresentation({ sessions, projectAliases }).projects[0]?.title);
+}
+const currentAlias = () => remoteProjectAliasesSnapshot().get('host')?.aliases[0]?.alias;
+
+beforeEach(async () => {
+ auth.accountGeneration += 1;
+ appState.state = 'active';
+ transport.clients.length = 0;
+ aliasReads = [];
+ container = document.createElement('div');
+ root = createRoot(container);
+ await act(async () => root.render(createElement(DeviceLinkProvider, null, createElement(Probe))));
+ transport.clients[0].invoke.mockImplementation(async (_deviceId, request) => {
+ if (request.channel !== PROJECT_ALIASES_GET_CHANNEL) return { ok: true, result: [] };
+ return new Promise<InvokeResultPayload>((resolve) => {
+ aliasReads.push((alias) => resolve({ ok: true, result: {
+ aliases: alias === null ? [] : [{ projectKey: 'local:/repo/app', alias }],
+ platform: 'darwin',
+ ownerStamp: { dataOwnerId: 'test-account', ownerGeneration: 1 },
+ } }));
+ });
+ });
+});
+afterEach(async () => {
+ await act(async () => {
+ root.unmount();
+ for (const resolve of aliasReads) resolve('finished after unmount');
+ });
+});
+
+describe('project aliases follow the Provider sessions subscription lifetime', () => {
+ // The real React mirror subscription must update a mounted presentation without any session mutation.
+ it('updates a mounted project heading on host rename and removal notifications', async () => {
+ await act(async () => context.subscribe('home', 'host', ['sessions']));
+ expect(container.textContent).toBe('app');
+ await act(async () => aliasReads[0]('电脑改后的项目名'));
+ expect(container.textContent).toBe('电脑改后的项目名');
+ await act(async () => transport.clients[0].frame({
+ kind: 'push', src: 'host', dst: 'controller',
+ payload: { channel: PROJECT_ALIASES_CHANGED_CHANNEL, payload: {},
+ ownerStamp: { dataOwnerId: 'test-account', ownerGeneration: 1 } },
+ } as Envelope));
+ expect(aliasReads).toHaveLength(2);
+ await act(async () => aliasReads[1](null));
+ expect(container.textContent).toBe('app');
+ expect(sessions[0].title).toBe('unchanged task');
+ });
+
+ it('keeps the home alias read alive when another owner releases its individual session stream', async () => {
+ await act(async () => {
+ await context.subscribe('home', 'host', ['sessions']);
+ await context.subscribe('conversation', 'host', ['sessions', 'session:task']);
+ });
+ expect(aliasReads).toHaveLength(1);
+ await act(async () => context.unsubscribe('conversation', 'host', ['sessions', 'session:task']));
+ await act(async () => aliasReads[0]('仍属于首页的项目名'));
+ expect(currentAlias()).toBe('仍属于首页的项目名');
+ });
+
+ it('starts a new read after the last owner leaves and immediately returns, fencing the old response', async () => {
+ await act(async () => context.subscribe('home', 'host', ['sessions']));
+ expect(aliasReads).toHaveLength(1);
+ await act(async () => {
+ await context.unsubscribe('home', 'host', ['sessions']);
+ await context.subscribe('home', 'host', ['sessions']);
+ });
+ expect(aliasReads).toHaveLength(2);
+ await act(async () => aliasReads[1]('重新进入后的项目名'));
+ expect(currentAlias()).toBe('重新进入后的项目名');
+ await act(async () => aliasReads[0]('离开前的旧项目名'));
+ expect(currentAlias()).toBe('重新进入后的项目名');
+ });
+
+ it('refreshes a sessions-only page after a short background stay without waiting for its old read', async () => {
+ await act(async () => context.subscribe('home', 'host', ['sessions']));
+ expect(aliasReads).toHaveLength(1);
+ await act(async () => {
+ appState.state = 'background'; appState.change('background');
+ appState.state = 'active'; appState.change('active');
+ });
+ await vi.waitFor(() => expect(aliasReads).toHaveLength(2));
+ await act(async () => aliasReads[1]('回到前台后的项目名'));
+ expect(currentAlias()).toBe('回到前台后的项目名');
+ await act(async () => aliasReads[0]('后台迟到项目名'));
+ expect(currentAlias()).toBe('回到前台后的项目名');
+ expect(transport.clients[0].stop).not.toHaveBeenCalled();
+ });
+});
diff --git a/apps/mobile/src/__tests__/remoteProjectAliases.test.ts b/apps/mobile/src/__tests__/remoteProjectAliases.test.ts
new file mode 100644
index 0000000000..8c60258e8b
--- /dev/null
+++ b/apps/mobile/src/__tests__/remoteProjectAliases.test.ts
@@ -0,0 +1,140 @@
+// Unit regression: the mobile mirror must reject prior-account/connection replies while retaining current project names.
+// Existing generic mirror tests lack mobile owner stamps/topic ownership. Minimal failure: one pending read,
+// then account switch, peer suspend or last sessions-owner release before that read resolves.
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+ acceptRemoteProjectAliasesChanged,
+ refreshRemoteProjectAliases,
+ remoteProjectAliasesSnapshot,
+ removeRemoteProjectAliases,
+ setRemoteProjectAliasesAccount,
+ suspendRemoteProjectAliases,
+ suspendRemoteProjectAliasesForReleasedTopics,
+} from '@/session/remoteProjectAliases';
+import { DeviceLinkTopicRegistry } from '@/device-link/topicRegistry';
+
+let generation = 0;
+const snapshot = (alias: string, owner = 'user-a', ownerGeneration = 1) => ({
+ aliases: [{ projectKey: 'local:/repo/app', alias }],
+ platform: 'darwin',
+ ownerStamp: { dataOwnerId: owner, ownerGeneration },
+});
+
+describe('mobile project alias ownership', () => {
+ beforeEach(() => setRemoteProjectAliasesAccount('user-a', ++generation));
+
+ it('discards an account-switched response and clears the previous account before the next read', async () => {
+ await refreshRemoteProjectAliases('desktop', async () => snapshot('旧账号'));
+ let finish!: (value: unknown) => void;
+ const pending = refreshRemoteProjectAliases('desktop', () => new Promise((resolve) => { finish = resolve; }));
+ await vi.waitFor(() => expect(finish).toBeTypeOf('function'));
+ setRemoteProjectAliasesAccount('user-b', ++generation);
+ expect(remoteProjectAliasesSnapshot().size).toBe(0);
+ finish(snapshot('迟到旧账号'));
+ await pending;
+ expect(remoteProjectAliasesSnapshot().size).toBe(0);
+ await refreshRemoteProjectAliases('desktop', async () => snapshot('新账号', 'user-b'));
+ expect(remoteProjectAliasesSnapshot().get('desktop')?.aliases[0].alias).toBe('新账号');
+ });
+
+ it('accepts only current-account, nonobsolete notifications and snapshots', async () => {
+ expect(acceptRemoteProjectAliasesChanged('desktop', undefined)).toBe(false);
+ expect(acceptRemoteProjectAliasesChanged('desktop', { dataOwnerId: 'user-b', ownerGeneration: 2 })).toBe(false);
+ expect(acceptRemoteProjectAliasesChanged('desktop', { dataOwnerId: 'user-a', ownerGeneration: 3 })).toBe(true);
+ expect(acceptRemoteProjectAliasesChanged('desktop', { dataOwnerId: 'user-a', ownerGeneration: 2 })).toBe(false);
+ await refreshRemoteProjectAliases('desktop', async () => ({
+ aliases: [{ projectKey: 'local:/repo/app', alias: '缺少归属' }],
+ platform: 'darwin',
+ }));
+ expect(remoteProjectAliasesSnapshot().has('desktop')).toBe(false);
+ await refreshRemoteProjectAliases('desktop', async () => snapshot('其他账号', 'user-b', 3));
+ expect(remoteProjectAliasesSnapshot().has('desktop')).toBe(false);
+ await refreshRemoteProjectAliases('desktop', async () => snapshot('旧代', 'user-a', 2));
+ expect(remoteProjectAliasesSnapshot().has('desktop')).toBe(false);
+ await refreshRemoteProjectAliases('desktop', async () => snapshot('当前代', 'user-a', 3));
+ expect(remoteProjectAliasesSnapshot().get('desktop')?.aliases[0].alias).toBe('当前代');
+ });
+
+ // A rejected stale read retains the old visible mirror; it must not lower the newer push watermark.
+ it('keeps a newer notification watermark after rejecting an older read over an existing mirror', async () => {
+ await refreshRemoteProjectAliases('desktop', async () => snapshot('已知名称', 'user-a', 1));
+ expect(acceptRemoteProjectAliasesChanged('desktop', snapshot('新通知', 'user-a', 3).ownerStamp)).toBe(true);
+ await refreshRemoteProjectAliases('desktop', async () => snapshot('迟到读取', 'user-a', 2));
+ expect(remoteProjectAliasesSnapshot().get('desktop')?.aliases[0].alias).toBe('已知名称');
+ expect(acceptRemoteProjectAliasesChanged('desktop', snapshot('旧通知', 'user-a', 2).ownerStamp)).toBe(false);
+ await refreshRemoteProjectAliases('desktop', async () => snapshot('旧代重试', 'user-a', 2));
+ expect(remoteProjectAliasesSnapshot().get('desktop')?.aliases[0].alias).toBe('已知名称');
+ });
+
+ it('retains names during a disconnect, rejects late reads, and permits a restarted host generation', async () => {
+ await refreshRemoteProjectAliases('desktop', async () => snapshot('已知名称', 'user-a', 5));
+ let finish!: (value: unknown) => void;
+ const pending = refreshRemoteProjectAliases('desktop', () => new Promise((resolve) => { finish = resolve; }));
+ await vi.waitFor(() => expect(finish).toBeTypeOf('function'));
+ suspendRemoteProjectAliases('desktop');
+ expect(acceptRemoteProjectAliasesChanged('desktop', snapshot('迟到通知', 'user-a', 5).ownerStamp, () => false)).toBe(false);
+ finish(snapshot('迟到', 'user-a', 5));
+ await pending;
+ expect(remoteProjectAliasesSnapshot().get('desktop')?.aliases[0].alias).toBe('已知名称');
+ await refreshRemoteProjectAliases('desktop', async () => snapshot('重启后名称', 'user-a', 1));
+ expect(remoteProjectAliasesSnapshot().get('desktop')?.aliases[0].alias).toBe('重启后名称');
+ });
+
+ // Reconnect can fail once before a restarted host responds with a lower generation.
+ // A retained display snapshot must not restore the suspended connection's owner watermark.
+ it('accepts a restarted host after the first reconnect read fails while retaining its old display name', async () => {
+ await refreshRemoteProjectAliases('desktop', async () => snapshot('重启前名称', 'user-a', 8));
+ suspendRemoteProjectAliases('desktop');
+ await refreshRemoteProjectAliases('desktop', async () => { throw new Error('temporary network failure'); });
+ expect(remoteProjectAliasesSnapshot().get('desktop')?.aliases[0].alias).toBe('重启前名称');
+ await refreshRemoteProjectAliases('desktop', async () => snapshot('重启后名称', 'user-a', 1));
+ expect(remoteProjectAliasesSnapshot().get('desktop')?.aliases[0].alias).toBe('重启后名称');
+ });
+
+ it('does not start metadata reads outside an active subscription and removes revoked device data only', async () => {
+ const read = vi.fn(async () => snapshot('当前项目'));
+ await refreshRemoteProjectAliases('desktop-a', read, () => false);
+ expect(read).not.toHaveBeenCalled();
+ await refreshRemoteProjectAliases('desktop-a', read);
+ await refreshRemoteProjectAliases('desktop-b', read);
+ removeRemoteProjectAliases('desktop-a');
+ expect([...remoteProjectAliasesSnapshot().keys()]).toEqual(['desktop-b']);
+ });
+
+ it('keeps other owners reads alive and starts a fresh read after the last owner leaves and reenters', async () => {
+ const registry = new DeviceLinkTopicRegistry();
+ registry.trackSubscribe('home', 'desktop', ['sessions']);
+ registry.trackSubscribe('drawer', 'desktop', ['sessions']);
+ const isCurrent = () => registry.hasTopic('desktop', 'sessions');
+ let finish!: (value: unknown) => void;
+ const pending = refreshRemoteProjectAliases('desktop', () => new Promise((resolve) => { finish = resolve; }), isCurrent);
+ await vi.waitFor(() => expect(finish).toBeTypeOf('function'));
+ suspendRemoteProjectAliasesForReleasedTopics('desktop', registry.untrackSubscribe('drawer', 'desktop', ['sessions']));
+ finish(snapshot('仍被首页订阅'));
+ await pending;
+ expect(remoteProjectAliasesSnapshot().get('desktop')?.aliases[0].alias).toBe('仍被首页订阅');
+
+ let finishOldRead!: (value: unknown) => void;
+ const oldRead = refreshRemoteProjectAliases('desktop', () => new Promise((resolve) => { finishOldRead = resolve; }), isCurrent);
+ await vi.waitFor(() => expect(finishOldRead).toBeTypeOf('function'));
+ suspendRemoteProjectAliasesForReleasedTopics('desktop', registry.untrackSubscribe('home', 'desktop', ['sessions']));
+ registry.trackSubscribe('home', 'desktop', ['sessions']);
+ const newRead = vi.fn(async () => snapshot('重新进入后的名称'));
+ await refreshRemoteProjectAliases('desktop', newRead, isCurrent);
+ expect(newRead).toHaveBeenCalledOnce();
+ finishOldRead(snapshot('离开前迟到的旧名称'));
+ await oldRead;
+ expect(remoteProjectAliasesSnapshot().get('desktop')?.aliases[0].alias).toBe('重新进入后的名称');
+ });
+
+ it('starts a fresh foreground read even when background suspension interrupted the first snapshot', async () => {
+ let finish!: (value: unknown) => void;
+ const backgroundRead = refreshRemoteProjectAliases('desktop', () => new Promise((resolve) => { finish = resolve; }));
+ await vi.waitFor(() => expect(finish).toBeTypeOf('function'));
+ suspendRemoteProjectAliases();
+ await refreshRemoteProjectAliases('desktop', async () => snapshot('回前台后的名称'));
+ finish(snapshot('后台迟到名称'));
+ await backgroundRead;
+ expect(remoteProjectAliasesSnapshot().get('desktop')?.aliases[0].alias).toBe('回前台后的名称');
+ });
+});
diff --git a/apps/mobile/src/device-link/DeviceLinkContext.tsx b/apps/mobile/src/device-link/DeviceLinkContext.tsx
index 57a850aba7..92b2d4aa3d 100644
--- a/apps/mobile/src/device-link/DeviceLinkContext.tsx
+++ b/apps/mobile/src/device-link/DeviceLinkContext.tsx
@@ -42,7 +42,16 @@ import {
type Topic,
decodeModelSpeedPayload,
} from '@cindy/device-link';
-import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore, type ReactNode } from 'react';
+import { createContext, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore, type ReactNode } from 'react';
+import { PROJECT_ALIASES_GET_CHANNEL, PROJECT_ALIASES_CHANGED_CHANNEL } from '@cindy/maker-shared/project-alias-sync';
+import {
+ acceptRemoteProjectAliasesChanged,
+ refreshRemoteProjectAliases,
+ removeRemoteProjectAliases,
+ setRemoteProjectAliasesAccount,
+ suspendRemoteProjectAliases,
+ suspendRemoteProjectAliasesForReleasedTopics,
+} from '@/session/remoteProjectAliases';
import { deviceLinkWsUrl, DEVICE_LINK_API_BASE_URL } from '@/config/env';
import { MOBILE_VISUAL_MOCK_ENABLED } from '@/config/env';
import { useAuth } from '@/auth/AuthContext';
@@ -391,6 +400,9 @@ export function DeviceLinkProvider({ children }: { children: ReactNode }) {
const sharedTaskApi = useSharedTaskApi();
const currentDataOwnerIdRef = useRef<string | null>(auth.user?.id ?? null);
currentDataOwnerIdRef.current = auth.user?.id ?? null;
+ useLayoutEffect(() => {
+ setRemoteProjectAliasesAccount(auth.isAuthenticated ? auth.user?.id ?? null : null, auth.accountGeneration);
+ }, [auth.accountGeneration, auth.isAuthenticated, auth.user?.id]);
const clientRef = useRef<DeviceLinkClient | null>(null);
const registryRef = useRef(new DeviceLinkTopicRegistry());
const [subscriptionVersion, setSubscriptionVersion] = useState(0);
@@ -588,6 +600,32 @@ export function DeviceLinkProvider({ children }: { children: ReactNode }) {
}
}, [sendOpenLinkOnce]);
+ const refreshProjectAliasesForClient = useCallback((
+ client: DeviceLinkClient,
+ deviceId: string,
+ invalidated = false,
+ ownerStamp?: unknown,
+ ): void => {
+ const epoch = connectionEpochRef.current;
+ const isCurrent = () => clientRef.current === client
+ && client.getStatus() === 'online'
+ && connectionEpochRef.current === epoch
+ && remoteSubscribedTopicsRef.current.get(deviceId)?.has('sessions') === true
+ && registryRef.current.hasTopic(deviceId, 'sessions')
+ && !backgroundReleaseInFlightRef.current
+ && !revokedDevicesStore.has(deviceId)
+ && presenceAvailableByDeviceRef.current.get(deviceId) !== false;
+ // A delayed push from a suspended peer must not restore its previous owner watermark.
+ if (!isCurrent() || (invalidated && !acceptRemoteProjectAliasesChanged(deviceId, ownerStamp, isCurrent))) return;
+ void refreshRemoteProjectAliases(deviceId, () => sendInvokeWithAccessHandling(
+ client, deviceId, PROJECT_ALIASES_GET_CHANNEL, [], {
+ preSend: () => {
+ if (!isCurrent()) throw new DeviceLinkError('NOT_CONNECTED', 'project alias read superseded');
+ },
+ },
+ ), isCurrent, invalidated);
+ }, []);
+
const sendTrackedSubscribe = useCallback(async (
client: DeviceLinkClient,
deviceId: string,
@@ -620,7 +658,8 @@ export function DeviceLinkProvider({ children }: { children: ReactNode }) {
mobileDebugLog('debug', 'recovery', 'subscription acknowledged', { topicCount: held.length });
},
});
- }, []);
+ if (topics.includes('sessions')) refreshProjectAliasesForClient(client, deviceId);
+ }, [refreshProjectAliasesForClient]);
// 熔断 open 设备的显式代表性探测:openLink 建链(成功按不定论,不关熔断),
// 再发一条真正穿过被控端 runInvoke → dispatchLocalInvoke → local-db 的最小读,
@@ -793,6 +832,7 @@ export function DeviceLinkProvider({ children }: { children: ReactNode }) {
wipeUnavailableDeviceMirror(deviceId);
},
onDeviceUnavailable: (deviceId) => {
+ suspendRemoteProjectAliases(deviceId);
if (isSharedTaskPeer(deviceId)) {
// Logical peers have no same-account presence entry. Preserve the
// existing bounded peer retry instead of waiting for an impossible
@@ -1079,6 +1119,7 @@ export function DeviceLinkProvider({ children }: { children: ReactNode }) {
connectionEpochRef.current = ++nextDeviceLinkConnectionEpoch;
setConnectionEpoch(connectionEpochRef.current);
resetRemoteProjectOrderPushFence();
+ suspendRemoteProjectAliases();
restorePendingReplyLinks(client);
void rehydrate();
// A new controller receives only presence deltas. Read the roster once so
@@ -1089,6 +1130,7 @@ export function DeviceLinkProvider({ children }: { children: ReactNode }) {
// 这是本地 ACK 超时,不是对端可达证据:只失效该 peer 的建链缓存和
// 订阅 ACK,再排该 peer 恢复;presence、其它 peer 与共享 WSS 均不动。
resetRemoteProjectOrderPushFence(deviceId);
+ suspendRemoteProjectAliases(deviceId);
const shouldRecover = requestForcedPeerRecovery(client, deviceId);
invalidatePeerLinkState(
deviceId,
@@ -1114,6 +1156,7 @@ export function DeviceLinkProvider({ children }: { children: ReactNode }) {
presenceUnavailableVerdictsRef.current.delete(snap.deviceId);
} else {
// Relay presence 是权威 availability verdict,普通目标应答不能推翻。
+ suspendRemoteProjectAliases(snap.deviceId);
presenceUnavailableVerdictsRef.current.set(snap.deviceId, {
kind: snap.online && !snap.remoteControlEnabled ? 'disabled' : 'presence',
responseEvidenceEpoch: capturePresenceAvailabilityEpoch(
@@ -1192,6 +1235,7 @@ export function DeviceLinkProvider({ children }: { children: ReactNode }) {
clearOnePresenceWipeTimer(presenceWipeTimersRef.current, deviceId);
if (isSharedTaskPeer(deviceId)) setPresenceVersion((version) => version + 1);
catalogRefresh.cancel(deviceId);
+ removeRemoteProjectAliases(deviceId);
remoteSubscribedTopicsRef.current.delete(deviceId);
forcedPeerRecoveryIntentRef.current.cancel(deviceId);
peerRecoverySchedulerRef.current?.cancel(deviceId);
@@ -1201,6 +1245,7 @@ export function DeviceLinkProvider({ children }: { children: ReactNode }) {
if (isSharedTaskPeer(deviceId)) setPresenceVersion((version) => version + 1);
catalogRefresh.cancel(deviceId);
resetRemoteProjectOrderPushFence(deviceId);
+ suspendRemoteProjectAliases(deviceId);
updateRehydrateSuppressionOnLinkClose(
rehydrateSuppressedDeviceIds,
deviceId,
@@ -1247,6 +1292,7 @@ export function DeviceLinkProvider({ children }: { children: ReactNode }) {
forcedPeerRecoveryIntentRef.current.cancel(deviceId);
}
},
+ onProjectAliasesChanged: (deviceId, ownerStamp) => refreshProjectAliasesForClient(client, deviceId, true, ownerStamp),
onProviderChanged: (deviceId) => {
catalogRefresh.notify(deviceId);
},
@@ -1392,6 +1438,7 @@ export function DeviceLinkProvider({ children }: { children: ReactNode }) {
diagnostics.background();
backgroundReleaseInFlightRef.current = true;
backgroundReleaseGenerationRef.current += 1;
+ suspendRemoteProjectAliases();
// App 生命周期暂停全部恢复执行,但各 peer 状态仍彼此独立;回前台统一
// 重新排队,旧代请求的迟到结果不会创建重试。
peerRecoverySchedulerRef.current?.pause();
@@ -1505,6 +1552,7 @@ export function DeviceLinkProvider({ children }: { children: ReactNode }) {
restorePendingReplyLinks,
requestForcedPeerRecovery,
readDeviceList,
+ refreshProjectAliasesForClient,
]);
const openLink = useCallback(
@@ -1551,7 +1599,7 @@ export function DeviceLinkProvider({ children }: { children: ReactNode }) {
};
preSend();
const client = requireClient(clientRef.current);
- return invokeWithHistoryViewCapability(
+ const result = await invokeWithHistoryViewCapability(
channel,
async () => {
// Reuse the existing peer-scoped handshake cache and its invalidation.
@@ -1576,7 +1624,11 @@ export function DeviceLinkProvider({ children }: { children: ReactNode }) {
return sendInvokeWithAccessHandling<T>(client, deviceId, channel, args, { preSend, background: opts?.background });
},
);
- }, [sendOpenLinkOnce]);
+ // Existing list refreshes also reconcile optional project display names. This read
+ // is single-flight and never changes task-list success or connection recovery.
+ if (channel === 'local-db:sessions:list') refreshProjectAliasesForClient(client, deviceId);
+ return result;
+ }, [refreshProjectAliasesForClient, sendOpenLinkOnce]);
const subscribe = useCallback(async (owner: string, deviceId: string, topics: string[]) => {
topics = sharedTaskTopics(deviceId, topics);
@@ -1603,6 +1655,7 @@ export function DeviceLinkProvider({ children }: { children: ReactNode }) {
isDeviceLinkTopic(topic) && !releasedSet.has(topic) && !registryRef.current.hasTopic(deviceId, topic));
const toSend = normalizeDeviceLinkTopics([...new Set([...released, ...staleUnheld])]);
markRemoteTopicsUnsubscribed(remoteSubscribedTopicsRef.current, deviceId, toSend);
+ suspendRemoteProjectAliasesForReleasedTopics(deviceId, toSend);
noteSessionLiveStreamsInterrupted(toSend);
if (toSend.length === 0 || presenceAvailableByDeviceRef.current.get(deviceId) === false) return;
await sendUnsubscribe(
@@ -1686,6 +1739,7 @@ type RouteFrameHandlers = {
onLinkClosed?: (deviceId: string, reason?: string) => void;
onProviderChanged?: (deviceId: string) => void;
onAgentsChanged?: (deviceId: string) => void;
+ onProjectAliasesChanged?: (deviceId: string, ownerStamp: unknown) => void;
};
/** routeFrame plus per-channel push handling time while local diagnostics record. */
@@ -1731,6 +1785,10 @@ export function routeFrame(env: Envelope, handlers: RouteFrameHandlers = {}): vo
for (const listener of remoteFavoritesChangedListeners) listener(env.src);
return;
}
+ if (push.channel === PROJECT_ALIASES_CHANGED_CHANNEL) {
+ handlers.onProjectAliasesChanged?.(env.src, push.ownerStamp);
+ return;
+ }
if (push.channel === 'maker:provider:changed') {
handlers.onProviderChanged?.(env.src);
return;
@@ -2286,6 +2344,7 @@ function markOfflineDeviceMirrors(deviceIds: readonly string[]): void {
function wipeUnavailableDeviceMirror(deviceId: string): void {
evictTaskTagCatalog(deviceId);
resetRemoteProjectOrderPushFence(deviceId);
+ removeRemoteProjectAliases(deviceId);
invalidateScheduleIndexForDevice(deviceId);
remoteSessionStore.removeDevice(deviceId);
remoteScheduleEventStore.clearDevice(deviceId);
diff --git a/apps/mobile/src/session/HomeSurface.tsx b/apps/mobile/src/session/HomeSurface.tsx
index 6396e897de..2c4ddc6319 100644
--- a/apps/mobile/src/session/HomeSurface.tsx
+++ b/apps/mobile/src/session/HomeSurface.tsx
@@ -180,6 +180,7 @@ import {
shouldReplaceListWithSearchResults,
} from '@/session/conversationSearch';
import { useConversationSearch } from '@/session/useConversationSearch';
+import { useRemoteProjectAliases } from '@/session/remoteProjectAliases';
import {
buildMobileHomePresentation,
excludeOrcaWorkerSessions,
@@ -538,6 +539,7 @@ function HomeScreenContent({ active = true, onModeChange, width, newSessionInSys
} = useDeviceLink();
const revokedDevices = useRevokedDevices();
const sessions = useRemoteHomeSessions();
+ const projectAliases = useRemoteProjectAliases();
const syncInFlightRef = useRef<Promise<void> | null>(null);
const syncQueuedRef = useRef<{ visible?: boolean } | null>(null);
const loadHomeRef = useRef<(options?: { visible?: boolean }) => Promise<void>>(async () => undefined);
@@ -1856,8 +1858,9 @@ function HomeScreenContent({ active = true, onModeChange, width, newSessionInSys
() => listConversationSearchProjects(
excludeOrcaWorkerSessions(sessions),
new Set(searchOrigins.map((origin) => origin.deviceId)),
+ projectAliases,
),
- [searchOrigins, sessions],
+ [projectAliases, searchOrigins, sessions],
);
const indexedSearch = useConversationSearch({
enabled: true,
@@ -2018,6 +2021,7 @@ function HomeScreenContent({ active = true, onModeChange, width, newSessionInSys
const homeSessions = useMemo(() => excludeOrcaWorkerSessions(sessions), [sessions]);
const home = useMemo(
() => buildMobileHomePresentation({
+ projectAliases,
devices: deviceModels,
liveActivityIndex,
messagePreviewIndex,
@@ -2030,12 +2034,13 @@ function HomeScreenContent({ active = true, onModeChange, width, newSessionInSys
// 未起名会话的显示文案:共享层不兜中文串,由这里给已解析的 i18n 值。
unnamedLabel: t('session.menu.unnamedTitle'),
}),
- [deviceModels, liveActivityIndex, messagePreviewIndex, pendingInteractionIndex, scheduleIndex, searchQuery, selectedDeviceId, homeSessions, statusFilter, t],
+ [projectAliases, deviceModels, liveActivityIndex, messagePreviewIndex, pendingInteractionIndex, scheduleIndex, searchQuery, selectedDeviceId, homeSessions, statusFilter, t],
);
// 「筛选 › 项目」的候选:设备范围内的项目全集,不受搜索与任务状态影响——否则已选中的项目
// 会因搜索没命中或当前状态下没有任务而从菜单里消失,用户无法单独取消它。
const projectFilterUniverse = useMemo(
() => buildMobileHomePresentation({
+ projectAliases,
devices: deviceModels,
scheduleIndex,
selectedDeviceId,
@@ -2043,7 +2048,7 @@ function HomeScreenContent({ active = true, onModeChange, width, newSessionInSys
statusFilter: 'all',
unnamedLabel: t('session.menu.unnamedTitle'),
}),
- [deviceModels, scheduleIndex, selectedDeviceId, homeSessions, t],
+ [projectAliases, deviceModels, scheduleIndex, selectedDeviceId, homeSessions, t],
);
const projectMachineIdentities = useMemo(
() => buildHomeProjectMachineIdentities(home, deviceConnectionStates),
diff --git a/apps/mobile/src/session/conversationSearch.ts b/apps/mobile/src/session/conversationSearch.ts
index 8d836186ae..9ebbfcd695 100644
--- a/apps/mobile/src/session/conversationSearch.ts
+++ b/apps/mobile/src/session/conversationSearch.ts
@@ -20,6 +20,7 @@ import {
type ConversationSearchStatusFilter,
} from '@cindy/maker-shared/conversation-search';
import { stripTrailingPathSeparators } from '@cindy/maker-shared/path-text';
+import { resolveProjectAliasForSessions, type ProjectAliasesByDevice } from '@cindy/maker-shared/project-alias-sync';
import {
remoteSessionDisplayTitle,
sessionRowMessagePreview,
@@ -454,10 +455,12 @@ export function scopedConversationSearchOrigins(
}
export function listConversationSearchProjects(
- sessions: readonly Pick<RemoteSession, 'canonicalDeviceId' | 'deviceLinkDeviceId' | 'deviceLinkDeviceName' | 'orcaRole' | 'workingDir' | 'workspaceKind'>[],
+ sessions: readonly Pick<RemoteSession, 'canonicalDeviceId' | 'deviceLinkDeviceId' | 'deviceLinkDeviceName' | 'orcaRole' | 'workingDir' | 'workspaceKind' | 'remoteHostId'>[],
deviceIds?: ReadonlySet<string>,
+ projectAliases?: ProjectAliasesByDevice,
): ConversationSearchProjectOption[] {
const byKey = new Map<string, ConversationSearchProjectOption>();
+ const groupedSessions = new Map<string, typeof sessions[number][]>();
for (const session of sessions) {
if (session.orcaRole === 'worker') continue;
if (deviceIds && !sessionBelongsToSelectedDevice(session, deviceIds)) continue;
@@ -468,6 +471,9 @@ export function listConversationSearchProjects(
if (!workingDir) continue;
const dirKey = collapseWorktreeDirForGrouping(workingDir) ?? workingDir;
const key = `${deviceId}:${dirKey}`;
+ const group = groupedSessions.get(key) ?? [];
+ group.push(session);
+ groupedSessions.set(key, group);
const existing = byKey.get(key);
if (existing) {
existing.count += 1;
@@ -478,10 +484,15 @@ export function listConversationSearchProjects(
deviceId,
deviceName: session.deviceLinkDeviceName ?? null,
key,
- title: conversationSearchProjectTitle(workingDir),
+ title: conversationSearchProjectTitle(dirKey),
workingDir: dirKey,
});
}
+ if (projectAliases) {
+ for (const [key, project] of byKey) {
+ project.title = resolveProjectAliasForSessions(groupedSessions.get(key) ?? [], projectAliases) ?? project.title;
+ }
+ }
return [...byKey.values()].sort((a, b) => (
a.title.localeCompare(b.title) || a.deviceId.localeCompare(b.deviceId) || a.key.localeCompare(b.key)
));
diff --git a/apps/mobile/src/session/mobileHomeListCache.ts b/apps/mobile/src/session/mobileHomeListCache.ts
index b18fc9587c..6a363c95eb 100644
--- a/apps/mobile/src/session/mobileHomeListCache.ts
+++ b/apps/mobile/src/session/mobileHomeListCache.ts
@@ -226,6 +226,9 @@ function coerceCachedSession(item: unknown): RemoteSession | null {
}
const totalMoney = normalizeRemoteMoney(item.totalMoney);
if (totalMoney) session.totalMoney = totalMoney;
+ // Project aliases distinguish a host's local directory from its SSH workspaces.
+ // Keep that identity in the cold-start list too; otherwise an SSH row can borrow a local alias.
+ if (typeof item.remoteHostId === 'string') session.remoteHostId = item.remoteHostId;
if (typeof item.source === 'string') session.source = item.source;
if (orcaRole) session.orcaRole = orcaRole;
if (typeof item.pinnedAt === 'string') session.pinnedAt = item.pinnedAt;
diff --git a/apps/mobile/src/session/projectAliasPresentation.ts b/apps/mobile/src/session/projectAliasPresentation.ts
new file mode 100644
index 0000000000..776d7554bf
--- /dev/null
+++ b/apps/mobile/src/session/projectAliasPresentation.ts
@@ -0,0 +1,22 @@
+import { resolveProjectAliasForSessions, type ProjectAliasesByDevice } from '@cindy/maker-shared/project-alias-sync';
+import { collapseWorktreeDirForGrouping } from '@cindy/maker-shared/worktree-paths';
+import { stripTrailingPathSeparators } from '@cindy/maker-shared/path-text';
+import type { RemoteSession } from './types';
+
+/** Route names are only a first-paint hint, never authority after a host snapshot arrives. */
+export function resolveMobileProjectRouteTitle(input: {
+ deviceId: string;
+ workingDir: string | null;
+ routeTitle: string | null;
+ sessions: readonly RemoteSession[];
+ projectAliases: ProjectAliasesByDevice;
+}): string | null {
+ if (!input.workingDir) return input.routeTitle;
+ const alias = resolveProjectAliasForSessions(input.sessions, input.projectAliases, input.deviceId);
+ if (alias) return alias;
+ const known = input.projectAliases.has(input.deviceId)
+ || input.sessions.some((session) => input.projectAliases.has(session.deviceLinkDeviceId ?? input.deviceId));
+ if (!known && input.routeTitle) return input.routeTitle;
+ const dir = collapseWorktreeDirForGrouping(stripTrailingPathSeparators(input.workingDir));
+ return dir.split(/[\\/]/).filter(Boolean).at(-1) || dir;
+}
diff --git a/apps/mobile/src/session/remoteProjectAliases.ts b/apps/mobile/src/session/remoteProjectAliases.ts
new file mode 100644
index 0000000000..7c95144155
--- /dev/null
+++ b/apps/mobile/src/session/remoteProjectAliases.ts
@@ -0,0 +1,104 @@
+import { useSyncExternalStore } from 'react';
+import {
+ createProjectAliasMirror,
+ type HostProjectAliasesSnapshot,
+ type ProjectAliasesByDevice,
+} from '@cindy/maker-shared/project-alias-sync';
+import {
+ parseSyncedProjectOrderOwnerStamp,
+ type SyncedProjectOrderOwnerStamp,
+} from '@cindy/maker-shared/project-order-sync';
+
+const mirror = createProjectAliasMirror();
+let account: { ownerId: string | null; generation: number } = { ownerId: null, generation: -1 };
+const ownerStamps = new Map<string, SyncedProjectOrderOwnerStamp>();
+const knownDevices = new Set<string>();
+const deviceGenerations = new Map<string, number>();
+
+/** Account changes invalidate both the visible map and every outstanding read. */
+export function setRemoteProjectAliasesAccount(ownerId: string | null, generation: number): void {
+ if (account.ownerId === ownerId && account.generation === generation) return;
+ account = { ownerId, generation };
+ ownerStamps.clear();
+ knownDevices.clear();
+ deviceGenerations.clear();
+ mirror.clear();
+}
+
+export function useRemoteProjectAliases(): ProjectAliasesByDevice {
+ return useSyncExternalStore(mirror.subscribe, mirror.getSnapshot, mirror.getSnapshot);
+}
+
+export function refreshRemoteProjectAliases(
+ deviceId: string,
+ read: () => Promise<unknown>,
+ isCurrent: () => boolean = () => true,
+ invalidated = false,
+): Promise<void> {
+ const scope = account;
+ if (scope.ownerId === null || !isCurrent()) return Promise.resolve();
+ knownDevices.add(deviceId);
+ const deviceGeneration = deviceGenerations.get(deviceId) ?? 0;
+ const current = (snapshot?: HostProjectAliasesSnapshot): boolean => {
+ if (account !== scope || (deviceGenerations.get(deviceId) ?? 0) !== deviceGeneration || !isCurrent()) return false;
+ const stamp = snapshot?.ownerStamp;
+ const previous = ownerStamps.get(deviceId);
+ if (snapshot && !stamp) return false;
+ if (stamp && (stamp.dataOwnerId !== scope.ownerId
+ || (previous && stamp.ownerGeneration < previous.ownerGeneration))) return false;
+ // Only an accepted response advances the watermark. A failed reconnect read
+ // may retain an old visible snapshot, which is not evidence for this connection.
+ if (stamp) ownerStamps.set(deviceId, stamp);
+ return true;
+ };
+ const guardedRead = async () => {
+ if (!current()) throw new Error('Project alias read superseded');
+ return read();
+ };
+ return (invalidated ? mirror.invalidate : mirror.refresh)(deviceId, guardedRead, current)
+ .catch(() => undefined); // Optional display metadata never fails task-list recovery.
+}
+
+/** New alias notifications are always owner-stamped; old hosts have no such channel. */
+export function acceptRemoteProjectAliasesChanged(
+ deviceId: string,
+ ownerStamp: unknown,
+ isCurrent: () => boolean = () => true,
+): boolean {
+ if (!isCurrent()) return false;
+ const incoming = parseSyncedProjectOrderOwnerStamp(ownerStamp);
+ if (!incoming || account.ownerId === null || incoming.dataOwnerId !== account.ownerId) return false;
+ const previous = ownerStamps.get(deviceId);
+ if (previous && incoming.ownerGeneration < previous.ownerGeneration) return false;
+ ownerStamps.set(deviceId, incoming);
+ return true;
+}
+
+/** Disconnects fence late reads but retain same-account, last-known display names. */
+export function suspendRemoteProjectAliases(deviceId?: string): void {
+ if (deviceId) {
+ ownerStamps.delete(deviceId);
+ deviceGenerations.set(deviceId, (deviceGenerations.get(deviceId) ?? 0) + 1);
+ mirror.suspend(deviceId);
+ } else {
+ ownerStamps.clear();
+ for (const id of knownDevices) {
+ deviceGenerations.set(id, (deviceGenerations.get(id) ?? 0) + 1);
+ mirror.suspend(id);
+ }
+ }
+}
+
+/** The caller supplies only topics whose last owner was released. Other owners keep the read alive. */
+export function suspendRemoteProjectAliasesForReleasedTopics(deviceId: string, topics: readonly string[]): void {
+ if (topics.includes('sessions')) suspendRemoteProjectAliases(deviceId);
+}
+
+export function removeRemoteProjectAliases(deviceId: string): void {
+ ownerStamps.delete(deviceId);
+ knownDevices.delete(deviceId);
+ deviceGenerations.set(deviceId, (deviceGenerations.get(deviceId) ?? 0) + 1);
+ mirror.remove(deviceId);
+}
+
+export const remoteProjectAliasesSnapshot = mirror.getSnapshot;
diff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.md
index 6293921538..7e9f54dcfa 100644
--- a/docs/dev-rules/protocol-compatibility.md
+++ b/docs/dev-rules/protocol-compatibility.md
@@ -2438,6 +2438,24 @@ X 快照有请求正文时,按原始 triggerMessageId 排除引用列表中的
- Cindy Skill Hub 客户端与服务端在首次对外发布前同步收紧以上契约,不为未发布过的中间
协议增加 fallback;已经发布的旧客户端仍使用原有 XD Skill Hub endpoint,不受此契约影响。
+### 项目显示名的跨设备镜像
+
+`sidebar-settings:get-project-aliases` 是只读的主机别名快照;返回主机平台、账号代次和
+`local:` / `remote:` 项目身份对应的别名,不传播主机作为控制端保存的 `device:` 覆盖名。
+`local-db:project-aliases:changed` 使用 `{}` 失效通知和账号标记,沿既有 `sessions` topic
+转发。控制端首次订阅、重连及既有列表刷新时补拉;在途读取期间收到变更时丢弃旧结果并补拉。
+完整空快照表示别名已清除,临时读取失败保留最后有效名称。退出账号、移除或撤销设备时清理镜像,
+迟到响应不得恢复已清理的数据。
+
+新主机与旧控制端保持原行为;新控制端连接不支持该读取通道的旧主机时使用目录名。
+只新增读取与通知准入,不开放远程别名写入,不改数据库或 relay 格式。
+名字按物理来源设备和完整主机项目身份匹配;Windows 本地路径按主机平台比较,SSH 身份和
+POSIX 大小写保留。既有分组若包含不同主机项目身份,仍显示原目录名,不能任取一条别名覆盖整组。
+桌面控制端已有的本地 `device:` 覆盖名继续优先。分组键、任务标题、工作目录和路由均不随别名改变。
+
+实现与回归见 `packages/maker-shared/src/projectAliasSync.ts`、`projectAliasSync.test.ts` 和
+`projectAliasPresentation.test.ts`;移动端首页、设备详情、抽屉与搜索筛选共用同一份镜像。
+
## 2. 插件来源
- 客户端不包含内建插件种子,不在安装包中预置插件,启动期也没有播种
diff --git a/packages/device-link/src/__tests__/allowlist.test.ts b/packages/device-link/src/__tests__/allowlist.test.ts
index b748bb75dc..29a67c72ae 100644
--- a/packages/device-link/src/__tests__/allowlist.test.ts
+++ b/packages/device-link/src/__tests__/allowlist.test.ts
@@ -215,6 +215,14 @@ describe('REMOTE_INVOKE_ALLOWLIST', () => {
expect(REMOTE_INVOKE_ALLOWLIST.has('sidebar-settings:set-project-order')).toBe(false);
});
+ it('exposes host project aliases as a read-only snapshot and forwards invalidations', () => {
+ expect(REMOTE_INVOKE_ALLOWLIST.has('sidebar-settings:get-project-aliases')).toBe(true);
+ expect(REMOTE_INVOKE_ALLOWLIST.has('local-db:project-aliases:list')).toBe(false);
+ expect(REMOTE_INVOKE_ALLOWLIST.has('local-db:project-aliases:set')).toBe(false);
+ expect(REMOTE_INVOKE_ALLOWLIST.has('local-db:project-aliases:delete')).toBe(false);
+ expect(PUSH_FORWARD_ALLOWLIST.has('local-db:project-aliases:changed')).toBe(true);
+ });
+
it('放行 Git safety 只读查询(远程 Codex Rewind 按被控端 snapshot 设置 gate)', () => {
expect(REMOTE_INVOKE_ALLOWLIST.has('maker:git-safety:get')).toBe(true);
expect(REMOTE_INVOKE_ALLOWLIST.has('maker:git-safety:set')).toBe(false);
diff --git a/packages/device-link/src/__tests__/topics.test.ts b/packages/device-link/src/__tests__/topics.test.ts
index b65455db2d..e001979354 100644
--- a/packages/device-link/src/__tests__/topics.test.ts
+++ b/packages/device-link/src/__tests__/topics.test.ts
@@ -51,6 +51,7 @@ describe('topicForPush', () => {
});
it('账号 / 全局级 channel → sessions(随列表订阅走)', () => {
+ expect(topicForPush('local-db:project-aliases:changed', {})).toBe('sessions');
expect(topicForPush('maker:provider:changed', { revision: 42 })).toBe('sessions');
expect(topicForPush('maker:agents:changed', {})).toBe('sessions');
expect(topicForPush('maker:schedule:event', { kind: 'x' })).toBe('sessions');
diff --git a/packages/device-link/src/allowlist.ts b/packages/device-link/src/allowlist.ts
index 5099883bd9..d1375af8a3 100644
--- a/packages/device-link/src/allowlist.ts
+++ b/packages/device-link/src/allowlist.ts
@@ -291,6 +291,8 @@ const CORE_INVOKE_CHANNELS: readonly string[] = [
// → CHANNEL_NOT_ALLOWED → 控制端吞掉,回退本机/按时间。
'sidebar-settings:get-project-order',
'sidebar-settings:apply-project-order',
+ // Host-owned project names are read-only on controllers. Local overrides and write channels stay local.
+ 'sidebar-settings:get-project-aliases',
// 模型供应商目录(只读):远程会话的模型选择器据此 1:1 镜像被控端的「供应商+模型」结构。
// 被控端 dispatch 在返回前剥离 routing 等执行字段(见 device-link/dispatch.ts),只回显示用字段。
'maker:provider:list',
@@ -811,6 +813,7 @@ export const PUSH_FORWARD_ALLOWLIST: ReadonlySet<string> = new Set([
'local-db:session:error-persisted',
// 被控端项目手动顺序变化:控制端 / 手机首页按被控端正本重排。
'sidebar-settings:project-order-changed',
+ 'local-db:project-aliases:changed',
// 被控端「当前 New Maker 草稿」全量变更:被控端草稿 effort/fast/选中 等任意变化时广播,
// 控制端的远程项目草稿据此实时刷新显示镜像(remoteDraftState)。账号 / 全局级、无 sessionId →
// topics.ts 的 ACCOUNT_CHANNELS 把它并入 `sessions` topic(控制端按设备订阅 sessions)。
diff --git a/packages/device-link/src/topics.ts b/packages/device-link/src/topics.ts
index c912fb27e6..42fa5d567b 100644
--- a/packages/device-link/src/topics.ts
+++ b/packages/device-link/src/topics.ts
@@ -193,6 +193,8 @@ const ACCOUNT_CHANNELS: ReadonlySet<string> = new Set([
'learn:event',
// 被控端项目手动顺序变化:无 sessionId,并入 sessions topic 随设备列表订阅到达。
'sidebar-settings:project-order-changed',
+ // Project aliases invalidate a device-level display snapshot, without a sessionId.
+ 'local-db:project-aliases:changed',
// Claude 订阅账号余量快照(账号级,无 sessionId):控制端打开远程订阅会话时 chip
// 据此实时刷新;并入 sessions topic 随设备列表订阅到达,低频(签名去抖 + 节流)。
'usage:claude-subscription-changed',
diff --git a/packages/maker-shared/package.json b/packages/maker-shared/package.json
index ec6d234852..17eb04cf17 100644
--- a/packages/maker-shared/package.json
+++ b/packages/maker-shared/package.json
@@ -60,6 +60,7 @@
"./mobile-home": "./src/mobileHome.ts",
"./tool-process-media": "./src/toolProcessMedia.ts",
"./payload-summary": "./src/payloadSummary.ts",
+ "./project-alias-sync": "./src/projectAliasSync.ts",
"./project-order-sync": "./src/projectOrderSync.ts",
"./path-text": "./src/pathText.ts",
"./permission-mode": "./src/permissionMode.ts",
diff --git a/packages/maker-shared/src/__tests__/projectAliasPresentation.test.ts b/packages/maker-shared/src/__tests__/projectAliasPresentation.test.ts
new file mode 100644
index 0000000000..ee0b7a2739
--- /dev/null
+++ b/packages/maker-shared/src/__tests__/projectAliasPresentation.test.ts
@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest';
+// Regression: mobile home/detail built directory titles even when the host had a project alias.
+// Production entries: buildMobileHomePresentation/buildRemoteSessionSections. Existing list tests
+// cover grouping but not alias updates. Minimal failure: rename one /repo/Slack对话 snapshot;
+// both titles must change while task titles, source paths and group keys stay unchanged (unit).
+import { buildMobileHomePresentation, type MobileHomeSessionLike } from '../mobileHome.js';
+import { buildRemoteSessionSections } from '../sessionList.js';
+import { createProjectAliasMirror, type HostProjectAliasesSnapshot } from '../projectAliasSync.js';
+
+function session(id: string, patch: Partial<MobileHomeSessionLike> = {}): MobileHomeSessionLike {
+ return {
+ id,
+ title: `Task ${id}`,
+ workingDir: '/repo/Slack对话',
+ workspaceKind: 'project',
+ deviceLinkDeviceId: 'computer-a',
+ model: 'model',
+ agentKind: 'cc',
+ status: 'active',
+ createdAt: '2026-10-23T00:00:00.000Z',
+ updatedAt: '2026-10-23T00:00:00.000Z',
+ ...patch,
+ };
+}
+
+function snapshot(alias: string | null, projectKey = 'local:/repo/Slack对话'): HostProjectAliasesSnapshot {
+ return { platform: 'darwin', aliases: alias === null ? [] : [{ projectKey, alias }] };
+}
+
+describe('project aliases in controller presentations', () => {
+ it('renames and clears project titles on home and detail without changing task titles, paths, or group keys', async () => {
+ const mirror = createProjectAliasMirror();
+ const sessions = [session('one'), session('two')];
+ let host = snapshot(null);
+ const read = async () => host;
+ await mirror.refresh('computer-a', read);
+ const home = () => buildMobileHomePresentation({ sessions, projectAliases: mirror.getSnapshot() });
+ const detail = () => buildRemoteSessionSections(sessions, 0, { projectAliases: mirror.getSnapshot() });
+ const originalKey = home().projects[0].key;
+ expect(home().projects[0].title).toBe('Slack对话');
+ expect(detail()[0].title).toBe('Slack对话');
+
+ host = snapshot('Slack同步测试');
+ await mirror.invalidate('computer-a', read);
+ expect(home().projects[0]).toMatchObject({ key: originalKey, title: 'Slack同步测试', workingDir: '/repo/Slack对话' });
+ expect(detail()[0].title).toBe('Slack同步测试');
+ expect(sessions.map((row) => row.title)).toEqual(['Task one', 'Task two']);
+
+ host = snapshot(null);
+ await mirror.invalidate('computer-a', read);
+ expect(home().projects[0]).toMatchObject({ key: originalKey, title: 'Slack对话' });
+ expect(detail()[0].title).toBe('Slack对话');
+ });
+
+ it('keeps different computers with the same path independent', () => {
+ const projectAliases = new Map([
+ ['computer-a', snapshot('First')],
+ ['computer-b', snapshot('Second')],
+ ]);
+ const home = buildMobileHomePresentation({
+ sessions: [session('one'), session('two', { deviceLinkDeviceId: 'computer-b' })],
+ projectAliases,
+ });
+ expect(new Map(home.projects.map((group) => [group.deviceId, group.title])))
+ .toEqual(new Map([['computer-a', 'First'], ['computer-b', 'Second']]));
+ });
+
+ it('applies a host base-project alias to its worktree and supports detail rows without source metadata', () => {
+ const projectAliases = new Map([['computer-a', snapshot('Project')]]);
+ const row = session('worktree', { workingDir: '/repo/Slack对话/.cindy-worktrees/example' });
+ expect(buildMobileHomePresentation({ sessions: [row], projectAliases }).projects[0].title).toBe('Project');
+ expect(buildRemoteSessionSections([{ ...row, deviceLinkDeviceId: undefined }], 0, {
+ projectAliases, projectAliasDeviceId: 'computer-a',
+ })[0].title).toBe('Project');
+ });
+
+ it.each([false, true])('never assigns a local name to an existing mixed local/SSH group (reversed=%s)', (reverse) => {
+ const projectAliases = new Map([['computer-a', {
+ platform: 'darwin', aliases: [
+ { projectKey: 'local:/repo/Slack对话', alias: 'Local' },
+ { projectKey: 'remote:ssh-a:/repo/Slack对话', alias: 'Remote' },
+ ],
+ }]]);
+ const sessions = [session('one'), session('two', { remoteHostId: 'ssh-a' })];
+ if (reverse) sessions.reverse();
+ expect(buildMobileHomePresentation({ sessions, projectAliases }).projects[0].title).toBe('Slack对话');
+ expect(buildRemoteSessionSections(sessions, 0, { projectAliases })[0].title).toBe('Slack对话');
+ expect(buildMobileHomePresentation({ sessions: [session('ssh', { remoteHostId: 'ssh-a' })], projectAliases }).projects[0].title)
+ .toBe('Remote');
+ });
+});
diff --git a/packages/maker-shared/src/__tests__/projectAliasSync.test.ts b/packages/maker-shared/src/__tests__/projectAliasSync.test.ts
new file mode 100644
index 0000000000..944c73bf68
--- /dev/null
+++ b/packages/maker-shared/src/__tests__/projectAliasSync.test.ts
@@ -0,0 +1,352 @@
+import { describe, expect, it, vi } from 'vitest';
+// Regression: desktop project renames were never mirrored to controllers.
+// Production entry: createProjectAliasMirror + host identity parsing; the old project-order
+// tests did not cover alias deletion, identity separation or a rename during an in-flight read.
+// Minimal failure: an old read resolves after a changed notification; unit tier uses deferred
+// promises so it verifies the published name and account fencing without real timers or IO.
+import {
+ createProjectAliasMirror,
+ parseHostProjectAliasesSnapshot,
+ projectAliasComparisonKey,
+ resolveProjectAliasForSessions,
+ type HostProjectAliasesSnapshot,
+ type ProjectAliasSessionLike,
+} from '../projectAliasSync';
+
+function snapshot(alias: string | null, owner = 'owner-a'): HostProjectAliasesSnapshot {
+ return {
+ aliases: alias === null ? [] : [{ projectKey: 'local:/repo', alias }],
+ platform: 'darwin',
+ ownerStamp: { dataOwnerId: owner, ownerGeneration: 1 },
+ };
+}
+
+function deferred<T>() {
+ let resolve!: (value: T) => void;
+ let reject!: (error: unknown) => void;
+ const promise = new Promise<T>((yes, no) => { resolve = yes; reject = no; });
+ return { promise, resolve, reject };
+}
+
+async function drainMicrotasks() {
+ for (let count = 0; count < 12; count += 1) await Promise.resolve();
+}
+
+function session(overrides: Partial<ProjectAliasSessionLike> = {}): ProjectAliasSessionLike {
+ return { workingDir: '/repo', deviceLinkDeviceId: 'dev-a', ...overrides };
+}
+
+describe('project alias identity and snapshot parsing', () => {
+ it.each([
+ ['local:C:\\Work\\App\\', 'win32', 'local:c:/work/app'],
+ ['local:C:/', 'win32', 'local:c:/'],
+ ['local:\\\\?\\C:\\Work\\App', 'win32', 'local:c:/work/app'],
+ ['local:\\\\Server\\Share\\App', 'win32', 'local://server/share/app'],
+ ['local:\\\\?\\UNC\\Server\\Share\\App', 'win32', 'local://server/share/app'],
+ ['local://Server/Share/App/', 'win32', 'local://server/share/app'],
+ ['local:C:/Work/App', 'linux', 'local:C:/Work/App'],
+ ['local:/repo/Foo\\Bar', 'linux', 'local:/repo/Foo\\Bar'],
+ ['local:/repo/Foo\\', 'linux', 'local:/repo/Foo\\'],
+ ['local:/repo/weird\\.worktrees/name', 'linux', 'local:/repo/weird\\.worktrees/name'],
+ ['local:/repo/.cindy-worktrees/branch/src', 'darwin', 'local:/repo'],
+ ['local:/repo/.xdt-worktrees/branch', 'linux', 'local:/repo'],
+ ['local:/repo/.worktrees/branch', 'linux', 'local:/repo'],
+ ['local:/repo/.claude/worktrees/branch', 'linux', 'local:/repo'],
+ ['remote:ssh%2Fone:C:/Work/App', 'win32', 'remote:ssh%2Fone:C:/Work/App'],
+ ['remote:ssh%3Aone:/repo/.worktrees/branch', 'darwin', 'remote:ssh%3Aone:/repo'],
+ ])('normalizes comparison identity without changing source identity: %s', (key, platform, expected) => {
+ expect(projectAliasComparisonKey(key, platform)).toBe(expected);
+ });
+
+ it.each(['device:other:/repo', 'remote:bad%:/repo', 'remote::/repo', 'remote:ssh', 'local:', 'local: ', '/repo'])('rejects a non-host or invalid identity: %s', (key) => {
+ expect(projectAliasComparisonKey(key, 'darwin')).toBeNull();
+ });
+
+ it('retains newest-first duplicates while rejecting invalid rows and controller-local overrides', () => {
+ expect(parseHostProjectAliasesSnapshot({
+ platform: 'win32',
+ aliases: [
+ { projectKey: 'local:C:/Repo', alias: ' Newest ' },
+ { projectKey: 'local:c:/repo', alias: 'Older' },
+ { projectKey: 'remote:ssh:/repo', alias: 'SSH' },
+ { projectKey: 'device:other:/repo', alias: 'Private override' },
+ { projectKey: 'local:/empty', alias: ' ' },
+ { projectKey: 'local:/long', alias: 'a'.repeat(81) },
+ null,
+ { projectKey: 1, alias: 'invalid' },
+ ],
+ })).toEqual({
+ platform: 'win32',
+ aliases: [
+ { projectKey: 'local:C:/Repo', alias: 'Newest' },
+ { projectKey: 'remote:ssh:/repo', alias: 'SSH' },
+ ],
+ });
+ });
+
+ it.each([null, [], {}, { aliases: [], platform: 1 }, { aliases: [], platform: 'darwin', ownerStamp: {} }])('does not turn a malformed response into an authoritative deletion', (raw) => {
+ expect(parseHostProjectAliasesSnapshot(raw)).toBeNull();
+ });
+
+ it('looks up full host identity on the physical source without borrowing canonical device aliases', () => {
+ const snapshots = new Map([
+ ['dev-a', {
+ ...snapshot('Local'),
+ aliases: [
+ { projectKey: 'local:/repo', alias: 'Local' },
+ { projectKey: 'remote:ssh-a:/repo', alias: 'SSH A' },
+ { projectKey: 'remote:ssh-b:/repo', alias: 'SSH B' },
+ ],
+ }],
+ ['dev-b', snapshot('Other machine')],
+ ]);
+ expect(resolveProjectAliasForSessions([session()], snapshots)).toBe('Local');
+ expect(resolveProjectAliasForSessions([session({ remoteHostId: 'ssh-a' })], snapshots)).toBe('SSH A');
+ expect(resolveProjectAliasForSessions([session({ remoteHostId: 'ssh-b' })], snapshots)).toBe('SSH B');
+ expect(resolveProjectAliasForSessions([session({ deviceLinkDeviceId: 'dev-b' })], snapshots)).toBe('Other machine');
+ const historical = { ...session({ deviceLinkDeviceId: 'old-device' }), canonicalDeviceId: 'dev-a' };
+ expect(resolveProjectAliasForSessions([historical], snapshots)).toBeNull();
+ expect(resolveProjectAliasForSessions([session({ deviceLinkDeviceId: undefined })], snapshots, 'dev-a')).toBe('Local');
+ });
+
+ it('preserves default titles for mixed local/SSH or physical-device groups in either session order', () => {
+ const snapshots = new Map([['dev-a', snapshot('Local')], ['dev-b', snapshot('Other')]]);
+ const local = session();
+ for (const different of [session({ remoteHostId: 'ssh' }), session({ deviceLinkDeviceId: 'dev-b' })]) {
+ expect(resolveProjectAliasForSessions([local, different], snapshots)).toBeNull();
+ expect(resolveProjectAliasForSessions([different, local], snapshots)).toBeNull();
+ }
+ expect(resolveProjectAliasForSessions([local, session({ workingDir: '/repo/.worktrees/topic' })], snapshots)).toBe('Local');
+ });
+});
+
+describe('project alias mirror lifecycle', () => {
+ it('limits reads across more than six devices while continuing queued work as slots free', async () => {
+ const mirror = createProjectAliasMirror();
+ const responses = Array.from({ length: 9 }, () => deferred<unknown>());
+ let active = 0;
+ let maxActive = 0;
+ const readers = responses.map((response) => vi.fn(async () => {
+ active += 1;
+ maxActive = Math.max(maxActive, active);
+ try {
+ return await response.promise;
+ } finally {
+ active -= 1;
+ }
+ }));
+ const pending = readers.map((read, index) => mirror.refresh(`dev-${index}`, read));
+ await drainMicrotasks();
+ expect(readers.map((read) => read.mock.calls.length)).toEqual([1, 1, 1, 1, 1, 1, 0, 0, 0]);
+ expect(active).toBe(6);
+ responses[0].resolve(snapshot('First complete'));
+ await drainMicrotasks();
+ expect(readers[6]).toHaveBeenCalledTimes(1);
+ expect(readers[7]).not.toHaveBeenCalled();
+ expect(active).toBe(6);
+ responses.forEach((response, index) => response.resolve(snapshot(`Name ${index}`)));
+ await Promise.all(pending);
+ expect(maxActive).toBe(6);
+ expect(mirror.getSnapshot().size).toBe(9);
+ });
+
+ it.each(['clear', 'remove', 'suspend'] as const)('%s skips obsolete queued reads while issued reads keep occupying their slots', async (operation) => {
+ const mirror = createProjectAliasMirror();
+ const issued = Array.from({ length: 6 }, () => deferred<unknown>());
+ const pendingIssued = issued.map((response, index) => mirror.refresh(`running-${index}`, () => response.promise));
+ const obsoleteRead = vi.fn(async () => snapshot('Never send this'));
+ const obsoletePending = mirror.refresh('queued-obsolete', obsoleteRead);
+ await drainMicrotasks();
+ expect(obsoleteRead).not.toHaveBeenCalled();
+ if (operation === 'clear') mirror.clear();
+ else mirror[operation]('queued-obsolete');
+ const replacement = deferred<unknown>();
+ const replacementRead = vi.fn(() => replacement.promise);
+ const replacementPending = mirror.refresh('queued-replacement', replacementRead);
+ await drainMicrotasks();
+ expect(obsoleteRead).not.toHaveBeenCalled();
+ expect(replacementRead).not.toHaveBeenCalled();
+ issued[0].resolve(snapshot('Issued read settled'));
+ await drainMicrotasks();
+ expect(obsoleteRead).not.toHaveBeenCalled();
+ expect(replacementRead).toHaveBeenCalledTimes(1);
+ replacement.resolve(snapshot('Replacement'));
+ issued.forEach((response) => response.resolve(snapshot('Issued')));
+ await Promise.all([...pendingIssued, obsoletePending, replacementPending]);
+ expect(mirror.getSnapshot().has('queued-obsolete')).toBe(false);
+ expect(mirror.getSnapshot().get('queued-replacement')).toEqual(snapshot('Replacement'));
+ });
+
+ it('does not send a queued read after its account or connection authority expires without a store reset', async () => {
+ const mirror = createProjectAliasMirror();
+ const issued = Array.from({ length: 6 }, () => deferred<unknown>());
+ const pendingIssued = issued.map((response, index) => mirror.refresh(`running-${index}`, () => response.promise));
+ let authorized = true;
+ const read = vi.fn(async () => snapshot('Must not read after authority expired'));
+ const pending = mirror.refresh('queued', read, () => authorized);
+ await drainMicrotasks();
+ expect(read).not.toHaveBeenCalled();
+ authorized = false;
+ issued.forEach((response) => response.resolve(snapshot('Issued')));
+ await Promise.all([...pendingIssued, pending]);
+ expect(read).not.toHaveBeenCalled();
+ expect(mirror.getSnapshot().has('queued')).toBe(false);
+ });
+
+ it('shares concurrent reads for one device while allowing another device to finish independently', async () => {
+ const mirror = createProjectAliasMirror();
+ const first = deferred<unknown>();
+ const read = vi.fn(() => first.promise);
+ const pending = mirror.refresh('dev-a', read);
+ const duplicate = mirror.refresh('dev-a', read);
+ await mirror.refresh('dev-b', async () => snapshot('B'));
+ expect(read).toHaveBeenCalledTimes(1);
+ expect(mirror.getSnapshot().get('dev-b')).toEqual(snapshot('B'));
+ expect(mirror.getSnapshot().has('dev-a')).toBe(false);
+ first.resolve(snapshot('A'));
+ await Promise.all([pending, duplicate]);
+ expect(mirror.getSnapshot().get('dev-a')).toEqual(snapshot('A'));
+ });
+
+ it('discards a pre-change read and coalesces several invalidations into one fresh read', async () => {
+ const mirror = createProjectAliasMirror();
+ const first = deferred<unknown>();
+ const second = deferred<unknown>();
+ const read = vi.fn().mockReturnValueOnce(first.promise).mockReturnValueOnce(second.promise);
+ const seen: string[] = [];
+ mirror.subscribe(() => { seen.push(mirror.getSnapshot().get('dev-a')?.aliases[0]?.alias ?? ''); });
+ const pending = mirror.refresh('dev-a', read);
+ await drainMicrotasks();
+ const invalidated = [mirror.invalidate('dev-a', read), mirror.invalidate('dev-a', read)];
+ first.resolve(snapshot('Stale'));
+ await drainMicrotasks();
+ expect(read).toHaveBeenCalledTimes(2);
+ expect(mirror.getSnapshot().has('dev-a')).toBe(false);
+ second.resolve(snapshot('Renamed'));
+ await Promise.all([pending, ...invalidated]);
+ expect(seen).toEqual(['Renamed']);
+ });
+
+ it('also reruns when the invalidated read failed', async () => {
+ const mirror = createProjectAliasMirror();
+ const first = deferred<unknown>();
+ const read = vi.fn().mockReturnValueOnce(first.promise).mockResolvedValueOnce(snapshot('Fresh'));
+ const pending = mirror.refresh('dev-a', read);
+ await drainMicrotasks();
+ mirror.invalidate('dev-a', read);
+ first.reject(new Error('old connection failed'));
+ await pending;
+ expect(read).toHaveBeenCalledTimes(2);
+ expect(mirror.getSnapshot().get('dev-a')).toEqual(snapshot('Fresh'));
+ });
+
+ it('applies deletions as whole-device replacement without clearing other devices', async () => {
+ const mirror = createProjectAliasMirror();
+ await mirror.refresh('dev-a', async () => snapshot('A'));
+ await mirror.refresh('dev-b', async () => snapshot('B'));
+ await mirror.invalidate('dev-a', async () => snapshot(null));
+ expect(mirror.getSnapshot().get('dev-a')?.aliases).toEqual([]);
+ expect(mirror.getSnapshot().get('dev-b')?.aliases[0]?.alias).toBe('B');
+ });
+
+ it.each([
+ { code: 'CHANNEL_NOT_ALLOWED' },
+ new Error('[DEVICE_LINK_CHANNEL_NOT_ALLOWED] old host'),
+ ])('falls back for an explicitly unsupported host channel', async (error) => {
+ const mirror = createProjectAliasMirror();
+ await mirror.refresh('dev-a', async () => snapshot('Known'));
+ await mirror.refresh('dev-a', async () => { throw error; });
+ expect(mirror.getSnapshot().get('dev-a')?.aliases).toEqual([]);
+ });
+
+ it.each([new Error('timeout'), { code: 'NOT_CONNECTED' }, { code: 'REMOTE_DISABLED' }])('keeps known names on transient/authorization failure instead of treating it as deletion', async (error) => {
+ const mirror = createProjectAliasMirror();
+ await mirror.refresh('dev-a', async () => snapshot('Known'));
+ const before = mirror.getSnapshot();
+ await mirror.refresh('dev-a', async () => { throw error; });
+ expect(mirror.getSnapshot()).toBe(before);
+ });
+
+ it('keeps a known snapshot on malformed data and avoids redundant notifications', async () => {
+ const mirror = createProjectAliasMirror();
+ const listener = vi.fn();
+ const off = mirror.subscribe(listener);
+ await mirror.refresh('dev-a', async () => snapshot('Known'));
+ await mirror.refresh('dev-a', async () => snapshot('Known'));
+ await mirror.refresh('dev-a', async () => ({ platform: 'darwin' }));
+ expect(listener).toHaveBeenCalledTimes(1);
+ off();
+ await mirror.refresh('dev-a', async () => snapshot('New'));
+ expect(listener).toHaveBeenCalledTimes(1);
+ });
+
+ it.each(['clear', 'remove', 'suspend'] as const)('%s fences old responses and does not let their completion clear a new pending read', async (operation) => {
+ const mirror = createProjectAliasMirror();
+ await mirror.refresh('dev-a', async () => snapshot('Known'));
+ const old = deferred<unknown>();
+ const oldPending = mirror.refresh('dev-a', () => old.promise);
+ await drainMicrotasks();
+ if (operation === 'clear') mirror.clear();
+ else mirror[operation]('dev-a');
+ expect(mirror.getSnapshot().has('dev-a')).toBe(operation === 'suspend');
+ const fresh = deferred<unknown>();
+ const readFresh = vi.fn(() => fresh.promise);
+ const freshPending = mirror.refresh('dev-a', readFresh);
+ await drainMicrotasks();
+ old.resolve(snapshot('Stale'));
+ await oldPending;
+ const joined = mirror.refresh('dev-a', readFresh);
+ await drainMicrotasks();
+ expect(readFresh).toHaveBeenCalledTimes(1);
+ fresh.resolve(snapshot('Fresh'));
+ await Promise.all([freshPending, joined]);
+ expect(mirror.getSnapshot().get('dev-a')).toEqual(snapshot('Fresh'));
+ });
+
+ it('does not recreate a removed device when its old read fails as unsupported', async () => {
+ const mirror = createProjectAliasMirror();
+ const old = deferred<unknown>();
+ const pending = mirror.refresh('dev-a', () => old.promise);
+ await drainMicrotasks();
+ mirror.remove('dev-a');
+ old.reject({ code: 'CHANNEL_NOT_ALLOWED' });
+ await pending;
+ expect(mirror.getSnapshot().has('dev-a')).toBe(false);
+ });
+
+ it('rejects old-account responses and does not trust a snapshot from another owner', async () => {
+ const mirror = createProjectAliasMirror();
+ let currentOwner = 'owner-a';
+ const old = deferred<unknown>();
+ const pending = mirror.refresh('dev-a', () => old.promise, (value) => currentOwner === 'owner-a'
+ && (value === undefined || value.ownerStamp?.dataOwnerId === currentOwner));
+ await drainMicrotasks();
+ currentOwner = 'owner-b';
+ old.resolve(snapshot('Private old name'));
+ await pending;
+ expect(mirror.getSnapshot().has('dev-a')).toBe(false);
+ await mirror.refresh('dev-a', async () => snapshot('Wrong owner'), (value) => value === undefined || value.ownerStamp?.dataOwnerId === currentOwner);
+ expect(mirror.getSnapshot().has('dev-a')).toBe(false);
+ await mirror.refresh('dev-a', async () => snapshot('B name', 'owner-b'), (value) => value === undefined || value.ownerStamp?.dataOwnerId === currentOwner);
+ expect(mirror.getSnapshot().get('dev-a')).toEqual(snapshot('B name', 'owner-b'));
+ });
+
+ it.each(['synchronous', 'microtask'] as const)('does not lose a change received from a %s subscriber during snapshot delivery', async (delivery) => {
+ const mirror = createProjectAliasMirror();
+ const read = vi.fn().mockResolvedValueOnce(snapshot('Before')).mockResolvedValueOnce(snapshot('After'));
+ let invalidated: Promise<void> | undefined;
+ let changed = false;
+ mirror.subscribe(() => {
+ if (changed) return;
+ changed = true;
+ const invalidate = () => { invalidated = mirror.invalidate('dev-a', read); };
+ if (delivery === 'synchronous') invalidate();
+ else queueMicrotask(invalidate);
+ });
+ await mirror.refresh('dev-a', read);
+ await drainMicrotasks();
+ await invalidated;
+ expect(read).toHaveBeenCalledTimes(2);
+ expect(mirror.getSnapshot().get('dev-a')).toEqual(snapshot('After'));
+ });
+});
diff --git a/packages/maker-shared/src/index.ts b/packages/maker-shared/src/index.ts
index 42006851fd..3c54a4372c 100644
--- a/packages/maker-shared/src/index.ts
+++ b/packages/maker-shared/src/index.ts
@@ -29,6 +29,7 @@ export * from './messageSearch.js';
export * from './messageWindow.js';
export * from './mobileHome.js';
export * from './payloadSummary.js';
+export * from './projectAliasSync.js';
export * from './projectOrderSync.js';
export * from './pathText.js';
export * from './permissionMode.js';
diff --git a/packages/maker-shared/src/mobileHome.ts b/packages/maker-shared/src/mobileHome.ts
index 6973cc6c71..5e805e1ae0 100644
--- a/packages/maker-shared/src/mobileHome.ts
+++ b/packages/maker-shared/src/mobileHome.ts
@@ -15,6 +15,7 @@ import { stripTrailingPathSeparators } from './pathText.js';
import { normalizeProjectOrderPath } from './projectOrderSync.js';
import { collapseWorktreeDirForGrouping } from './worktreePaths.js';
import { CINDY_MAKE_ENABLED, isCindyMakeSource } from './cindyMakeFeature.js';
+import { resolveProjectAliasForSessions, type ProjectAliasesByDevice } from './projectAliasSync.js';
export const MOBILE_HOME_ALL_DEVICES = 'all';
@@ -118,6 +119,7 @@ export interface MobileHomePresentation {
}
export interface MobileHomeOptions {
+ projectAliases?: ProjectAliasesByDevice;
devices?: readonly MobileHomeDeviceLike[];
messagePreviewIndex?: ReadonlyMap<string, string>;
liveActivityIndex?: ReadonlyMap<string, RemoteSessionLiveActivity>;
@@ -137,6 +139,7 @@ export interface MobileHomeOptions {
}
export function buildMobileHomePresentation({
+ projectAliases,
devices = [],
messagePreviewIndex,
liveActivityIndex,
@@ -214,6 +217,7 @@ export function buildMobileHomePresentation({
localizer,
),
devices,
+ projectAliases,
);
const overview = summarizeHomeOverview(normalizedSessions, projects, pendingInteractionIndex, normalizedSelectedDeviceId);
const primaryDevice = pickPrimaryDevice(deviceFilters, normalizedSelectedDeviceId);
@@ -334,6 +338,7 @@ function pickPrimaryDevice(
function buildProjectGroups(
items: readonly RemoteSessionListItem[],
devices: readonly MobileHomeDeviceLike[],
+ projectAliases?: ProjectAliasesByDevice,
): MobileHomeProjectGroup[] {
const deviceNames = new Map(devices.map((device) => [device.deviceId, device.name]));
const grouped = new Map<string, RemoteSessionListItem[]>();
@@ -369,7 +374,10 @@ function buildProjectGroups(
sessionCount: group.reduce((sum, item) => sum + (item.automationGroup?.sessionCount ?? 1), 0),
sessions: group,
subtitle: [deviceName, workingDir].filter(Boolean).join(' · '),
- title: cindyMake ? 'Cindy Make' : projectTitle(workingDir),
+ title: cindyMake ? 'Cindy Make' : resolveProjectAliasForSessions(
+ group.flatMap((item) => item.automationGroup?.items.map((member) => member.session) ?? [item.session]),
+ projectAliases,
+ ) ?? projectTitle(workingDir),
workingDir,
};
})
diff --git a/packages/maker-shared/src/projectAliasSync.ts b/packages/maker-shared/src/projectAliasSync.ts
new file mode 100644
index 0000000000..f3b7242788
--- /dev/null
+++ b/packages/maker-shared/src/projectAliasSync.ts
@@ -0,0 +1,248 @@
+import { collapseWorktreeDirForGrouping } from './worktreePaths.js';
+import {
+ parseSyncedProjectOrderOwnerStamp,
+ type SyncedProjectOrderOwnerStamp,
+} from './projectOrderSync.js';
+
+export const PROJECT_ALIASES_GET_CHANNEL = 'sidebar-settings:get-project-aliases';
+export const PROJECT_ALIASES_CHANGED_CHANNEL = 'local-db:project-aliases:changed';
+
+export interface HostProjectAliasesSnapshot {
+ /** Host identities only: a controller's device: overrides stay on that controller. */
+ aliases: readonly { projectKey: string; alias: string }[];
+ platform: string;
+ ownerStamp?: SyncedProjectOrderOwnerStamp;
+}
+
+export type ProjectAliasesByDevice = ReadonlyMap<string, HostProjectAliasesSnapshot>;
+
+export interface ProjectAliasSessionLike {
+ workingDir: string | null;
+ remoteHostId?: string | null;
+ /** Physical source, never canonicalDeviceId (which is only a display identity). */
+ deviceLinkDeviceId?: string | null;
+}
+
+function normalizeAliasPath(raw: string): string | null {
+ if (!raw.trim()) return null;
+ let value = raw;
+ if (value.startsWith('\\\\?\\UNC\\')) value = `\\\\${value.slice(8)}`;
+ else if (value.startsWith('\\\\?\\')) value = value.slice(4);
+ if (/^[A-Za-z]:[\\/]/.test(value) || value.startsWith('\\\\') || value.startsWith('//')) {
+ value = value.replaceAll('\\', '/');
+ }
+ while (value.length > 1 && value.endsWith('/') && !/^[A-Za-z]:\/$/.test(value)) {
+ value = value.slice(0, -1);
+ }
+ return collapseWorktreeDirForGrouping(value);
+}
+
+/** Comparison only; never use this value as an IO path or a controller grouping key. */
+export function projectAliasComparisonKey(raw: string, platform: string): string | null {
+ if (raw.startsWith('local:')) {
+ const path = normalizeAliasPath(raw.slice(6));
+ if (path === null) return null;
+ const windows = /^[A-Za-z]:\//.test(path) || path.startsWith('//');
+ return `local:${platform === 'win32' && windows ? path.toLowerCase() : path}`;
+ }
+ if (!raw.startsWith('remote:')) return null;
+ const separator = raw.indexOf(':', 7);
+ if (separator < 0) return null;
+ try {
+ const host = decodeURIComponent(raw.slice(7, separator));
+ const path = normalizeAliasPath(raw.slice(separator + 1));
+ return host && path !== null ? `remote:${encodeURIComponent(host)}:${path}` : null;
+ } catch {
+ return null;
+ }
+}
+
+export function parseHostProjectAliasesSnapshot(raw: unknown): HostProjectAliasesSnapshot | null {
+ if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+ const value = raw as Record<string, unknown>;
+ if (!Array.isArray(value.aliases) || typeof value.platform !== 'string') return null;
+ const ownerStamp = parseSyncedProjectOrderOwnerStamp(value.ownerStamp);
+ if (Object.prototype.hasOwnProperty.call(value, 'ownerStamp') && !ownerStamp) return null;
+ const aliases: { projectKey: string; alias: string }[] = [];
+ const seen = new Set<string>();
+ for (const row of value.aliases) {
+ if (!row || typeof row !== 'object') continue;
+ const { projectKey, alias } = row as Record<string, unknown>;
+ if (typeof projectKey !== 'string' || typeof alias !== 'string') continue;
+ const comparison = projectAliasComparisonKey(projectKey, value.platform);
+ const trimmed = alias.trim();
+ if (!comparison || !trimmed || trimmed.length > 80 || seen.has(comparison)) continue;
+ // Host rows are newest-first, matching the desktop's legacy duplicate handling.
+ seen.add(comparison);
+ aliases.push({ projectKey, alias: trimmed });
+ }
+ return { aliases, platform: value.platform, ...(ownerStamp ? { ownerStamp } : {}) };
+}
+
+const aliasIndexes = new WeakMap<HostProjectAliasesSnapshot, ReadonlyMap<string, string>>();
+
+function aliasIndex(snapshot: HostProjectAliasesSnapshot): ReadonlyMap<string, string> {
+ const existing = aliasIndexes.get(snapshot);
+ if (existing) return existing;
+ const next = new Map<string, string>();
+ for (const row of snapshot.aliases) {
+ const key = projectAliasComparisonKey(row.projectKey, snapshot.platform);
+ if (key && !next.has(key)) next.set(key, row.alias);
+ }
+ aliasIndexes.set(snapshot, next);
+ return next;
+}
+
+/** Existing mixed-identity groups keep their path title, rather than borrowing one member's alias. */
+export function resolveProjectAliasForSessions(
+ sessions: readonly ProjectAliasSessionLike[],
+ snapshots: ProjectAliasesByDevice | undefined,
+ defaultDeviceId?: string,
+): string | null {
+ if (!snapshots || sessions.length === 0) return null;
+ let identity: string | undefined;
+ let alias: string | null = null;
+ for (const session of sessions) {
+ const deviceId = session.deviceLinkDeviceId || defaultDeviceId;
+ if (!deviceId || !session.workingDir) return null;
+ const snapshot = snapshots.get(deviceId);
+ if (!snapshot) return null;
+ const key = projectAliasComparisonKey(
+ session.remoteHostId
+ ? `remote:${encodeURIComponent(session.remoteHostId)}:${session.workingDir}`
+ : `local:${session.workingDir}`,
+ snapshot.platform,
+ );
+ if (!key) return null;
+ const current = JSON.stringify([deviceId, key]);
+ if (identity !== undefined && identity !== current) return null;
+ identity = current;
+ alias = aliasIndex(snapshot).get(key) ?? null;
+ }
+ return alias;
+}
+
+type ReadAliases = () => Promise<unknown>;
+type IsCurrent = (snapshot?: HostProjectAliasesSnapshot) => boolean;
+interface AliasRead {
+ read: ReadAliases;
+ isCurrent: IsCurrent;
+ revision: number;
+ pending?: Promise<void>;
+}
+
+function missingChannel(error: unknown): boolean {
+ const record = error && typeof error === 'object' ? error as Record<string, unknown> : null;
+ const code = typeof record?.code === 'string' ? record.code : undefined;
+ const message = typeof error === 'string' ? error : record?.message;
+ const resolved = code ?? (typeof message === 'string' ? message.match(/\[([A-Z0-9_]+)\]/)?.[1] : undefined);
+ return resolved === 'CHANNEL_NOT_ALLOWED' || resolved === 'DEVICE_LINK_CHANNEL_NOT_ALLOWED';
+}
+
+function snapshotsEqual(a: HostProjectAliasesSnapshot | undefined, b: HostProjectAliasesSnapshot): boolean {
+ return !!a && a.platform === b.platform
+ && a.ownerStamp?.dataOwnerId === b.ownerStamp?.dataOwnerId
+ && a.ownerStamp?.ownerGeneration === b.ownerStamp?.ownerGeneration
+ && a.aliases.length === b.aliases.length
+ && a.aliases.every((row, index) => row.projectKey === b.aliases[index].projectKey && row.alias === b.aliases[index].alias);
+}
+
+/** In-memory read model. Hosts own persistence; adapters own authorization and connection recovery. */
+export function createProjectAliasMirror() {
+ let snapshots: ProjectAliasesByDevice = new Map();
+ const reads = new Map<string, AliasRead>();
+ const listeners = new Set<() => void>();
+ const notify = () => { for (const listener of listeners) listener(); };
+ // Display metadata has its own small budget; it never holds up session-list recovery.
+ let activeReads = 0;
+ const waitingReads: (() => void)[] = [];
+ async function acquireReadSlot(): Promise<() => void> {
+ if (activeReads >= 6) await new Promise<void>((resolve) => { waitingReads.push(resolve); });
+ else activeReads += 1;
+ return () => {
+ const next = waitingReads.shift();
+ if (next) next(); // Transfer the occupied slot directly to the next waiting reader.
+ else activeReads -= 1;
+ };
+ }
+
+ function apply(deviceId: string, snapshot: HostProjectAliasesSnapshot): void {
+ if (snapshotsEqual(snapshots.get(deviceId), snapshot)) return;
+ const next = new Map(snapshots);
+ next.set(deviceId, snapshot);
+ snapshots = next;
+ notify();
+ }
+
+ function request(deviceId: string, read: ReadAliases, isCurrent: IsCurrent = () => true, invalidate = false): Promise<void> {
+ let state = reads.get(deviceId);
+ if (!state) {
+ state = { read, isCurrent, revision: 0 };
+ reads.set(deviceId, state);
+ }
+ state.read = read;
+ state.isCurrent = isCurrent;
+ if (invalidate) state.revision += 1;
+ if (state.pending) return state.pending;
+ const active = state;
+ // Defer execution until pending is assigned, including synchronous reader throws.
+ const pending = Promise.resolve().then(async () => {
+ while (reads.get(deviceId) === active) {
+ const release = await acquireReadSlot();
+ if (reads.get(deviceId) !== active || !active.isCurrent()) {
+ release();
+ return;
+ }
+ const revision = active.revision;
+ const guard = active.isCurrent;
+ const loader = active.read;
+ try {
+ const snapshot = parseHostProjectAliasesSnapshot(await loader());
+ if (reads.get(deviceId) !== active) return;
+ if (revision !== active.revision) continue;
+ if (snapshot && guard(snapshot)) apply(deviceId, snapshot);
+ } catch (error) {
+ if (reads.get(deviceId) !== active) return;
+ if (revision !== active.revision) continue;
+ // A transient failure must not erase a known name. An old host has no aliases to mirror.
+ if (missingChannel(error) && guard()) apply(deviceId, { aliases: [], platform: '' });
+ } finally {
+ release();
+ }
+ // A synchronous subscriber can invalidate while apply() publishes the snapshot.
+ if (revision !== active.revision) continue;
+ active.pending = undefined;
+ return;
+ }
+ }).finally(() => {
+ if (reads.get(deviceId) === active && active.pending === pending) active.pending = undefined;
+ });
+ active.pending = pending;
+ return pending;
+ }
+
+ return {
+ getSnapshot: (): ProjectAliasesByDevice => snapshots,
+ subscribe(listener: () => void): () => void {
+ listeners.add(listener);
+ return () => { listeners.delete(listener); };
+ },
+ refresh: (deviceId: string, read: ReadAliases, isCurrent?: IsCurrent) => request(deviceId, read, isCurrent),
+ invalidate: (deviceId: string, read: ReadAliases, isCurrent?: IsCurrent) => request(deviceId, read, isCurrent, true),
+ suspend(deviceId: string): void { reads.delete(deviceId); },
+ remove(deviceId: string): void {
+ reads.delete(deviceId);
+ if (!snapshots.has(deviceId)) return;
+ const next = new Map(snapshots);
+ next.delete(deviceId);
+ snapshots = next;
+ notify();
+ },
+ clear(): void {
+ reads.clear();
+ if (snapshots.size === 0) return;
+ snapshots = new Map();
+ notify();
+ },
+ };
+}
diff --git a/packages/maker-shared/src/sessionList.ts b/packages/maker-shared/src/sessionList.ts
index 148992a391..34281d314f 100644
--- a/packages/maker-shared/src/sessionList.ts
+++ b/packages/maker-shared/src/sessionList.ts
@@ -9,6 +9,7 @@ import { sessionCollaborationLabel, sessionWorktreeLabel } from './sessionIdenti
import { isDefaultDraftSessionTitle } from './sessionTitle.js';
import { getSessionListCollapseView } from './sessionListCollapse.js';
import { collapseWorktreeDirForGrouping } from './worktreePaths.js';
+import { resolveProjectAliasForSessions, type ProjectAliasesByDevice } from './projectAliasSync.js';
let sessionListCollator: Intl.Collator | undefined;
/** Call when the host resumes after system locale/region preferences may change. */
@@ -48,6 +49,8 @@ export interface RemoteSessionListSessionLike extends SessionInterruptionState {
userSendAt?: string | null;
workspaceKind?: 'project' | 'dialogue' | string | null;
workingDir: string | null;
+ remoteHostId?: string | null;
+ deviceLinkDeviceId?: string | null;
worktreePath?: string | null;
// device-link 会话列表(local-db:sessions:list)带的最近一条 user/assistant 消息纯文本预览,
// 由桌面 sessionToCamel 产出(已处理 clearedAt / rewind / 角色过滤);idle 会话直接显示,
@@ -170,6 +173,9 @@ export interface RemoteSessionListContext {
export type RemoteSessionStatusFilter = 'active' | 'waiting' | 'automation' | 'archived' | 'all';
export interface RemoteSessionListOptions {
+ projectAliases?: ProjectAliasesByDevice;
+ /** A single-device detail view may have rows without controller-local device metadata. */
+ projectAliasDeviceId?: string;
statusFilter?: RemoteSessionStatusFilter;
messagePreviewIndex?: ReadonlyMap<string, string>;
liveActivityIndex?: ReadonlyMap<string, RemoteSessionLiveActivity>;
@@ -228,7 +234,7 @@ export function buildRemoteSessionSections(
sections.push({ key: 'pinned', title: '置顶', data: pinned });
}
- sections.push(...buildProjectSections(rest, now, groupAutomations, options.localizer));
+ sections.push(...buildProjectSections(rest, now, groupAutomations, options.localizer, options));
return sections;
}
@@ -391,6 +397,7 @@ function buildProjectSections(
now: number,
groupAutomations = true,
localizer?: PresentationLocalizer,
+ options: RemoteSessionListOptions = {},
): RemoteSessionSection[] {
const dialogue = groupAutomationListItems(items.filter((item) => isDialogueSession(item.session)), now, groupAutomations, undefined, localizer);
const sections: RemoteSessionSection[] = [];
@@ -411,7 +418,8 @@ function buildProjectSections(
for (const [workingDir, data] of [...projectGroups].sort(([a], [b]) => compareSessionListStrings(a, b))) {
sections.push({
key: `project:${workingDir}`,
- title: projectTitle(workingDir),
+ title: resolveProjectAliasForSessions(data.map((item) => item.session), options.projectAliases, options.projectAliasDeviceId)
+ ?? projectTitle(workingDir),
data: groupAutomationListItems(data, now, groupAutomations, undefined, localizer),
});
}