@shardflux/cli 0.11.1 → 0.13.0

package/dist/command-center-model.js

@@ -0,0 +1,90 @@
+import { ShardfluxApiError } from '@shardflux/sdk';
+import { disambiguatedSlug } from "./agent-commands.js";
+import { projectIdentity } from "./project-identity.js";
+import { readSetupProgress } from "./assisted-setup.js";
+/** Older K5 captures used the workspace key as the agent label. K1 needs its leaf name. */
+export const agentName = (key, labels) => (labels.agent || key).split('/').at(-1);
+export const projectName = (key, labels) => labels.shard_project || key.split('/')[0];
+const parked = (workspace) => ['suspended', 'hibernated', 'parked'].includes(workspace?.observed_state ?? '');
+export async function loadCenter(ctx) {
+    const collect = async (path) => {
+        const rows = [], cursors = new Set();
+        let cursor = null;
+        do {
+            const page = await ctx.cloud().request('GET', path, {
+                query: { limit: 200, ...(cursor ? { cursor } : {}) }, signal: ctx.signal,
+            });
+            rows.push(...page.data);
+            cursor = page.next_cursor;
+            if (cursor && cursors.has(cursor))
+                throw new Error(`${path} returned a repeated pagination cursor`);
+            if (cursor)
+                cursors.add(cursor);
+        } while (cursor);
+        return rows;
+    };
+    const [agents, workspaces] = await Promise.all([collect('/v1/agents'), collect('/v1/workspaces')]);
+    let browserProfiles;
+    try {
+        browserProfiles = await ctx.cloud().browserProfiles.list({ signal: ctx.signal });
+    }
+    catch (error) {
+        if (error instanceof ShardfluxApiError && error.status === 404)
+            browserProfiles = [];
+        else
+            throw error;
+    }
+    const setups = {};
+    await Promise.all(workspaces.filter(w => !w.deleted_at && w.labels.shard_setup === 'true').map(async (workspace) => {
+        const progress = await readSetupProgress(ctx, workspace, agents.some(agent => agent.workspace_id === workspace.id && agent.state === 'working'));
+        if (progress)
+            setups[workspace.id] = progress;
+    }));
+    return { agents, workspaces: workspaces.filter(w => !w.deleted_at), browserProfiles, ...(Object.keys(setups).length ? { setups } : {}) };
+}
+export function scopedProject(data, scope) {
+    if (scope.remote) {
+        const match = data.workspaces.find(w => w.labels.repo_remote === scope.remote);
+        if (match)
+            return projectName(match.workspace_key, match.labels);
+        const collision = data.workspaces.some(w => projectName(w.workspace_key, w.labels) === scope.slug && w.labels.repo_remote !== undefined && w.labels.repo_remote !== scope.remote);
+        if (collision)
+            return disambiguatedSlug(scope.slug, scope.remote);
+    }
+    return scope.slug;
+}
+export function centerRows(data, scope, filter = '') {
+    const rows = [];
+    const workspaces = new Map(data.workspaces.map(w => [w.id, w]));
+    const withSessions = new Set();
+    const project = scope ? scopedProject(data, scope) : undefined;
+    for (const agent of data.agents) {
+        const workspace = workspaces.get(agent.workspace_id);
+        if (workspace?.deleted_at)
+            continue;
+        const badge = agent.app === 'claude' && agent.credential_status === 'needs_sign_in' ? 'Claude sign-in needed' : agent.state === 'exited' ? 'done' : parked(workspace) ? 'parked' : agent.state === 'waiting' ? 'needs you' : 'working';
+        rows.push({ id: agent.id, key: agent.workspace_key, project: projectName(agent.workspace_key, agent.labels), agent, workspace, badge,
+            attention: badge === 'Claude sign-in needed' ? -1 : ['needs you', 'working', 'parked', 'done'].indexOf(badge) });
+        withSessions.add(agent.workspace_id);
+    }
+    for (const workspace of data.workspaces) {
+        if (!workspace.labels.shard_project || withSessions.has(workspace.id))
+            continue;
+        rows.push({ id: workspace.id, key: workspace.workspace_key, project: projectName(workspace.workspace_key, workspace.labels), workspace,
+            badge: parked(workspace) ? 'parked' : 'no sessions', attention: parked(workspace) ? 2 : 4 });
+    }
+    if (scope && !rows.some(r => r.project === project))
+        rows.push({ id: `start:${project}`, key: `${project}/main`, project: project, start: true, badge: 'start', attention: 0 });
+    for (const row of rows)
+        row.browserProfiles = data.browserProfiles?.filter(p => p.scope === 'project' || typeof p.scope !== 'string' && p.scope.workspace_id === row.workspace?.id);
+    for (const row of rows)
+        row.setup = row.workspace ? data.setups?.[row.workspace.id] : undefined;
+    const visible = rows.filter(r => (!project || r.project === project) && `${r.project} ${r.key} ${r.agent?.app ?? ''} ${r.agent?.title ?? ''} ${r.badge}`.toLowerCase().includes(filter.toLowerCase()));
+    const ranks = new Map();
+    const agentRanks = new Map();
+    for (const row of visible) {
+        ranks.set(row.project, Math.min(ranks.get(row.project) ?? 99, row.attention));
+        agentRanks.set(row.key, Math.min(agentRanks.get(row.key) ?? 99, row.attention));
+    }
+    return visible.sort((a, b) => ranks.get(a.project) - ranks.get(b.project) || a.project.localeCompare(b.project) || agentRanks.get(a.key) - agentRanks.get(b.key) || a.key.localeCompare(b.key) || a.attention - b.attention || a.id.localeCompare(b.id));
+}

package/dist/command-center-renderer.d.ts

@@ -0,0 +1,25 @@
+import type { CenterRow } from './command-center-model.js';
+/** API titles and local input never get to send terminal controls. */
+export declare function plain(value: string): string;
+export declare function clip(value: string, columns: number): string;
+export interface CenterView {
+    rows: CenterRow[];
+    selected: string | undefined;
+    filter: string;
+    message: string;
+    prompt?: string;
+    menu?: {
+        title: string;
+        items: string[];
+        selected: number;
+    };
+    extraKeys: string[];
+    menubarHint?: string;
+}
+export declare function renderCenter(view: CenterView, columns: number, height: number, color?: boolean): string[];
+/** Cursor-address changed lines only; polling an unchanged view writes nothing. */
+export declare class AnsiRenderer {
+    #private;
+    reset(): void;
+    draw(lines: string[]): string;
+}

package/dist/command-center-renderer.js

@@ -0,0 +1,100 @@
+import { browserSessionNote, workspaceBrowserSessionNote } from "./browser-profile-copy.js";
+import { agentName } from "./command-center-model.js";
+import { setupLine } from "./assisted-setup.js";
+/** API titles and local input never get to send terminal controls. */
+export function plain(value) { return [...value].map(ch => { const code = ch.codePointAt(0); return code < 32 || code >= 127 && code <= 159 ? ' ' : ch; }).join(''); }
+function width(ch) {
+    if (/\p{Mark}/u.test(ch))
+        return 0;
+    const code = ch.codePointAt(0);
+    return code >= 0x1100 && (code <= 0x115f || code >= 0x2e80 && code <= 0xa4cf || code >= 0xac00 && code <= 0xd7a3 || code >= 0xf900 && code <= 0xfaff || code >= 0xfe10 && code <= 0xfe6f || code >= 0xff01 && code <= 0xff60 || code >= 0x1f000) ? 2 : 1;
+}
+export function clip(value, columns) {
+    let result = '', used = 0;
+    for (const ch of plain(value)) {
+        const n = width(ch);
+        if (used + n > columns)
+            break;
+        result += ch;
+        used += n;
+    }
+    return result;
+}
+export function renderCenter(view, columns, height, color = true) {
+    columns = Math.max(1, Math.min(1000, columns));
+    height = Math.max(1, Math.min(1000, height));
+    const lines = ['shardflux  /  Cloud agents', view.filter ? `Filter: ${view.filter}` : 'Projects / agents / sessions  ·  attention first', ''];
+    const body = [];
+    const sites = (profiles) => [...new Set(profiles.flatMap(p => p.sites.map(s => s.site)))].join(', ');
+    // Project-scoped sessions reach every row, so they are named once; workspace-scoped ones sit under their agent.
+    const shared = [...new Map(view.rows.flatMap(r => r.browserProfiles ?? []).filter(p => p.scope === 'project').map(p => [p.name, p])).values()];
+    if (shared.length)
+        body.push({ text: `Browser sessions: ${sites(shared)}` }, { text: browserSessionNote }, { text: '' });
+    let project = '', key = '';
+    for (const row of view.rows) {
+        if (row.project !== project) {
+            project = row.project;
+            key = '';
+            body.push({ text: project });
+            const setup = view.rows.find(candidate => candidate.project === project && candidate.setup)?.setup;
+            const progress = setup && setupLine(project, setup);
+            if (progress)
+                body.push({ text: `  ${progress}` });
+        }
+        if (row.start) {
+            body.push({ text: '  Start Claude here (or Codex)', id: row.id });
+            continue;
+        }
+        if (row.key !== key) {
+            key = row.key;
+            body.push({ text: `  ${agentName(key, row.agent?.labels ?? row.workspace?.labels ?? {})}` });
+            const own = row.browserProfiles?.filter(p => p.scope !== 'project') ?? [];
+            if (own.length)
+                body.push({ text: `    Browser sessions: ${sites(own)}` }, { text: `    ${workspaceBrowserSessionNote}` });
+        }
+        const session = row.agent?.id.slice(row.agent.workspace_id.length + 1);
+        body.push({ text: `    [${row.badge}] ${row.agent ? `${row.agent.app}  ${clip(session, 12)}  ${row.agent.title || 'Untitled session'}` : 'Open a session'}`, id: row.id, badge: row.badge });
+    }
+    if (!body.length)
+        body.push({ text: view.filter ? 'No matching sessions. Press / to change the filter.' : 'No cloud agents. Run shard <path> to start a project.' });
+    const available = Math.max(0, height - 7);
+    const selected = body.findIndex(r => r.id === view.selected);
+    const start = Math.max(0, selected - available + 1);
+    for (const row of body.slice(start, start + available)) {
+        let line = clip(`${row.id === view.selected ? '>' : ' '} ${row.text}`, columns);
+        if (color) {
+            if (row.badge === 'working')
+                line = `\x1b[38;5;208m${line}\x1b[0m`;
+            if (row.badge === 'done')
+                line = `\x1b[2m${line}\x1b[0m`;
+            if (row.id === view.selected)
+                line = `\x1b[7m${line}\x1b[0m`;
+        }
+        lines.push(line);
+    }
+    while (lines.length < height - 4)
+        lines.push('');
+    lines.push(view.prompt ?? view.message, 'Enter open  o open in  n session  N agent  f fork  p park', `l logs  / filter  q quit${view.extraKeys.length ? `  ${view.extraKeys.join('  ')}` : ''}`, view.menubarHint ?? `${view.rows.length} session${view.rows.length === 1 ? '' : 's'}  ·  refresh every 2s`);
+    if (view.menu) {
+        const menu = [view.menu.title, ...view.menu.items.map((item, i) => `${i === view.menu.selected ? '>' : ' '} ${item}`), 'Enter select  Esc cancel'];
+        const offset = Math.min(3, Math.max(0, height - menu.length));
+        for (let i = 0; i < menu.length && offset + i < height; i++)
+            lines[offset + i] = menu[i];
+    }
+    return lines.slice(0, height).map(line => line.includes('\x1b') ? line : clip(line, columns));
+}
+/** Cursor-address changed lines only; polling an unchanged view writes nothing. */
+export class AnsiRenderer {
+    #previous = [];
+    reset() { this.#previous = []; }
+    draw(lines) {
+        let output = '';
+        for (let i = 0; i < Math.max(lines.length, this.#previous.length); i++) {
+            const line = lines[i] ?? '';
+            if (this.#previous[i] !== line)
+                output += `\x1b[${i + 1};1H\x1b[2K${line}`;
+        }
+        this.#previous = [...lines];
+        return output;
+    }
+}

package/dist/command-center.d.ts

@@ -0,0 +1,18 @@
+import type { Handler, Ctx } from './commands.js';
+import type { ProjectScope } from './command-center-model.js';
+interface CenterOptions {
+    app?: 'claude' | 'codex';
+    approvals?: boolean;
+    dimensions?: () => {
+        columns: number;
+        rows: number;
+    };
+    resizeEvents?: {
+        on(event: 'SIGWINCH', listener: () => void): unknown;
+        off(event: 'SIGWINCH', listener: () => void): unknown;
+    };
+    pollMs?: number;
+}
+export declare function showCenter(ctx: Ctx, scope?: ProjectScope, options?: CenterOptions): Promise<number>;
+export declare const commandCenter: Handler;
+export {};

package/dist/command-center.js

@@ -0,0 +1,320 @@
+import { json } from "./format.js";
+import { UsageError } from "./errors.js";
+import { projectIdentity } from "./project-identity.js";
+import { AgentStateStore } from "./agent-state.js";
+import { agentAction, availableTargets } from "./command-center-actions.js";
+import { centerRows, loadCenter } from "./command-center-model.js";
+import { AnsiRenderer, renderCenter } from "./command-center-renderer.js";
+import { CenterKeys } from "./command-center-keys.js";
+import { menubarHint } from "./menubar.js";
+import { MenubarManager } from "./menubar.js";
+import { homedir } from 'node:os';
+import { retrySetupStep } from "./assisted-setup.js";
+export async function showCenter(ctx, scope, options = {}) {
+    const input = ctx.io.stdin;
+    if (!input.isTTY || !input.setRawMode || !input.on || !input.off)
+        throw new UsageError('command center requires a TTY');
+    const { HANDLERS } = await import("./handlers.js");
+    const extra = [['m', 'merge'], ['k', 'keep'], ['d', 'discard']].filter(([, command]) => HANDLERS[`agents ${command}`]);
+    const view = { rows: [], selected: undefined, filter: '', message: 'Loading agents…', extraKeys: extra.map(([key, command]) => `${key} ${command}`) };
+    const hint = await menubarHint(ctx.store.dir, new MenubarManager({ home: ctx.io.env.HOME || homedir(), signal: ctx.signal }));
+    if (hint)
+        view.menubarHint = hint;
+    const renderer = new AnsiRenderer(), keys = new CenterKeys();
+    const dimensions = options.dimensions ?? (() => ({ columns: process.stdout.columns || 80, rows: process.stdout.rows || 24 }));
+    const resizeEvents = options.resizeEvents ?? process;
+    let data = { agents: [], workspaces: [] };
+    let visible = false, finished = false, busy = false;
+    let timer, escapeTimer;
+    let refreshing;
+    let edit;
+    let menuActions = [];
+    let finish;
+    const done = new Promise(resolve => { finish = resolve; });
+    const wasRaw = input.isRaw ?? false;
+    const draw = () => {
+        if (!visible || finished)
+            return;
+        const size = dimensions();
+        ctx.io.stdout.write(renderer.draw(renderCenter(view, size.columns, size.rows, ctx.io.env.NO_COLOR === undefined && ctx.io.env.TERM !== 'dumb')));
+    };
+    const updateRows = () => {
+        view.rows = centerRows(data, scope, view.filter);
+        if (!view.rows.some(r => r.id === view.selected))
+            view.selected = view.rows[0]?.id;
+    };
+    const close = () => { finished = true; clearTimeout(timer); refreshing?.abort(); finish(); };
+    const hide = () => {
+        visible = false;
+        clearTimeout(timer);
+        clearTimeout(escapeTimer);
+        refreshing?.abort();
+        input.off('data', onData);
+        input.off('end', close);
+        input.pause?.();
+        input.setRawMode(wasRaw);
+        ctx.io.stdout.write('\x1b[?25h\x1b[?1049l');
+    };
+    const refresh = async () => {
+        if (!visible || finished)
+            return;
+        const controller = new AbortController();
+        refreshing = controller;
+        try {
+            const loaded = await loadCenter({ ...ctx, signal: AbortSignal.any([ctx.signal, controller.signal]) });
+            if (!visible || controller.signal.aborted)
+                return;
+            data = loaded;
+            updateRows();
+            if (view.message === 'Loading agents…' || view.message.startsWith('Refresh failed:'))
+                view.message = '';
+        }
+        catch (error) {
+            if (!controller.signal.aborted && !ctx.signal.aborted)
+                view.message = `Refresh failed: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        finally {
+            if (refreshing === controller) {
+                refreshing = undefined;
+                draw();
+                if (visible && !finished)
+                    timer = setTimeout(() => { void refresh(); }, options.pollMs ?? 2000);
+            }
+        }
+    };
+    const show = () => {
+        visible = true;
+        renderer.reset();
+        ctx.io.stdout.write('\x1b[?1049h\x1b[?25l');
+        input.setRawMode(true);
+        input.on('data', onData);
+        input.on('end', close);
+        input.resume?.();
+        draw();
+        void refresh();
+    };
+    const dispatch = async (action, values, args, attach = false) => {
+        if (busy || finished)
+            return;
+        busy = true;
+        view.menu = undefined;
+        view.prompt = undefined;
+        edit = undefined;
+        hide();
+        try {
+            const output = [];
+            const actionCtx = attach ? ctx : { ...ctx, json: true, io: { ...ctx.io, stdout: { write: (chunk) => { output.push(Buffer.from(chunk).toString()); return true; } } } };
+            const code = await agentAction(actionCtx, action, { approvals: options.approvals ?? false, ...values }, args);
+            view.message = code === 0 ? `${action} finished` : `${action} returned ${code}`;
+        }
+        catch (error) {
+            view.message = error instanceof Error ? error.message : String(error);
+        }
+        finally {
+            busy = false;
+            if (!finished && !ctx.signal.aborted)
+                show();
+        }
+    };
+    const menu = (title, choices) => {
+        view.menu = { title, items: choices.map(c => c.label), selected: 0 };
+        menuActions = choices.map(c => c.run);
+        draw();
+    };
+    const logs = async (key, app) => {
+        busy = true;
+        hide();
+        const controller = new AbortController();
+        const stop = (chunk) => { if (Buffer.from(chunk).some(byte => [3, 4, 27, 113].includes(byte)))
+            controller.abort(); };
+        ctx.io.stdout.write('Log tail · q or Esc returns to agents\r\n');
+        input.setRawMode(true);
+        input.on('data', stop);
+        input.resume?.();
+        try {
+            await agentAction({ ...ctx, signal: AbortSignal.any([ctx.signal, controller.signal]) }, 'logs', { app, follow: true }, [key]);
+        }
+        catch (error) {
+            if (!controller.signal.aborted)
+                view.message = error instanceof Error ? error.message : String(error);
+        }
+        finally {
+            input.off('data', stop);
+            input.pause?.();
+            input.setRawMode(wasRaw);
+            busy = false;
+            if (!finished && !ctx.signal.aborted)
+                show();
+        }
+    };
+    const handle = async (key) => {
+        if (busy || finished)
+            return;
+        if (key === 'quit') {
+            close();
+            return;
+        }
+        if (edit) {
+            if (key === 'escape') {
+                if (edit.kind === 'filter') {
+                    view.filter = edit.previous ?? '';
+                    updateRows();
+                }
+                edit = undefined;
+                view.prompt = undefined;
+            }
+            else if (key === 'enter') {
+                const current = edit;
+                edit = undefined;
+                view.prompt = undefined;
+                if (current.kind !== 'filter') {
+                    const row = view.rows.find(r => r.id === view.selected);
+                    if (!row)
+                        return;
+                    if (!/^[a-z0-9][a-z0-9._-]{0,63}$/.test(current.text)) {
+                        view.message = 'Use a name with lowercase letters, digits, dots, dashes or underscores.';
+                        draw();
+                        return;
+                    }
+                    if (current.kind === 'fork')
+                        await dispatch('fork', {}, [row.key, current.text]);
+                    else {
+                        const main = data.workspaces.find(w => w.workspace_key === `${row.project}/main`);
+                        if (!main) {
+                            view.message = 'This project has no main workspace to copy.';
+                            draw();
+                            return;
+                        }
+                        await dispatch('new', { name: current.text, like: main.id, ...(scope ? { path: scope.folder } : {}) }, [main.workspace_key], true);
+                    }
+                }
+            }
+            else if (key === 'backspace')
+                edit.text = [...edit.text].slice(0, -1).join('');
+            else if ([...key].length === 1 && key >= ' ' && edit.text.length < (edit.kind === 'filter' ? 256 : 64))
+                edit.text += key;
+            if (edit) {
+                if (edit.kind === 'filter') {
+                    view.filter = edit.text;
+                    updateRows();
+                }
+                view.prompt = `${edit.kind === 'filter' ? 'Filter' : 'New agent name'}: ${edit.text}  (Enter accepts, Esc cancels)`;
+            }
+            draw();
+            return;
+        }
+        if (view.menu) {
+            if (key === 'escape' || key === 'q')
+                view.menu = undefined;
+            else if (key === 'up' || key === 'down')
+                view.menu.selected = (view.menu.selected + (key === 'up' ? -1 : 1) + view.menu.items.length) % view.menu.items.length;
+            else if (key === 'enter') {
+                const run = menuActions[view.menu.selected];
+                view.menu = undefined;
+                await run?.();
+            }
+            draw();
+            return;
+        }
+        if (key === 'q') {
+            close();
+            return;
+        }
+        if (key === 'up' || key === 'down' || key === 'j') {
+            const index = view.rows.findIndex(r => r.id === view.selected);
+            view.selected = view.rows[Math.max(0, Math.min(view.rows.length - 1, index + (key === 'up' ? -1 : 1)))]?.id;
+            draw();
+            return;
+        }
+        if (key === '/') {
+            edit = { kind: 'filter', text: view.filter, previous: view.filter };
+            view.prompt = `Filter: ${view.filter}`;
+            draw();
+            return;
+        }
+        const row = view.rows.find(r => r.id === view.selected);
+        if (!row)
+            return;
+        if (key === 'r' && row.setup && row.workspace) {
+            const step = row.setup.tasks.find(task => task.state === 'failed' && task.error?.retryable);
+            if (step) {
+                busy = true;
+                try {
+                    await retrySetupStep(ctx, row.workspace, step.name);
+                    view.message = `Retrying ${step.name}`;
+                }
+                catch (error) {
+                    view.message = error instanceof Error ? error.message : String(error);
+                }
+                finally {
+                    busy = false;
+                    draw();
+                }
+            }
+            return;
+        }
+        const project = scope ? scope.remote ?? scope.folder : row.workspace?.labels.repo_remote || row.project;
+        const app = row.agent?.app || options.app || new AgentStateStore(ctx.store.dir).app(project, row.workspace?.labels.app === 'codex' ? 'codex' : 'claude');
+        if (row.start && ['enter', 'n', 'N'].includes(key)) {
+            menu('Start here', [app, app === 'claude' ? 'codex' : 'claude'].map(app => ({ label: `Start ${app === 'claude' ? 'Claude' : 'Codex'} here`, run: () => dispatch('new', { path: scope.folder, app }, [], true) })));
+            return;
+        }
+        if (key === 'enter')
+            await dispatch('open', { app, project, in: 'terminal' }, [row.key], true);
+        else if (key === 'o') {
+            const targets = await availableTargets(ctx);
+            menu('Open in…', targets.map(target => ({ label: target, run: () => dispatch('open', { app, project, in: target }, [row.key], true) })));
+        }
+        else if (key === 'n') {
+            menu('New session', ['claude', 'codex'].map(app => ({ label: `${app === 'claude' ? 'Claude' : 'Codex'} (reattach if running)`, run: () => dispatch('new', { app, project }, [row.key], true) })));
+        }
+        else if (key === 'N' || key === 'f') {
+            edit = { kind: key === 'N' ? 'new' : 'fork', text: '' };
+            view.prompt = 'New agent name: ';
+        }
+        else if (key === 'p')
+            await dispatch('park', {}, [row.key]);
+        else if (key === 'l') {
+            await logs(row.key, app);
+        }
+        else {
+            const command = extra.find(([letter]) => letter === key)?.[1];
+            if (command)
+                await dispatch(command, {}, [row.key]);
+        }
+        draw();
+    };
+    function onData(chunk) {
+        clearTimeout(escapeTimer);
+        for (const key of keys.feed(chunk))
+            void handle(key).catch(error => { view.message = String(error); draw(); });
+        escapeTimer = setTimeout(() => { for (const key of keys.escape())
+            void handle(key); }, 35);
+    }
+    const resize = () => { renderer.reset(); draw(); };
+    ctx.signal.addEventListener('abort', close, { once: true });
+    resizeEvents.on('SIGWINCH', resize);
+    try {
+        if (ctx.signal.aborted)
+            return 130;
+        show();
+        await done;
+        return ctx.signal.aborted ? 130 : 0;
+    }
+    finally {
+        hide();
+        resizeEvents.off('SIGWINCH', resize);
+        ctx.signal.removeEventListener('abort', close);
+    }
+}
+export const commandCenter = async (ctx, values, [path, app]) => {
+    const scope = path ? projectIdentity(path) : undefined;
+    if (ctx.json) {
+        const data = await loadCenter(ctx);
+        const rows = centerRows(data, scope);
+        const projects = [...new Set(rows.map(row => row.project))];
+        ctx.io.stdout.write(json({ projects, workspaces: data.workspaces.filter(w => rows.some(r => r.workspace?.id === w.id)), agents: data.agents.filter(a => rows.some(r => r.agent?.id === a.id)) }));
+        return 0;
+    }
+    return showCenter(ctx, scope, { approvals: values.approvals === true, ...(app === 'claude' || app === 'codex' ? { app } : {}) });
+};

package/dist/commands.d.ts

@@ -1,10 +1,11 @@
-import type { AccountClientOptions, RunResult, Shardflux, ShardfluxAccount, Workspace } from '@shardflux/sdk';
+import type { AccountClientOptions, Caps, RunResult, Shardflux, ShardfluxAccount, Workspace } from '@shardflux/sdk';
 import type { Values } from './args.js';
 import type { CredentialStore, StoredApiKey, StoredSession } from './credentials.js';
 import type { Input, StdinLike } from './input.js';
 import type { Distribution, UpdateView } from './update-check.js';
 import type { TimingRecorder } from './timing.js';
 export interface Writer {
+    isTTY?: boolean;
     write(chunk: string | Uint8Array): boolean;
 }
 export interface Io {
@@ -70,6 +71,12 @@ export type Handler = (ctx: Ctx, values: Values, positionals: string[]) => Promi
 export declare const str: (v: Values[string]) => string | undefined;
 export declare const strs: (v: Values[string]) => string[];
 export declare function out(ctx: Ctx, human: string, machine: unknown): void;
+export declare function openVolumes(values: readonly string[]): import('@shardflux/sdk').OpenVolumes | undefined;
+/**
+ * The caps of `workspaces open` and `workspaces fork` (0.8.0): the resource caps plus the memory allocation. Given caps
+ * replace the stored ones, so they are sent only when a flag was given.
+ */
+export declare function workspaceCaps(values: Values): Caps | undefined;
 /** `--when-idle <duration>`: whole seconds from 0 (as soon as it is idle; 0.6.1) to 3600 (the API's after_seconds bounds). */
 export declare function whenIdleSeconds(text: string): number;
 export declare function waitTimeout(values: Values): number;
@@ -116,5 +123,4 @@ export declare function ttlSeconds(values: Values, b: {
     max: number;
     range: string;
 }): number | undefined;
-/** The project-key commands; handlers.ts adds the account plane's. */
 export declare const KEY_HANDLERS: Record<string, Handler>;