@camerontaylor/paseo-cli 0.8.0-fork.1

package/dist/commands/script/shared.js

@@ -0,0 +1,59 @@
+import { resolve } from "node:path";
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+export async function connectWorkspaceScriptClient(host) {
+    const daemonHost = getDaemonHost({ host });
+    try {
+        const client = await connectToDaemon({ host });
+        // COMPAT(workspaceScriptManagement): added in v0.1.105, remove gate after 2027-01-10.
+        if (!client.getLastServerInfoMessage()?.features?.workspaceScriptManagement) {
+            await client.close().catch(() => { });
+            throw {
+                code: "DAEMON_UPDATE_REQUIRED",
+                message: "Update the host to use workspace script management.",
+            };
+        }
+        return client;
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && "message" in error) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${daemonHost}: ${message}`,
+            details: "Start the daemon with: paseo daemon start",
+        };
+    }
+}
+export async function resolveWorkspaceScriptWorkspaceId(client, options) {
+    if (options.workspace) {
+        return options.workspace;
+    }
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const payload = await client.fetchWorkspaces({ page: { limit: 200 } });
+    const matches = payload.entries.filter((workspace) => resolve(workspace.workspaceDirectory) === cwd);
+    if (matches.length === 1) {
+        return matches[0].id;
+    }
+    if (matches.length > 1) {
+        throw {
+            code: "WORKSPACE_AMBIGUOUS",
+            message: `Multiple workspaces use ${cwd}`,
+            details: "Pass --workspace <workspace-id> to select one.",
+        };
+    }
+    throw {
+        code: "WORKSPACE_NOT_FOUND",
+        message: `No Paseo workspace found for ${cwd}`,
+        details: "Open the directory in Paseo first, or pass --workspace <workspace-id>.",
+    };
+}
+export function toWorkspaceScriptCommandError(code, action, error) {
+    if (error && typeof error === "object" && "code" in error && "message" in error) {
+        return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return { code, message: `Failed to ${action}: ${message}` };
+}
+//# sourceMappingURL=shared.js.map

package/dist/commands/script/start.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type WorkspaceScriptCommandOptions } from "./shared.js";
+import { type WorkspaceScriptRow } from "./schema.js";
+export declare function runStartCommand(scriptName: string, options: WorkspaceScriptCommandOptions, _command: Command): Promise<SingleResult<WorkspaceScriptRow>>;
+//# sourceMappingURL=start.d.ts.map

package/dist/commands/script/start.js

@@ -0,0 +1,23 @@
+import { connectWorkspaceScriptClient, resolveWorkspaceScriptWorkspaceId, toWorkspaceScriptCommandError, } from "./shared.js";
+import { workspaceScriptSchema } from "./schema.js";
+export async function runStartCommand(scriptName, options, _command) {
+    const client = await connectWorkspaceScriptClient(options.host);
+    try {
+        const workspaceId = await resolveWorkspaceScriptWorkspaceId(client, options);
+        const payload = await client.startWorkspaceScriptWithStatus(workspaceId, scriptName);
+        if (payload.error || !payload.script) {
+            throw {
+                code: "WORKSPACE_SCRIPT_START_FAILED",
+                message: payload.error ?? `Script '${scriptName}' did not return status metadata`,
+            };
+        }
+        return { type: "single", data: payload.script, schema: workspaceScriptSchema };
+    }
+    catch (error) {
+        throw toWorkspaceScriptCommandError("WORKSPACE_SCRIPT_START_FAILED", "start workspace script", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=start.js.map

package/dist/commands/script/stop.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type WorkspaceScriptCommandOptions } from "./shared.js";
+import { type WorkspaceScriptRow } from "./schema.js";
+export declare function runStopCommand(scriptName: string, options: WorkspaceScriptCommandOptions, _command: Command): Promise<SingleResult<WorkspaceScriptRow>>;
+//# sourceMappingURL=stop.d.ts.map

package/dist/commands/script/stop.js

@@ -0,0 +1,23 @@
+import { connectWorkspaceScriptClient, resolveWorkspaceScriptWorkspaceId, toWorkspaceScriptCommandError, } from "./shared.js";
+import { workspaceScriptSchema } from "./schema.js";
+export async function runStopCommand(scriptName, options, _command) {
+    const client = await connectWorkspaceScriptClient(options.host);
+    try {
+        const workspaceId = await resolveWorkspaceScriptWorkspaceId(client, options);
+        const payload = await client.stopWorkspaceScript(workspaceId, scriptName);
+        if (payload.error || !payload.script) {
+            throw {
+                code: "WORKSPACE_SCRIPT_STOP_FAILED",
+                message: payload.error ?? `Script '${scriptName}' did not return status metadata`,
+            };
+        }
+        return { type: "single", data: payload.script, schema: workspaceScriptSchema };
+    }
+    catch (error) {
+        throw toWorkspaceScriptCommandError("WORKSPACE_SCRIPT_STOP_FAILED", "stop workspace script", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=stop.js.map

package/dist/commands/speech/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createSpeechCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/speech/index.js

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+export function createSpeechCommand() {
+    return new Command("speech").description("Speech commands");
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/terminal/capture.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from "commander";
+import { type TerminalCommandOptions } from "./shared.js";
+export interface TerminalCaptureOptions extends TerminalCommandOptions {
+    start?: string;
+    end?: string;
+    scrollback?: boolean;
+    ansi?: boolean;
+}
+export declare function runCaptureCommand(terminalId: string, _options: TerminalCaptureOptions, command: Command): Promise<void>;
+//# sourceMappingURL=capture.d.ts.map

package/dist/commands/terminal/capture.js

@@ -0,0 +1,68 @@
+import { renderError, toCommandError } from "../../output/render.js";
+import { connectTerminalClient, resolveTerminalId, toTerminalCommandError, } from "./shared.js";
+export async function runCaptureCommand(terminalId, _options, command) {
+    const options = command.optsWithGlobals();
+    try {
+        const payload = await executeCaptureCommand(terminalId, options);
+        if (options.json) {
+            process.stdout.write(JSON.stringify({
+                terminalId: payload.terminalId,
+                lines: payload.lines,
+                totalLines: payload.totalLines,
+            }, null, 2) + "\n");
+            return;
+        }
+        if (payload.lines.length > 0) {
+            process.stdout.write(payload.lines.join("\n") + "\n");
+        }
+    }
+    catch (err) {
+        const output = renderError(toCommandError(err), {
+            format: options.json ? "json" : "table",
+            noColor: options.color === false,
+        });
+        process.stderr.write(output + "\n");
+        process.exit(1);
+    }
+}
+async function executeCaptureCommand(terminalId, options) {
+    const { client, close } = await connectTerminalClient(options.host);
+    try {
+        const resolvedId = await resolveTerminalId(client, terminalId);
+        if (!resolvedId) {
+            throw {
+                code: "TERMINAL_NOT_FOUND",
+                message: `No terminal found matching: ${terminalId}`,
+                details: "Use `paseo terminal ls --all` to list available terminals.",
+            };
+        }
+        const start = options.scrollback ? 0 : parseLineNumber("--start", options.start);
+        const end = parseLineNumber("--end", options.end);
+        return await client.terminals.ref(resolvedId).capture({
+            ...(start === undefined ? {} : { start }),
+            ...(end === undefined ? {} : { end }),
+            stripAnsi: !options.ansi,
+        });
+    }
+    catch (err) {
+        throw toTerminalCommandError("TERMINAL_CAPTURE_FAILED", "capture terminal output", err);
+    }
+    finally {
+        await close().catch(() => { });
+    }
+}
+function parseLineNumber(flag, value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed)) {
+        throw {
+            code: "INVALID_LINE_NUMBER",
+            message: `Invalid ${flag} value: ${value}`,
+            details: "Use an integer line number.",
+        };
+    }
+    return parsed;
+}
+//# sourceMappingURL=capture.js.map

package/dist/commands/terminal/create.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type TerminalCommandOptions } from "./shared.js";
+import { type TerminalRow } from "./schema.js";
+export interface TerminalCreateOptions extends TerminalCommandOptions {
+    workspace?: string;
+    cwd?: string;
+    name?: string;
+}
+export declare function runCreateCommand(options: TerminalCreateOptions, _command: Command): Promise<SingleResult<TerminalRow>>;
+//# sourceMappingURL=create.d.ts.map

package/dist/commands/terminal/create.js

@@ -0,0 +1,29 @@
+import { connectTerminalClient, toTerminalCommandError, } from "./shared.js";
+import { terminalSchema } from "./schema.js";
+export async function runCreateCommand(options, _command) {
+    const { client, close } = await connectTerminalClient(options.host);
+    try {
+        const cwd = options.cwd ?? (options.workspace ? undefined : process.cwd());
+        const workspaceId = options.workspace ?? (await client.workspaces.open(options.cwd ?? process.cwd())).id;
+        const terminal = await client.terminals.create({
+            workspaceId,
+            cwd,
+            name: options.name,
+        });
+        const snapshot = terminal.current();
+        if (!snapshot)
+            throw new Error("The daemon did not create a terminal");
+        return {
+            type: "single",
+            data: snapshot,
+            schema: terminalSchema,
+        };
+    }
+    catch (err) {
+        throw toTerminalCommandError("TERMINAL_CREATE_FAILED", "create terminal", err);
+    }
+    finally {
+        await close().catch(() => { });
+    }
+}
+//# sourceMappingURL=create.js.map

package/dist/commands/terminal/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createTerminalCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/terminal/index.js

@@ -0,0 +1,45 @@
+import { Command, Option } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addDaemonHostOption, addJsonAndDaemonHostOptions, withGlobalOptions, } from "../../utils/command-options.js";
+import { runCaptureCommand } from "./capture.js";
+import { runCreateCommand } from "./create.js";
+import { runKillCommand } from "./kill.js";
+import { runLsCommand } from "./ls.js";
+import { runSendKeysCommand } from "./send-keys.js";
+export function createTerminalCommand() {
+    const terminal = new Command("terminal").description("Manage workspace terminals");
+    addJsonAndDaemonHostOptions(terminal
+        .command("ls")
+        .description("List terminals")
+        .addOption(new Option("--all", "List terminals across all workspaces").conflicts(["cwd", "workspace"]))
+        .option("--workspace <id>", "Workspace ID")
+        .option("--cwd <path>", "Working directory")).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(terminal
+        .command("create")
+        .description("Create a terminal")
+        .option("--workspace <id>", "Workspace ID")
+        .option("--cwd <path>", "Working directory")
+        .option("--name <name>", "Terminal name")).action(withOutput(runCreateCommand));
+    addJsonAndDaemonHostOptions(terminal
+        .command("kill")
+        .description("Kill a terminal")
+        .argument("<terminal-id>", "Terminal ID, ID prefix, or name")).action(withOutput(runKillCommand));
+    addDaemonHostOption(terminal
+        .command("capture")
+        .description("Capture terminal output")
+        .argument("<terminal-id>", "Terminal ID, ID prefix, or name")
+        .option("--start <n>", "Capture start line")
+        .option("--end <n>", "Capture end line")
+        .option("-S, --scrollback", "Capture from the beginning of scrollback")
+        .option("--ansi", "Preserve ANSI escape codes")
+        .option("--json", "Output in JSON format")).action(withGlobalOptions(runCaptureCommand));
+    addDaemonHostOption(terminal
+        .command("send-keys")
+        .description("Send keys to a terminal")
+        .argument("<terminal-id>", "Terminal ID, ID prefix, or name")
+        .argument("<keys...>", "Keys to send")
+        .option("-l, --literal", "Send raw keys without interpreting special tokens")
+        .option("--json", "Output in JSON format")).action(withGlobalOptions(runSendKeysCommand));
+    return terminal;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/terminal/kill.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type TerminalCommandOptions } from "./shared.js";
+import { type TerminalKillRow } from "./schema.js";
+export declare function runKillCommand(terminalId: string, options: TerminalCommandOptions, _command: Command): Promise<SingleResult<TerminalKillRow>>;
+//# sourceMappingURL=kill.d.ts.map

package/dist/commands/terminal/kill.js

@@ -0,0 +1,36 @@
+import { connectTerminalClient, resolveTerminalId, toTerminalCommandError, } from "./shared.js";
+import { terminalKillSchema } from "./schema.js";
+export async function runKillCommand(terminalId, options, _command) {
+    const { client, close } = await connectTerminalClient(options.host);
+    try {
+        const resolvedId = await requireTerminalId(client, terminalId);
+        await client.terminals.ref(resolvedId).kill();
+        return {
+            type: "single",
+            data: {
+                terminalId: resolvedId,
+                success: true,
+            },
+            schema: terminalKillSchema,
+        };
+    }
+    catch (err) {
+        throw toTerminalCommandError("TERMINAL_KILL_FAILED", "kill terminal", err);
+    }
+    finally {
+        await close().catch(() => { });
+    }
+}
+async function requireTerminalId(client, terminalId) {
+    const resolvedId = await resolveTerminalId(client, terminalId);
+    if (resolvedId) {
+        return resolvedId;
+    }
+    const error = {
+        code: "TERMINAL_NOT_FOUND",
+        message: `No terminal found matching: ${terminalId}`,
+        details: "Use `paseo terminal ls --all` to list available terminals.",
+    };
+    throw error;
+}
+//# sourceMappingURL=kill.js.map

package/dist/commands/terminal/ls.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from "commander";
+import type { ListResult } from "../../output/index.js";
+import { type TerminalCommandOptions } from "./shared.js";
+import { type TerminalRow } from "./schema.js";
+export interface TerminalLsOptions extends TerminalCommandOptions {
+    workspace?: string;
+    all?: boolean;
+    cwd?: string;
+}
+export declare function runLsCommand(options: TerminalLsOptions, _command: Command): Promise<ListResult<TerminalRow>>;
+//# sourceMappingURL=ls.d.ts.map

package/dist/commands/terminal/ls.js

@@ -0,0 +1,21 @@
+import { connectTerminalClient, toTerminalCommandError, } from "./shared.js";
+import { terminalSchema } from "./schema.js";
+export async function runLsCommand(options, _command) {
+    const { client, close } = await connectTerminalClient(options.host);
+    const cwd = options.all || options.workspace ? undefined : (options.cwd ?? process.cwd());
+    try {
+        const payload = await client.terminals.list({ cwd, workspaceId: options.workspace });
+        return {
+            type: "list",
+            data: payload.entries,
+            schema: terminalSchema,
+        };
+    }
+    catch (err) {
+        throw toTerminalCommandError("TERMINAL_LIST_FAILED", "list terminals", err);
+    }
+    finally {
+        await close().catch(() => { });
+    }
+}
+//# sourceMappingURL=ls.js.map

package/dist/commands/terminal/schema.d.ts

@@ -0,0 +1,10 @@
+import type { PaseoTerminal } from "@camerontaylor/paseo-client";
+import type { OutputSchema } from "../../output/index.js";
+export type TerminalRow = PaseoTerminal;
+export interface TerminalKillRow {
+    terminalId: string;
+    success: boolean;
+}
+export declare const terminalSchema: OutputSchema<TerminalRow>;
+export declare const terminalKillSchema: OutputSchema<TerminalKillRow>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/commands/terminal/schema.js

@@ -0,0 +1,17 @@
+export const terminalSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: (row) => row.id.slice(0, 8), width: 8 },
+        { header: "NAME", field: "name", width: 24 },
+        { header: "CWD", field: "cwd", width: 48 },
+        { header: "WORKSPACE", field: "workspaceId", width: 24 },
+    ],
+};
+export const terminalKillSchema = {
+    idField: "terminalId",
+    columns: [
+        { header: "ID", field: (row) => row.terminalId.slice(0, 8), width: 8 },
+        { header: "SUCCESS", field: "success", width: 8 },
+    ],
+};
+//# sourceMappingURL=schema.js.map

package/dist/commands/terminal/send-keys.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from "commander";
+import { type TerminalCommandOptions } from "./shared.js";
+export interface TerminalSendKeysOptions extends TerminalCommandOptions {
+    literal?: boolean;
+}
+export declare function runSendKeysCommand(terminalId: string, keys: string[], _options: TerminalSendKeysOptions, command: Command): Promise<void>;
+//# sourceMappingURL=send-keys.d.ts.map

package/dist/commands/terminal/send-keys.js

@@ -0,0 +1,45 @@
+import { renderError, toCommandError } from "../../output/render.js";
+import { connectTerminalClient, resolveTerminalId, toTerminalCommandError, } from "./shared.js";
+export async function runSendKeysCommand(terminalId, keys, _options, command) {
+    const options = command.optsWithGlobals();
+    try {
+        const payload = await executeSendKeysCommand(terminalId, keys, options);
+        if (options.json) {
+            process.stdout.write(JSON.stringify(payload, null, 2) + "\n");
+        }
+    }
+    catch (err) {
+        const output = renderError(toCommandError(err), {
+            format: options.json ? "json" : "table",
+            noColor: options.color === false,
+        });
+        process.stderr.write(output + "\n");
+        process.exit(1);
+    }
+}
+async function executeSendKeysCommand(terminalId, keys, options) {
+    const { client, close } = await connectTerminalClient(options.host);
+    try {
+        const resolvedId = await resolveTerminalId(client, terminalId);
+        if (!resolvedId) {
+            throw {
+                code: "TERMINAL_NOT_FOUND",
+                message: `No terminal found matching: ${terminalId}`,
+                details: "Use `paseo terminal ls --all` to list available terminals.",
+            };
+        }
+        const terminal = client.terminals.ref(resolvedId);
+        const keysSent = options.literal ? terminal.write(keys.join("")) : terminal.sendKeys(keys);
+        return {
+            terminalId: resolvedId,
+            keysSent,
+        };
+    }
+    catch (err) {
+        throw toTerminalCommandError("TERMINAL_SEND_KEYS_FAILED", "send terminal keys", err);
+    }
+    finally {
+        await close().catch(() => { });
+    }
+}
+//# sourceMappingURL=send-keys.js.map

package/dist/commands/terminal/shared.d.ts

@@ -0,0 +1,12 @@
+import type { CommandError, CommandOptions } from "../../output/index.js";
+export interface TerminalCommandOptions extends CommandOptions {
+    host?: string;
+}
+export declare function connectTerminalClient(host?: string): Promise<{
+    client: import("@camerontaylor/paseo-client").PaseoApi;
+    daemonHost: string;
+    close: () => Promise<void>;
+}>;
+export declare function toTerminalCommandError(code: string, action: string, err: unknown): CommandError;
+export declare function resolveTerminalId(client: Awaited<ReturnType<typeof connectTerminalClient>>["client"], idOrName: string): Promise<string | null>;
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/terminal/shared.js

@@ -0,0 +1,62 @@
+import { createPaseoApi } from "@camerontaylor/paseo-client";
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+export async function connectTerminalClient(host) {
+    const daemonHost = getDaemonHost({ host });
+    try {
+        const client = await connectToDaemon({ host });
+        return { client: createPaseoApi(client), daemonHost, close: () => client.close() };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${daemonHost}: ${message}`,
+            details: "Start the daemon with: paseo daemon start",
+        };
+        throw error;
+    }
+}
+export function toTerminalCommandError(code, action, err) {
+    if (err && typeof err === "object" && "code" in err && "message" in err) {
+        return err;
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    const rpcCode = typeof err === "object" && err !== null && "code" in err && typeof err.code === "string"
+        ? err.code
+        : undefined;
+    return {
+        code: rpcCode ?? code,
+        message: `Failed to ${action}: ${message}`,
+    };
+}
+export async function resolveTerminalId(client, idOrName) {
+    const payload = await client.terminals.list();
+    return resolveTerminalIdentifier(idOrName, payload.entries);
+}
+function resolveTerminalIdentifier(idOrName, terminals) {
+    if (!idOrName || terminals.length === 0) {
+        return null;
+    }
+    const query = idOrName.toLowerCase();
+    const exactMatch = terminals.find((terminal) => terminal.id === idOrName);
+    if (exactMatch) {
+        return exactMatch.id;
+    }
+    const prefixMatches = terminals.filter((terminal) => terminal.id.toLowerCase().startsWith(query));
+    if (prefixMatches.length === 1 && prefixMatches[0]) {
+        return prefixMatches[0].id;
+    }
+    if (prefixMatches.length > 1) {
+        return null;
+    }
+    const nameMatches = terminals.filter((terminal) => terminal.name?.toLowerCase() === query);
+    if (nameMatches.length === 1 && nameMatches[0]) {
+        return nameMatches[0].id;
+    }
+    const partialNameMatches = terminals.filter((terminal) => terminal.name?.toLowerCase().includes(query));
+    if (partialNameMatches.length === 1 && partialNameMatches[0]) {
+        return partialNameMatches[0].id;
+    }
+    return null;
+}
+//# sourceMappingURL=shared.js.map

package/dist/commands/workspace/archive.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+interface WorkspaceArchiveResult {
+    workspaceId: string;
+    status: "archived";
+    archivedAt: string;
+}
+export declare function runArchiveCommand(workspaceId: string, options: {
+    host?: string;
+}, _command: Command): Promise<SingleResult<WorkspaceArchiveResult>>;
+export {};
+//# sourceMappingURL=archive.d.ts.map

package/dist/commands/workspace/archive.js

@@ -0,0 +1,41 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+const workspaceArchiveSchema = {
+    idField: "workspaceId",
+    columns: [
+        { header: "WORKSPACE ID", field: "workspaceId", width: 20 },
+        { header: "STATUS", field: "status", width: 10 },
+        { header: "ARCHIVED AT", field: "archivedAt", width: 26 },
+    ],
+};
+export async function runArchiveCommand(workspaceId, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+        };
+    });
+    try {
+        const payload = await client.archiveWorkspace(workspaceId);
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        if (!payload.archivedAt) {
+            throw new Error("Workspace archive did not return an archive timestamp");
+        }
+        return {
+            type: "single",
+            data: { workspaceId, status: "archived", archivedAt: payload.archivedAt },
+            schema: workspaceArchiveSchema,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw { code: "WORKSPACE_ARCHIVE_FAILED", message };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=archive.js.map

package/dist/commands/workspace/create.d.ts

@@ -0,0 +1,49 @@
+import type { Command } from "commander";
+import type { CommandOptions, SingleResult } from "../../output/index.js";
+import { type WorkspaceRow } from "./shared.js";
+export interface WorkspaceCreateOptions extends CommandOptions {
+    isolation?: string;
+    path?: string;
+    project?: string;
+    title?: string;
+    mode?: string;
+    worktreeSlug?: string;
+    newBranch?: string;
+    base?: string;
+    branch?: string;
+    prNumber?: string;
+    forge?: string;
+}
+export declare function buildWorkspaceSource(options: WorkspaceCreateOptions): {
+    projectId?: string | undefined;
+    kind: "directory";
+    path: string;
+} | {
+    baseBranch?: string | undefined;
+    branchName?: string | undefined;
+    action: "branch-off";
+    kind: "worktree";
+    cwd?: string;
+    projectId?: string;
+    worktreeSlug?: string;
+} | {
+    action: "checkout";
+    refName: string;
+    kind: "worktree";
+    cwd?: string;
+    projectId?: string;
+    worktreeSlug?: string;
+} | {
+    action: "checkout";
+    checkoutSource: {
+        number: number;
+        forge?: string | undefined;
+        kind: "change_request";
+    };
+    kind: "worktree";
+    cwd?: string;
+    projectId?: string;
+    worktreeSlug?: string;
+};
+export declare function runCreateCommand(options: WorkspaceCreateOptions, _command: Command): Promise<SingleResult<WorkspaceRow>>;
+//# sourceMappingURL=create.d.ts.map