@shardflux/cli 0.11.0 → 0.13.0

package/dist/agent-targets.js

@@ -0,0 +1,267 @@
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { accessSync, constants, chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, 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";
+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('%', '%%') + '"';
+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)))
+        throw new UsageError('desktop targets require a <project>/<agent> workspace key');
+    const [project, agent] = parts;
+    return { host: `shardflux-${project}-${agent}`, workspace: key, project, agent };
+}
+/** Replace only a marked block, retaining every byte outside it. Put Includes before user Host blocks. */
+export function managedBlock(text, body) {
+    const start = text.indexOf(BEGIN), end = text.indexOf(END);
+    if ((start < 0) !== (end < 0) || (start >= 0 && (end < start || text.indexOf(BEGIN, start + BEGIN.length) >= 0 || text.indexOf(END, end + END.length) >= 0)))
+        throw new UsageError('malformed Shardflux managed block; repair it before updating targets');
+    const block = body ? `${BEGIN}\n${body}\n${END}\n` : '';
+    if (start < 0)
+        return block + text;
+    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) {
+    const home = env.HOME || homedir();
+    const hasApp = (name, bundle) => platform === 'darwin' && [join('/Applications', name), join(home, 'Applications', 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 executable = (name) => (env.PATH ?? '').split(':').filter(Boolean).some(p => { try {
+        accessSync(join(p, name), constants.X_OK);
+        return true;
+    }
+    catch {
+        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 };
+}
+/** All paths are supplied by the invocation; tests use a temporary HOME, never the owner's app stores. */
+export class AgentTargets {
+    home;
+    dir;
+    identityFile;
+    knownHosts;
+    sshFile;
+    claudeFile;
+    codexFile;
+    manifestFile;
+    constructor(env, dir) {
+        this.home = resolve(env.HOME || homedir());
+        this.dir = resolve(dir);
+        this.identityFile = join(this.dir, 'ssh', 'id_ed25519');
+        this.knownHosts = join(this.dir, 'known_hosts');
+        this.sshFile = join(this.dir, 'ssh_config');
+        this.claudeFile = join(env.CLAUDE_CONFIG_DIR || join(this.home, '.claude'), 'settings.json');
+        this.codexFile = join(env.CODEX_HOME || join(this.home, '.codex'), 'codex-app', 'config.json');
+        this.manifestFile = join(this.dir, 'targets.json');
+        for (const path of [this.home, this.dir, this.identityFile, this.knownHosts, this.sshFile, this.claudeFile, this.codexFile])
+            if (/[\r\n\0]/.test(path))
+                throw new UsageError('target paths must not contain line breaks or NUL');
+    }
+    #text(file) {
+        try {
+            if (lstatSync(file).isSymbolicLink())
+                throw new UsageError(`refusing to replace symlink ${file}`);
+            return readFileSync(file, 'utf8');
+        }
+        catch (e) {
+            if (e.code === 'ENOENT')
+                return '';
+            throw e;
+        }
+    }
+    #json(file) {
+        const text = this.#text(file);
+        if (!text)
+            return {};
+        let doc;
+        try {
+            doc = JSON.parse(text);
+        }
+        catch {
+            throw new UsageError(`invalid JSON in ${file}; it was left unchanged`);
+        }
+        if (!object(doc))
+            throw new UsageError(`${file} must contain a JSON object`);
+        return doc;
+    }
+    #manifest() {
+        const doc = this.#json(this.manifestFile);
+        if (!Object.keys(doc).length)
+            return { version: 1, entries: [], created: {} };
+        if (doc.version !== 1 || !Array.isArray(doc.entries) || !object(doc.created))
+            throw new UsageError('unsupported Shardflux targets manifest');
+        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'))
+                throw new UsageError('invalid Shardflux target entry');
+            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');
+        }
+        return doc;
+    }
+    entry(host, apiUrl) {
+        const entry = this.#manifest().entries.find(e => e.host === host);
+        if (!entry)
+            throw new UsageError(`unknown managed SSH host ${host}; run shard agents targets <project>/<agent>`);
+        if (entry.api_url !== apiUrl)
+            throw new UsageError(`SSH host ${host} belongs to ${entry.api_url}; use that API URL`);
+        return entry;
+    }
+    deviceKey() {
+        mkdirSync(dirname(this.identityFile), { recursive: true, mode: 0o700 });
+        if (!existsSync(this.identityFile)) {
+            const r = spawnSync('ssh-keygen', ['-q', '-t', 'ed25519', '-N', '', '-C', 'shardflux-device', '-f', this.identityFile], { stdio: 'ignore', timeout: 10_000 });
+            if (r.status !== 0)
+                throw new Error('could not generate the Shardflux device SSH key');
+        }
+        if (lstatSync(this.identityFile).isSymbolicLink())
+            throw new UsageError('device SSH key must not be a symlink');
+        chmodSync(this.identityFile, 0o600);
+        const r = spawnSync('ssh-keygen', ['-y', '-f', this.identityFile], { encoding: 'utf8', input: '', timeout: 10_000 });
+        if (r.status !== 0 || !/^ssh-ed25519 [A-Za-z0-9+/=]+(?: [^\r\n]*)?$/.test(r.stdout.trim()))
+            throw new Error('Shardflux device key must be an unencrypted ed25519 key');
+        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) {
+        if (!/^shardflux-[a-z0-9._-]+$/.test(host) || !/^ssh-ed25519 [A-Za-z0-9+/=]+(?: [^\r\n]*)?$/.test(publicKey.trim()))
+            throw new Error('API returned an invalid ed25519 SSH host key');
+        const key = publicKey.trim().split(/\s+/).slice(0, 2).join(' ');
+        const bytes = Buffer.from(key.split(' ')[1], 'base64');
+        if (bytes.length !== 51 || bytes.readUInt32BE(0) !== 11 || bytes.subarray(4, 15).toString() !== 'ssh-ed25519' || bytes.readUInt32BE(15) !== 32)
+            throw new Error('API returned an invalid ed25519 SSH host key');
+        const text = this.#text(this.knownHosts), lines = text.split('\n').filter(Boolean);
+        const previous = lines.filter(l => l.split(/\s+/)[0]?.split(',').includes(host));
+        if (previous.some(l => l.split(/\s+/).slice(1, 3).join(' ') !== key))
+            throw new Error(`SSH host key changed for ${host}; verify the workspace identity before removing its pin`);
+        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));
+    }
+    #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 });
+        }
+    }
+    #configure(key, apiUrl, targets, remove) {
+        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');
+        const manifest = this.#manifest(), old = manifest.entries;
+        const identity = key ? targetIdentity(key) : undefined;
+        if (!remove && !identity)
+            return old;
+        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];
+        const sshConfig = join(this.home, '.ssh', 'config');
+        const writes = new Map();
+        const rememberFile = (file) => {
+            manifest.created[file] ??= [];
+            if (!existsSync(file) && !manifest.created[file].includes('$file'))
+                manifest.created[file].push('$file');
+        };
+        for (const file of [sshConfig, this.sshFile])
+            rememberFile(file);
+        const outside = managedBlock(this.#text(sshConfig), '') + '\n' + managedBlock(this.#text(this.sshFile), '');
+        for (const e of entries)
+            if (outside.split('\n').some(line => /^\s*Host\s+/i.test(line) && line.trim().split(/\s+/).slice(1).includes(e.host)))
+                throw new UsageError(`unmanaged SSH Host already defines ${e.host}`);
+        const removed = old.filter(e => !entries.some(n => n.host === e.host));
+        if (removed.length && existsSync(this.knownHosts)) {
+            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)}` : ''));
+        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']]) {
+            if (!old.some(e => e.targets.includes(target)) && !entries.some(e => e.targets.includes(target)))
+                continue;
+            rememberFile(file);
+            const doc = this.#json(file);
+            if (file === this.codexFile && doc.version !== undefined && doc.version !== 1)
+                throw new UsageError('unsupported Codex app config version; file was left unchanged');
+            if (doc[prop] !== undefined && !Array.isArray(doc[prop]))
+                throw new UsageError(`${file}: ${prop} must be an array`);
+            const values = (doc[prop] ?? []);
+            const identifies = (v, host) => object(v) && (target === 'claude-desktop' ? v.id === host : v.sshAlias === host);
+            for (const e of entries.filter(e => e.targets.includes(target)))
+                if (values.some(v => identifies(v, e.host)) && !old.some(o => o.host === e.host && o.targets.includes(target)))
+                    throw new UsageError(`refusing to replace an unmanaged ${target} entry for ${e.host}`);
+            const kept = values.filter(v => !old.some(e => e.targets.includes(target) && identifies(v, e.host)));
+            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}` }] })];
+            if (!doc[prop].length && manifest.created[file].includes(prop))
+                delete doc[prop];
+            if (file === this.codexFile) {
+                if (!("version" in doc) && prop in doc) {
+                    doc.version = 1;
+                    manifest.created[file].push('version');
+                }
+                if (!(prop in doc) && manifest.created[file].includes('version'))
+                    delete doc.version;
+            }
+            writes.set(file, Object.keys(doc).length || !manifest.created[file].includes('$file') ? JSON.stringify(doc, null, 2) + '\n' : '');
+        }
+        if (!remove)
+            this.deviceKey();
+        // Record ownership before touching app stores, so a partial write can still be removed.
+        manifest.entries = entries;
+        if (!remove)
+            writePrivateFile(this.dir, this.manifestFile, JSON.stringify(manifest, null, 2) + '\n');
+        for (const [file, text] of writes) {
+            if (text) {
+                if (text !== this.#text(file))
+                    writePrivateFile(dirname(file), file, text);
+            }
+            else if (existsSync(file)) {
+                if (manifest.created[file]?.includes('$file') || file === this.knownHosts)
+                    rmSync(file);
+                else
+                    writePrivateFile(dirname(file), file, '');
+            }
+        }
+        if (remove)
+            writePrivateFile(this.dir, this.manifestFile, JSON.stringify(manifest, null, 2) + '\n');
+        return entries;
+    }
+}

package/dist/agent-terminal.d.ts

@@ -0,0 +1,35 @@
+import { PtyConnection } from '@shardflux/sdk';
+import type { CellClient, PtyServerMessage } from '@shardflux/sdk';
+import type { Io } from './commands.js';
+export interface TerminalConnection {
+    input(bytes: Uint8Array): void;
+    resize(rows: number, cols: number): void;
+    messages(): AsyncIterable<PtyServerMessage>;
+    close(): Promise<void>;
+}
+export declare function retryableAttach(error: unknown): boolean;
+/** Offsets address bytes, including escape sequences and UTF-8 split across frames. */
+export declare class PtyOutputCursor {
+    offset: number;
+    consume(message: PtyServerMessage): Buffer | null;
+}
+export interface AttachOptions {
+    io: Io;
+    credentialPrompts?: (ask: (message: string) => Promise<string>, signal: AbortSignal) => Promise<void>;
+    signal: AbortSignal;
+    connect(offset: number, signal: AbortSignal): Promise<TerminalConnection>;
+    wake(signal: AbortSignal): Promise<unknown>;
+    invalidate(): void;
+    sleep(ms: number, signal: AbortSignal): Promise<void>;
+    dimensions?: () => {
+        rows: number;
+        cols: number;
+    };
+    resizeEvents?: {
+        on(event: 'SIGWINCH', listener: () => void): unknown;
+        off(event: 'SIGWINCH', listener: () => void): unknown;
+    };
+}
+/** Detaching closes only this attachment; the workspace PTY and agent keep running. */
+export declare function attachTerminal(options: AttachOptions): Promise<number>;
+export declare function cellConnector(cell: CellClient, sessionId: string): (offset: number, signal: AbortSignal) => Promise<PtyConnection>;

package/dist/agent-terminal.js

@@ -0,0 +1,209 @@
+import { StringDecoder } from 'node:string_decoder';
+import { PtyConnection, ShardfluxApiError, ShardfluxProtocolError, exitCodePosix } from '@shardflux/sdk';
+import { UsageError } from "./errors.js";
+export function retryableAttach(error) {
+    if (error instanceof ShardfluxProtocolError && /invalid|byte gap|omitted/.test(error.message))
+        return false;
+    return !(error instanceof ShardfluxApiError) || error.retryable || ['stale_epoch', 'token_expired', 'workspace_not_running', 'workspace_busy'].includes(error.code);
+}
+/** Offsets address bytes, including escape sequences and UTF-8 split across frames. */
+export class PtyOutputCursor {
+    offset = 0;
+    consume(message) {
+        if (message.type !== 'output')
+            return null;
+        const start = message.offset;
+        if (!Number.isSafeInteger(start) || start < 0 || start > this.offset || typeof message.data !== 'string')
+            throw new ShardfluxProtocolError('PTY output has a byte gap or invalid offset', 0, 'cell');
+        const bytes = Buffer.from(message.data, 'base64');
+        const fresh = bytes.subarray(Math.min(bytes.length, this.offset - start));
+        this.offset += fresh.length;
+        return fresh;
+    }
+}
+/** Detaching closes only this attachment; the workspace PTY and agent keep running. */
+export async function attachTerminal(options) {
+    const { io } = options;
+    const stdin = io.stdin;
+    if (!stdin.isTTY || !stdin.setRawMode || !stdin.on || !stdin.off)
+        throw new UsageError('terminal attach requires a TTY');
+    const controller = new AbortController();
+    const abort = () => controller.abort(options.signal.reason);
+    options.signal.addEventListener('abort', abort, { once: true });
+    if (options.signal.aborted)
+        abort();
+    const signal = controller.signal;
+    const cursor = new PtyOutputCursor();
+    let connection;
+    let acceptingInput = false;
+    let promptAnswer;
+    let promptLine = '';
+    let promptDecoder = new StringDecoder('utf8');
+    let prefix = false;
+    let detached = false;
+    let inputFailure;
+    const pending = [];
+    let pendingBytes = 0;
+    const dimensions = options.dimensions ?? (() => ({ rows: process.stdout.rows || 24, cols: process.stdout.columns || 80 }));
+    const resizeEvents = options.resizeEvents ?? process;
+    const resize = () => {
+        const size = dimensions();
+        connection?.resize(Math.min(1000, Math.max(1, size.rows)), Math.min(1000, Math.max(1, size.cols)));
+    };
+    const send = (bytes) => {
+        if (!bytes.length)
+            return;
+        if (connection && acceptingInput) {
+            try {
+                connection.input(bytes);
+            }
+            catch (error) {
+                if (!retryableAttach(error)) {
+                    inputFailure = error instanceof Error ? error : new Error(String(error));
+                    controller.abort(error);
+                    return;
+                }
+                acceptingInput = false;
+                void connection.close().catch((failure) => { inputFailure = failure instanceof Error ? failure : new Error(String(failure)); controller.abort(failure); });
+            }
+            if (acceptingInput)
+                return;
+        }
+        {
+            pendingBytes += bytes.length;
+            if (pendingBytes > 64 * 1024) {
+                inputFailure = new UsageError('terminal input exceeded the reconnect buffer');
+                controller.abort(inputFailure);
+            }
+            else
+                pending.push(bytes);
+        }
+    };
+    const data = (value) => {
+        const bytes = typeof value === 'string' ? Buffer.from(value) : value;
+        if (promptAnswer) {
+            for (const byte of bytes) {
+                if (byte === 3) {
+                    controller.abort();
+                    return;
+                }
+                if (byte === 13 || byte === 10) {
+                    const answer = promptAnswer;
+                    promptAnswer = undefined;
+                    answer(promptLine + promptDecoder.end());
+                    promptLine = '';
+                    promptDecoder = new StringDecoder('utf8');
+                    return;
+                }
+                if (byte === 127 || byte === 8) {
+                    promptLine = Array.from(promptLine).slice(0, -1).join('');
+                    io.stderr.write('\b \b');
+                }
+                else if (byte >= 32 && promptLine.length < 4096) {
+                    const character = promptDecoder.write(Buffer.from([byte]));
+                    promptLine += character;
+                    io.stderr.write(character);
+                }
+            }
+            return;
+        }
+        if (!prefix && !bytes.includes(29)) {
+            send(bytes);
+            return;
+        }
+        const output = [];
+        for (const byte of bytes) {
+            if (prefix) {
+                prefix = false;
+                if (byte === 100) {
+                    send(Buffer.from(output));
+                    detached = true;
+                    controller.abort();
+                    return;
+                }
+                output.push(29);
+            }
+            if (byte === 29)
+                prefix = true;
+            else
+                output.push(byte);
+        }
+        send(Buffer.from(output));
+    };
+    const end = () => { detached = true; controller.abort(); };
+    const wasRaw = stdin.isRaw ?? false;
+    stdin.setRawMode(true);
+    stdin.on('data', data);
+    stdin.on('end', end);
+    resizeEvents.on('SIGWINCH', resize);
+    stdin.resume?.();
+    const promptTask = options.credentialPrompts?.(message => new Promise((resolve, reject) => {
+        const abort = () => { promptAnswer = undefined; reject(new Error('terminal detached')); };
+        signal.addEventListener('abort', abort, { once: true });
+        promptAnswer = line => { signal.removeEventListener('abort', abort); io.stderr.write('\n'); resolve(line); };
+        io.stderr.write(message);
+    }), signal).catch(error => { if (!signal.aborted) {
+        inputFailure = error instanceof Error ? error : new Error('credential prompt unavailable');
+        controller.abort();
+    } });
+    let reconnects = 0;
+    try {
+        while (!signal.aborted) {
+            try {
+                if (reconnects) {
+                    options.invalidate();
+                    await options.wake(signal);
+                }
+                connection = await options.connect(cursor.offset, signal);
+                acceptingInput = true;
+                resize();
+                while (pending.length) {
+                    connection.input(pending[0]);
+                    pendingBytes -= pending.shift().length;
+                }
+                for await (const message of connection.messages()) {
+                    if (signal.aborted)
+                        break;
+                    const bytes = cursor.consume(message);
+                    if (bytes?.length)
+                        io.stdout.write(bytes);
+                    if (message.type === 'exit') {
+                        if (!message.session)
+                            throw new ShardfluxProtocolError('PTY exit omitted the session', 0, 'cell');
+                        return exitCodePosix({ exitCode: message.session.exit_code ?? null, termSignal: message.session.term_signal ?? null, timedOut: false });
+                    }
+                }
+            }
+            catch (error) {
+                if (signal.aborted)
+                    break;
+                if (!retryableAttach(error))
+                    throw error;
+            }
+            finally {
+                const previous = connection;
+                connection = undefined;
+                acceptingInput = false;
+                await previous?.close();
+            }
+            reconnects += 1;
+            await options.sleep(Math.min(2_000, 100 * 2 ** Math.min(reconnects, 5)), signal);
+        }
+        if (inputFailure)
+            throw inputFailure;
+        return detached ? 0 : 130;
+    }
+    finally {
+        controller.abort();
+        await promptTask;
+        options.signal.removeEventListener('abort', abort);
+        stdin.off('data', data);
+        stdin.off('end', end);
+        resizeEvents.off('SIGWINCH', resize);
+        stdin.setRawMode(wasRaw);
+        stdin.pause?.();
+    }
+}
+export function cellConnector(cell, sessionId) {
+    return (offset, signal) => PtyConnection.attach(cell, sessionId, offset, signal);
+}

package/dist/args.d.ts

@@ -1,4 +1,4 @@
-export declare const CLI_VERSION = "0.11.0";
+export declare const CLI_VERSION = "0.13.0";
 export interface OptionSpec {
     type: 'string' | 'boolean';
     short?: string;
@@ -27,7 +27,8 @@ export interface CommandSpec {
     examples?: string[];
 }
 export declare const GLOBAL_OPTIONS: Record<string, OptionSpec>;
-/** Every command: the account plane first (sign in, set up), then the project-key commands. */
+export declare const PROJECT_COMMAND: CommandSpec;
+export declare const CENTER_COMMAND: CommandSpec;
 export declare const COMMANDS: CommandSpec[];
 export declare function normalizeWords(words: string[]): string[];
 export declare function findCommand(words: string[]): CommandSpec | undefined;
@@ -67,9 +68,12 @@ export type Parsed = {
 };
 /**
  * Parses argv (without node/script). Throws UsageError for anything invalid;
- * returns help text for --help, bare groups and a bare `shard`.
+ * returns help text for --help, bare groups and non-TTY bare `shard`.
  */
-export declare function parseCommandLine(argv: readonly string[]): Parsed;
+export declare function parseCommandLine(argv: readonly string[], options?: {
+    tty?: boolean;
+    isProjectPath?: (path: string) => boolean;
+}): Parsed;
 export declare function usageLine(c: CommandSpec): string;
 export declare function commandHelp(c: CommandSpec): string;
 /** Help of a group (`auth`) or a sub-group (`auth totp`): its commands with their summaries. */