@shardflux/cli 0.13.6 → 0.14.1

package/dist/agent-target-commands.js

@@ -9,13 +9,16 @@ import { join, relative } from 'node:path';
 import { projectIdentity } from "./project-identity.js";
 import { projectWorkspacePath } from "./agent-repository.js";
 import { UsageError } from "./errors.js";
+import { prepareDesktopRouter } from "./conversation-router.js";
 import { openUrl } from "./browser.js";
+import { agentMachineName, prepareAgentMachine } from "./agent-machine.js";
+import { prewarmT3 } from "./t3-runtime.js";
+import { AgentStateStore } from "./agent-state.js";
 const missing = (e) => e instanceof ShardfluxApiError && e.status === 404;
 const keyOf = (ref) => ref.includes('/') ? ref : `${projectIdentity('./').slug}/${ref}`;
 /** Optimistic file replacement preserves keys installed by other devices connecting at the same time. */
 export async function installDeviceKey(cell, key, signal) {
     const path = '/home/user/.ssh/authorized_keys';
-    await cell.files.mkdir('/home/user/.ssh', { mode: '0700', parents: true });
     for (let attempt = 0; attempt < 4; attempt++) {
         let text = '', revision = 'absent';
         try {
@@ -30,8 +33,11 @@ export async function installDeviceKey(cell, key, signal) {
                 throw e;
         }
         const publicPart = key.split(' ').slice(0, 2).join(' ');
+        // A reconnect finds its key with one read; only a first key creates the directory.
         if (text.split('\n').some(line => line.trim().split(/\s+/).slice(0, 2).join(' ') === publicPart))
             return;
+        if (revision === 'absent')
+            await cell.files.mkdir('/home/user/.ssh', { mode: '0700', parents: true });
         try {
             await cell.files.patch({ path, content: text + (text && !text.endsWith('\n') ? '\n' : '') + key + '\n', expectedRevision: revision, mode: '0600' }, { signal });
             return;
@@ -43,18 +49,26 @@ export async function installDeviceKey(cell, key, signal) {
     }
     throw new Error('authorized_keys kept changing; retry the SSH connection');
 }
-/** Host trust is established over the authenticated files API, before sending any SSH protocol bytes. */
-export async function prepareSsh(ws, ctx, targets, host) {
+async function sshCell(ws, ctx) {
     if (!ws.ready)
         await ws.wake({ timeoutMs: ctx.wakeTimeoutMs, signal: ctx.signal });
-    const cell = ws.cell({ agentLabel: ctx.agentLabel, transitionTimeoutMs: ctx.wakeTimeoutMs });
-    const hostKey = await cell.files.readText('/etc/ssh/ssh_host_ed25519_key.pub', { length: 4096 });
-    targets.pin(host, hostKey);
-    await installDeviceKey(cell, targets.deviceKey(), ctx.signal);
+    if (ws.labels?.t3_environment_id)
+        await prepareAgentMachine(ctx, ws);
+    return ws.cell({ agentLabel: ctx.agentLabel, transitionTimeoutMs: ctx.wakeTimeoutMs });
+}
+/** Host trust over the authenticated files API: the host key pin and this device's key, read together. */
+async function trustSsh(cell, targets, host, signal) {
+    const [hostKey] = await Promise.all([cell.files.readText('/etc/ssh/ssh_host_ed25519_key.pub', { length: 4096 }), installDeviceKey(cell, targets.deviceKey(), signal)]);
+    await targets.pin(host, hostKey, signal);
+}
+/** Host trust is established over the authenticated files API, before sending any SSH protocol bytes. */
+export async function prepareSsh(ws, ctx, targets, host) {
+    const cell = await sshCell(ws, ctx);
+    await trustSsh(cell, targets, host, ctx.signal);
     return cell;
 }
 async function openApp(target, env) {
-    const child = spawn('open', ['-b', target === 'claude-desktop' ? 'com.anthropic.claudefordesktop' : 'com.openai.codex'], { env, stdio: 'ignore' });
+    const child = spawn('open', ['-b', { 'claude-desktop': 'com.anthropic.claudefordesktop', 'codex-app': 'com.openai.codex', t3: 'com.t3tools.t3code' }[target]], { env, stdio: 'ignore' });
     await new Promise((resolve, reject) => {
         const timer = setTimeout(() => { child.kill('SIGKILL'); reject(new Error('app launcher timed out')); }, 10_000);
         child.once('error', e => { clearTimeout(timer); reject(e); });
@@ -64,10 +78,10 @@ async function openApp(target, env) {
             reject(new Error(`app launcher exited ${code}`)); });
     });
 }
-export function proxyStream(io) {
+export function proxyStream(io, ended, outputGate) {
     const stdout = io.stdout;
     const source = Readable.from(io.stdin, { objectMode: false });
-    let blocked = false;
+    let blocked = false, gate = outputGate;
     const pump = () => {
         while (!blocked && !stream.destroyed) {
             const bytes = source.read();
@@ -80,27 +94,43 @@ export function proxyStream(io) {
         allowHalfOpen: true,
         read() { blocked = false; pump(); },
         write(bytes, _encoding, done) {
-            try {
-                if (stdout.write(bytes))
-                    done();
-                else if (stdout.once)
-                    stdout.once('drain', done);
-                else
-                    done(new Error('stdout cannot signal backpressure'));
-            }
-            catch (e) {
-                done(e);
-            }
+            const send = () => {
+                try {
+                    if (stdout.write(bytes))
+                        done();
+                    else if (stdout.once)
+                        stdout.once('drain', done);
+                    else
+                        done(new Error('stdout cannot signal backpressure'));
+                }
+                catch (e) {
+                    done(e);
+                }
+            };
+            // No guest byte reaches the SSH client before the gate opens (its host key pinned).
+            if (gate)
+                void gate.then(() => { gate = undefined; send(); }, (e) => done(e instanceof Error ? e : new Error(String(e))));
+            else
+                send();
         },
-        destroy(error, done) { source.destroy(); done(error); },
+        // A guest can close before SSH authenticates (e.g. sshd MaxStartups).
+        // Once output drains, end the proxy so SSH sees EOF instead of waiting
+        // for input EOF from the client that is itself waiting for us.
+        final(done) { done(); ended?.(); },
+        destroy(error, done) { source.destroy(); stdout.off?.('error', outputError); stdout.off?.('close', outputClosed); done(error); },
     });
+    const outputError = (error) => stream.destroy(error);
+    const outputClosed = () => stream.destroy(new Error('SSH client output closed'));
+    stdout.once?.('error', outputError);
+    stdout.once?.('close', outputClosed);
     source.on('readable', pump);
-    source.once('end', () => stream.push(null));
+    source.once('end', () => { stream.push(null); ended?.(); });
     source.once('error', (error) => stream.destroy(error));
     return stream;
 }
 const openTarget = (target) => async (ctx, values, [ref = 'main']) => {
-    if (target !== 'web' && !installedTargets(ctx.io.env).targets.includes(target))
+    const detected = installedTargets(ctx.io.env);
+    if (target !== 'web' && !detected.targets.includes(target))
         throw new UsageError(`${target} is not installed on this machine`);
     let ws = await resolveWorkspace(ctx, keyOf(ref));
     if (values.reachable !== undefined)
@@ -125,37 +155,57 @@ const openTarget = (target) => async (ctx, values, [ref = 'main']) => {
         out(ctx, `${url}\n`, { target, workspace: ws.data, url });
         return 0;
     }
+    return openDesktopWorkspace(ctx, ws, target, detected.versions.t3);
+};
+export async function openDesktopWorkspace(ctx, ws, target, t3Version, prewarmed = false) {
+    if (target !== 't3')
+        ws = await prepareDesktopRouter(ctx, ws);
+    await prepareAgentMachine(ctx, ws);
+    if (target === 't3' && t3Version && !prewarmed)
+        await queueT3Prewarm(ctx, ws, t3Version);
     const targets = new AgentTargets(ctx.io.env, ctx.store.dir);
-    const entry = targets.configure(ws.key, ctx.apiUrl, [target]).find(e => e.workspace === ws.key);
-    const instructions = target === 'claude-desktop'
-        ? `Restart Claude Desktop to load the connection, then choose Shardflux · ${entry.project} · ${entry.agent} in Code's environment dropdown and open ${projectWorkspacePath({ slug: entry.project })}.`
-        : `Restart Codex to import ${entry.host} and its remote project. If it has already been imported, enable ${entry.host} in Settings → Connections → SSH.`;
+    const entry = (await (ws.labels.shard_router === 'project' ? targets.configureProject(ws.key, ctx.apiUrl, [target], ctx.signal) : targets.configure(ws.key, ctx.apiUrl, [target], false, ctx.signal))).find(e => e.workspace === ws.key);
+    const instructions = target === 't3'
+        ? `Add environment → SSH → ${entry.host} (${agentMachineName(ws.key)}), then open ${projectWorkspacePath({ slug: entry.project })}.`
+        : target === 'claude-desktop'
+            ? `Restart Claude Desktop to load the connection, then choose ${targetLabel(entry)} in Code's environment dropdown and open ${projectWorkspacePath({ slug: entry.project })}.`
+            : `Restart Codex to import ${entry.host} and its remote project. If it has already been imported, enable ${entry.host} in Settings → Connections → SSH.`;
     if (!ctx.json)
         await openApp(target, ctx.io.env);
+    new AgentStateStore(ctx.store.dir).saveTarget(ws.labels.repo_remote || ws.labels.shard_project || entry.project, target);
     out(ctx, `${instructions}\n`, { target, workspace: ws.data, host: entry.host, instructions });
     return 0;
-};
+}
+export async function queueT3Prewarm(ctx, ws, version) {
+    try {
+        await prewarmT3(ctx, ws, version);
+    }
+    catch (error) {
+        ctx.io.stderr.write(`T3 runtime will install on connect: ${error instanceof Error ? error.message : String(error)}\n`);
+    }
+}
 const tilde = (targets, file) => file.startsWith(`${targets.home}/`) ? `~/${relative(targets.home, file)}` : file;
-const targetLabel = (e) => `[SF] ${e.project} · ${e.agent}`;
+const targetLabel = (e) => e.agent === 'router' ? `Shardflux · ${e.project}` : `[SF] ${e.project} · ${e.agent}`;
 /** Where each managed connection of an entry lives: the SSH host block (and its Include), then each desktop app's file. */
-function configuredTargets(targets, e) {
+function configuredTargets(targets, e, t3 = false) {
     return [
         { target: 'ssh', label: 'SSH', file: targets.sshFile, name: e.host, detail: `(included from ${tilde(targets, join(targets.home, '.ssh', 'config'))}): ssh ${e.host}` },
         ...(e.targets.includes('claude-desktop') ? [{ target: 'claude-desktop', label: 'Claude Desktop', file: targets.claudeFile, name: targetLabel(e), detail: `(sshConfigs: ${targetLabel(e)}); restart Claude Desktop, then pick it in Code's environment list` }] : []),
         ...(e.targets.includes('codex-app') ? [{ target: 'codex-app', label: 'Codex app', file: targets.codexFile, name: targetLabel(e), detail: `(remoteConnections: ${targetLabel(e)}); restart Codex to import it` }] : []),
+        ...(t3 ? [{ target: 't3', label: 'T3 Code', file: targets.sshFile, name: agentMachineName(e.workspace), detail: `Add environment → SSH → ${e.host}; project ${projectWorkspacePath({ slug: e.project })}` }] : []),
     ];
 }
 function targetFiles(targets, entries) {
     return [...new Set(entries.flatMap(e => configuredTargets(targets, e).map(c => c.file)))];
 }
 export const TARGET_HANDLERS = {
-    'agents targets'(ctx, values, [ref]) {
+    async 'agents targets'(ctx, values, [ref]) {
         const detected = installedTargets(ctx.io.env);
         const targets = new AgentTargets(ctx.io.env, ctx.store.dir);
         const key = ref ? keyOf(ref) : undefined;
-        const before = values.remove === true ? targets.configure(undefined, ctx.apiUrl, []) : [];
+        const before = values.remove === true ? await targets.configure(undefined, ctx.apiUrl, [], false, ctx.signal) : [];
         const entries = ref || values.remove === true
-            ? targets.configure(key, ctx.apiUrl, detected.targets.filter((t) => t === 'claude-desktop' || t === 'codex-app'), values.remove === true)
+            ? await targets.configure(key, ctx.apiUrl, detected.targets.filter((t) => t === 'claude-desktop' || t === 'codex-app' || t === 't3'), values.remove === true, ctx.signal)
             : [];
         const detection = `${detected.clients.join(', ') || 'No installed agent clients'}\nOpen targets: ${detected.targets.join(', ')}\n`;
         if (values.remove === true) {
@@ -168,23 +218,43 @@ export const TARGET_HANDLERS = {
             out(ctx, detection, { ...detected, entries });
             return Promise.resolve(0);
         }
-        const configured = configuredTargets(targets, entry);
+        const t3 = detected.targets.includes('t3');
+        const configured = configuredTargets(targets, entry, t3);
         out(ctx, `Configured ${entry.workspace} as SSH host ${entry.host}:\n${configured.map(c => `  ${c.label.padEnd(15)} ${tilde(targets, c.file)}${c.detail ? ` ${c.detail}` : ''}`).join('\n')}\n` +
-            ['claude-desktop', 'codex-app'].filter(t => !entry.targets.includes(t)).map(t => `  ${(t === 'claude-desktop' ? 'Claude Desktop' : 'Codex app').padEnd(15)} not installed on this computer\n`).join(''), { ...detected, entries, configured: configured.map(({ target, file, name }) => ({ target, file, name })) });
+            ['claude-desktop', 'codex-app', 't3'].filter(t => t === 't3' ? !t3 : !entry.targets.includes(t)).map(t => `  ${{ 'claude-desktop': 'Claude Desktop', 'codex-app': 'Codex app', t3: 'T3 Code' }[t].padEnd(15)} not installed on this computer\n`).join(''), { ...detected, entries, configured: configured.map(({ target, file, name }) => ({ target, file, name })) });
         return Promise.resolve(0);
     },
     'agents open claude-desktop': openTarget('claude-desktop'),
     'agents open codex-app': openTarget('codex-app'),
+    'agents open t3': openTarget('t3'),
     'agents open web': openTarget('web'),
     async 'ssh-proxy'(ctx, _values, [host]) {
         if (ctx.json || !host)
             throw new UsageError('ssh-proxy requires a managed host and binary standard IO');
         const targets = new AgentTargets(ctx.io.env, ctx.store.dir), entry = targets.entry(host, ctx.apiUrl);
-        const ws = await resolveWorkspace(ctx, entry.workspace);
-        const cell = await prepareSsh(ws, ctx, targets, host);
-        const stream = proxyStream(ctx.io);
+        const controller = new AbortController();
+        const signal = AbortSignal.any([ctx.signal, controller.signal]);
+        const proxyCtx = { ...ctx, signal };
+        let trusted, distrusted;
+        const trust = new Promise((resolve, reject) => { trusted = resolve; distrusted = reject; });
+        trust.catch(() => { });
+        const stream = proxyStream(ctx.io, () => controller.abort(new Error('SSH proxy stream ended')), trust);
+        stream.on('error', error => controller.abort(error));
         try {
-            const tunnel = await new WorkspaceTunnels(() => cell, () => ws.grantedTools).forward({ remotePort: 22, stream, signal: ctx.signal });
+            const ws = await resolveWorkspace(proxyCtx, entry.workspace);
+            void ws.hint({ signal }).catch(() => undefined);
+            const cell = await sshCell(ws, proxyCtx);
+            // Trust and the tunnel start run together; the stream holds guest bytes until the host key is pinned.
+            const trusting = trustSsh(cell, targets, host, signal).then(trusted, (e) => { distrusted(e); controller.abort(e); throw e; });
+            const [opened, checked] = await Promise.allSettled([new WorkspaceTunnels(() => cell, () => ws.grantedTools).forward({ remotePort: 22, stream, signal, passive: true }), trusting]);
+            if (checked.status === 'rejected') {
+                if (opened.status === 'fulfilled')
+                    await opened.value.close().catch(() => { });
+                throw checked.reason;
+            }
+            if (opened.status === 'rejected')
+                throw opened.reason;
+            const tunnel = opened.value;
             try {
                 await tunnel.closed;
             }

package/dist/agent-targets.d.ts

@@ -1,4 +1,4 @@
-export type DesktopTarget = 'claude-desktop' | 'codex-app';
+export type DesktopTarget = 'claude-desktop' | 'codex-app' | 't3';
 export interface TargetEntry {
     host: string;
     workspace: string;
@@ -10,9 +10,10 @@ export interface TargetEntry {
 export declare function targetIdentity(key: string): Pick<TargetEntry, 'host' | 'workspace' | 'project' | 'agent'>;
 /** Replace only a marked block, retaining every byte outside it. Put Includes before user Host blocks. */
 export declare function managedBlock(text: string, body: string): string;
-export declare function installedTargets(env: Record<string, string | undefined>, platform?: NodeJS.Platform): {
+export declare function installedTargets(env: Record<string, string | undefined>, platform?: NodeJS.Platform, appDirs?: string[]): {
     targets: string[];
     clients: string[];
+    versions: Partial<Record<DesktopTarget, string>>;
 };
 /** All paths are supplied by the invocation; tests use a temporary HOME, never the owner's app stores. */
 export declare class AgentTargets {
@@ -28,6 +29,7 @@ export declare class AgentTargets {
     constructor(env: Record<string, string | undefined>, dir: string);
     entry(host: string, apiUrl: string): TargetEntry;
     deviceKey(): string;
-    pin(host: string, publicKey: string): void;
-    configure(key: string | undefined, apiUrl: string, targets: DesktopTarget[], remove?: boolean): TargetEntry[];
+    pin(host: string, publicKey: string, signal?: AbortSignal): Promise<void>;
+    configure(key: string | undefined, apiUrl: string, targets: DesktopTarget[], remove?: boolean, signal?: AbortSignal): Promise<TargetEntry[]>;
+    configureProject(key: string, apiUrl: string, targets: DesktopTarget[], signal?: AbortSignal): Promise<TargetEntry[]>;
 }

package/dist/agent-targets.js

@@ -1,16 +1,20 @@
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { accessSync, constants, chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { accessSync, constants, chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { writePrivateFile } from "./credentials.js";
 import { UsageError } from "./errors.js";
 import { projectWorkspacePath } from "./agent-repository.js";
+import { withTargetLock } from "./target-lock.js";
+const PERSISTED_TARGETS = ['claude-desktop', 'codex-app'];
 const BEGIN = '# BEGIN Shardflux managed targets';
 const END = '# END Shardflux managed targets';
 const object = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 const shellQuote = (s) => "'" + s.replaceAll("'", "'\\''").replaceAll('%', '%%') + "'";
 const quote = (s) => '"' + s.replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('%', '%%') + '"';
+// Some SSH config readers (T3 Code's host discovery) split Include on whitespace and keep quotes; quote only when needed.
+const includePath = (s) => /^[^\s"'\\#%]+$/.test(s) ? s : quote(s);
 export function targetIdentity(key) {
     const parts = key.split('/');
     if (parts.length !== 2 || parts.some(p => !/^[a-z0-9][a-z0-9._-]{0,95}$/.test(p)))
@@ -29,15 +33,48 @@ export function managedBlock(text, body) {
     const stop = end + END.length + (text[end + END.length] === '\n' ? 1 : 0);
     return text.slice(0, start) + block + text.slice(stop);
 }
-export function installedTargets(env, platform = process.platform) {
+export function installedTargets(env, platform = process.platform, appDirs) {
     const home = env.HOME || homedir();
-    const hasApp = (name, bundle) => platform === 'darwin' && [join('/Applications', name), join(home, 'Applications', name)].some(path => {
+    // SHARDFLUX_APPLICATIONS_DIRS (colon-separated) replaces the scanned app folders, like SHARDFLUX_CONFIG_DIR does for config.
+    const dirs = appDirs ?? (env.SHARDFLUX_APPLICATIONS_DIRS !== undefined ? env.SHARDFLUX_APPLICATIONS_DIRS.split(':').filter(Boolean) : ['/Applications', join(home, 'Applications')]);
+    const hasApp = (name, bundle) => platform === 'darwin' && dirs.map(dir => join(dir, name)).some(path => {
         const info = join(path, 'Contents', 'Info.plist');
         if (!existsSync(info))
             return false;
         const result = spawnSync('/usr/libexec/PlistBuddy', ['-c', 'Print :CFBundleIdentifier', info], { input: '', encoding: 'utf8', timeout: 1000 });
         return result.status === 0 && result.stdout.trim() === bundle;
     });
+    const versions = {};
+    let t3 = false;
+    if (platform === 'darwin')
+        for (const dir of dirs) {
+            let names;
+            try {
+                names = readdirSync(dir);
+            }
+            catch {
+                continue;
+            }
+            for (const name of names.filter(name => name.endsWith('.app'))) {
+                const info = join(dir, name, 'Contents', 'Info.plist');
+                // XML and binary plists store this ASCII bundle id verbatim. Avoid a
+                // subprocess for every unrelated app on the normal no-T3 path.
+                try {
+                    if (!readFileSync(info).includes('com.t3tools.t3code'))
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+                const result = spawnSync('/usr/libexec/PlistBuddy', ['-c', 'Print :CFBundleIdentifier', '-c', 'Print :CFBundleShortVersionString', info], { input: '', encoding: 'utf8', timeout: 1000 });
+                const [bundle, version] = result.stdout?.trim().split('\n') ?? [];
+                if (bundle !== 'com.t3tools.t3code')
+                    continue;
+                t3 = true;
+                if (result.status === 0 && version && /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version))
+                    versions.t3 ??= version;
+            }
+        }
     const executable = (name) => (env.PATH ?? '').split(':').filter(Boolean).some(p => { try {
         accessSync(join(p, name), constants.X_OK);
         return true;
@@ -46,7 +83,9 @@ export function installedTargets(env, platform = process.platform) {
         return false;
     } });
     const clients = [hasApp('Claude.app', 'com.anthropic.claudefordesktop') && 'claude-desktop', (hasApp('Codex.app', 'com.openai.codex') || hasApp('ChatGPT.app', 'com.openai.codex')) && 'codex-app', executable('claude') && 'claude', executable('codex') && 'codex'].filter((v) => !!v);
-    return { targets: [...(platform === 'darwin' ? clients.filter(c => c.endsWith('-app') || c === 'claude-desktop') : []), 'web'], clients };
+    if (t3)
+        clients.push('t3');
+    return { targets: [...(platform === 'darwin' ? clients.filter(c => c.endsWith('-app') || c === 'claude-desktop' || c === 't3') : []), 'web'], clients, versions };
 }
 /** All paths are supplied by the invocation; tests use a temporary HOME, never the owner's app stores. */
 export class AgentTargets {
@@ -107,11 +146,16 @@ export class AgentTargets {
         if (Object.values(doc.created).some(v => !Array.isArray(v) || v.some(k => typeof k !== 'string')))
             throw new UsageError('invalid target ownership metadata');
         for (const e of doc.entries) {
-            if (!object(e) || typeof e.workspace !== 'string' || typeof e.api_url !== 'string' || /[\r\n\0]/.test(e.api_url) || !Array.isArray(e.targets) || e.targets.some(t => t !== 'claude-desktop' && t !== 'codex-app'))
+            if (!object(e) || typeof e.workspace !== 'string' || typeof e.api_url !== 'string' || /[\r\n\0]/.test(e.api_url) || !Array.isArray(e.targets) || e.targets.some(t => typeof t !== 'string'))
                 throw new UsageError('invalid Shardflux target entry');
+            // Forward compatible: a newer CLI may record targets this one does not know; they write no files here.
+            e.targets = e.targets.filter(t => PERSISTED_TARGETS.includes(t));
             const identity = targetIdentity(e.workspace);
             if (identity.host !== e.host || identity.project !== e.project || identity.agent !== e.agent)
                 throw new UsageError('invalid Shardflux target identity');
+            // Earlier CVE entries used this optional flag. Identity now comes solely
+            // from the router workspace key; remove the obsolete flag on rewrite.
+            delete e.project_router;
         }
         return doc;
     }
@@ -139,8 +183,8 @@ export class AgentTargets {
         const key = r.stdout.trim().split(/\s+/).slice(0, 2).join(' ');
         return `${key} shardflux-device-${createHash('sha256').update(key).digest('hex').slice(0, 16)}`;
     }
-    pin(host, publicKey) {
-        this.#locked(() => this.#pin(host, publicKey));
+    pin(host, publicKey, signal) {
+        return withTargetLock(this.dir, () => this.#pin(host, publicKey), signal);
     }
     #pin(host, publicKey) {
         if (!/^shardflux-[a-z0-9._-]+$/.test(host) || !/^ssh-ed25519 [A-Za-z0-9+/=]+(?: [^\r\n]*)?$/.test(publicKey.trim()))
@@ -156,28 +200,19 @@ export class AgentTargets {
         if (!previous.length)
             writePrivateFile(this.dir, this.knownHosts, text + (text && !text.endsWith('\n') ? '\n' : '') + `${host} ${key}\n`);
     }
-    configure(key, apiUrl, targets, remove = false) {
-        return this.#locked(() => this.#configure(key, apiUrl, targets, remove));
+    configure(key, apiUrl, targets, remove = false, signal) {
+        return withTargetLock(this.dir, () => this.#configure(key, apiUrl, targets, remove), signal);
     }
-    #locked(work) {
-        mkdirSync(this.dir, { recursive: true, mode: 0o700 });
-        const lock = join(this.dir, 'targets.lock');
-        try {
-            mkdirSync(lock, { mode: 0o700 });
-        }
-        catch (e) {
-            if (e.code === 'EEXIST')
-                throw new UsageError('another target update holds targets.lock; retry after it finishes');
-            throw e;
-        }
-        try {
-            return work();
-        }
-        finally {
-            rmSync(lock, { recursive: true });
-        }
+    configureProject(key, apiUrl, targets, signal) {
+        return withTargetLock(this.dir, () => {
+            const identity = targetIdentity(key);
+            if (identity.agent !== 'router')
+                throw new UsageError('Project targets require the managed router workspace.');
+            const previous = this.#manifest().entries.filter(e => e.project === identity.project && e.api_url === apiUrl).flatMap(e => e.targets);
+            return this.#configure(key, apiUrl, [...new Set([...previous, ...targets])], false, true);
+        }, signal);
     }
-    #configure(key, apiUrl, targets, remove) {
+    #configure(key, apiUrl, targets, remove, projectTarget = false) {
         const url = new URL(apiUrl);
         if (!['https:', 'http:'].includes(url.protocol) || url.username || url.password || /[\r\n\0]/.test(apiUrl))
             throw new UsageError('invalid target API URL');
@@ -188,8 +223,11 @@ export class AgentTargets {
         const existing = old.find(e => e.host === identity?.host);
         if (existing && (existing.workspace !== key || existing.api_url !== apiUrl))
             throw new UsageError('SSH alias already belongs to another workspace or API URL');
-        const added = identity ? { ...identity, api_url: apiUrl, targets: [...new Set([...(existing?.targets ?? []), ...targets])] } : undefined;
-        const entries = remove ? old.filter(e => identity ? e.host !== identity.host : e.api_url !== apiUrl) : existing ? old.map(e => e === existing ? added : e) : [...old, added];
+        // Only targets that own a config file are recorded: published CLIs reject any other value in this manifest.
+        const added = identity ? { ...identity, api_url: apiUrl, targets: [...new Set([...(existing?.targets ?? []), ...targets.filter((t) => PERSISTED_TARGETS.includes(t))])] } : undefined;
+        let entries = remove ? old.filter(e => identity ? e.host !== identity.host : e.api_url !== apiUrl) : existing ? old.map(e => e === existing ? added : e) : [...old, added];
+        if (projectTarget)
+            entries = entries.map(e => e.host !== added.host && e.project === added.project && e.api_url === apiUrl ? { ...e, targets: [] } : e);
         const sshConfig = join(this.home, '.ssh', 'config');
         const writes = new Map();
         const rememberFile = (file) => {
@@ -208,7 +246,7 @@ export class AgentTargets {
             const text = this.#text(this.knownHosts);
             writes.set(this.knownHosts, text.split(/(?<=\n)/).filter(line => !removed.some(e => line.split(/\s+/)[0] === e.host)).join(''));
         }
-        writes.set(sshConfig, managedBlock(this.#text(sshConfig), entries.length ? `Include ${quote(this.sshFile)}` : ''));
+        writes.set(sshConfig, managedBlock(this.#text(sshConfig), entries.length ? `Include ${includePath(this.sshFile)}` : ''));
         const blocks = entries.map(e => `Host ${e.host}\n  HostName ${e.host}\n  ProxyCommand ${this.dir === join(this.home, '.config', 'shardflux') ? '' : `env ${shellQuote(`SHARDFLUX_CONFIG_DIR=${this.dir}`)} `}shard ssh-proxy %n --api-url ${shellQuote(e.api_url)}\n  User user\n  UserKnownHostsFile ${quote(this.knownHosts)}\n  StrictHostKeyChecking yes\n  IdentityFile ${quote(this.identityFile)}\n  IdentitiesOnly yes`);
         writes.set(this.sshFile, managedBlock(this.#text(this.sshFile), blocks.join('\n\n')));
         for (const [file, prop, target] of [[this.claudeFile, 'sshConfigs', 'claude-desktop'], [this.codexFile, 'remoteConnections', 'codex-app']]) {
@@ -229,7 +267,10 @@ export class AgentTargets {
             manifest.created[file] ??= [];
             if (!(prop in doc) && !manifest.created[file].includes(prop))
                 manifest.created[file].push(prop);
-            doc[prop] = [...kept, ...entries.filter(e => e.targets.includes(target)).map(e => target === 'claude-desktop' ? { id: e.host, name: `[SF] ${e.project} · ${e.agent}`, sshHost: e.host, startDirectory: projectWorkspacePath({ slug: e.project }) } : { sshAlias: e.host, projects: [{ remotePath: projectWorkspacePath({ slug: e.project }), label: `[SF] ${e.project} · ${e.agent}` }] })];
+            doc[prop] = [...kept, ...entries.filter(e => e.targets.includes(target)).map(e => {
+                    const label = e.agent === 'router' ? `Shardflux · ${e.project}` : `[SF] ${e.project} · ${e.agent}`;
+                    return target === 'claude-desktop' ? { id: e.host, name: label, sshHost: e.host, startDirectory: projectWorkspacePath({ slug: e.project }) } : { sshAlias: e.host, projects: [{ remotePath: projectWorkspacePath({ slug: e.project }), label }] };
+                })];
             if (!doc[prop].length && manifest.created[file].includes(prop))
                 delete doc[prop];
             if (file === this.codexFile) {

package/dist/args.d.ts

@@ -1,4 +1,4 @@
-export declare const CLI_VERSION = "0.13.6";
+export declare const CLI_VERSION = "0.14.1";
 export interface OptionSpec {
     type: 'string' | 'boolean';
     short?: string;