@getpaseo/cli 0.2.0-beta.1 → 0.2.0-beta.3

package/dist/commands/heartbeat/index.js

@@ -0,0 +1,139 @@
+import { Command } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { parseDuration } from "../../utils/duration.js";
+import { connectScheduleClient, toScheduleCommandError, toScheduleRow, } from "../schedule/shared.js";
+import { scheduleSchema } from "../schedule/schema.js";
+const heartbeatDeleteSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id" },
+        { header: "STATUS", field: "status" },
+    ],
+};
+function requireCallerAgentId() {
+    const agentId = process.env.PASEO_AGENT_ID?.trim();
+    if (!agentId) {
+        throw new Error("Heartbeat commands must run inside a Paseo agent");
+    }
+    return agentId;
+}
+async function requireOwnedHeartbeat(client, id, agentId) {
+    const payload = await client.scheduleInspect({ id });
+    if (payload.error || !payload.schedule) {
+        throw new Error(payload.error ?? `Heartbeat not found: ${id}`);
+    }
+    if (payload.schedule.target.type !== "agent" || payload.schedule.target.agentId !== agentId) {
+        throw new Error(`Heartbeat ${id} does not belong to agent ${agentId}`);
+    }
+}
+async function runCreateHeartbeat(prompt, options, _command) {
+    const agentId = requireCallerAgentId();
+    const cron = options.cron?.trim();
+    if (!cron) {
+        throw new Error("--cron is required");
+    }
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        const maxRuns = options.maxRuns ? Number.parseInt(options.maxRuns, 10) : undefined;
+        if (maxRuns !== undefined && (!Number.isSafeInteger(maxRuns) || maxRuns <= 0)) {
+            throw new Error("--max-runs must be a positive integer");
+        }
+        const payload = await client.scheduleCreate({
+            prompt: prompt.trim(),
+            cadence: {
+                type: "cron",
+                expression: cron,
+                ...(options.timezone?.trim() ? { timezone: options.timezone.trim() } : {}),
+            },
+            target: { type: "agent", agentId },
+            ...(options.name?.trim() ? { name: options.name.trim() } : {}),
+            ...(maxRuns ? { maxRuns } : {}),
+            ...(options.expiresIn
+                ? { expiresAt: new Date(Date.now() + parseDuration(options.expiresIn)).toISOString() }
+                : {}),
+        });
+        if (payload.error || !payload.schedule) {
+            throw new Error(payload.error ?? "Heartbeat creation failed");
+        }
+        return { type: "single", data: toScheduleRow(payload.schedule), schema: scheduleSchema };
+    }
+    catch (error) {
+        throw toScheduleCommandError("HEARTBEAT_CREATE_FAILED", "create heartbeat", error);
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+async function runUpdateHeartbeat(id, options, _command) {
+    const agentId = requireCallerAgentId();
+    const cron = options.cron?.trim();
+    if (!cron) {
+        throw new Error("--cron is required");
+    }
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        await requireOwnedHeartbeat(client, id, agentId);
+        const payload = await client.scheduleUpdate({
+            id,
+            cadence: {
+                type: "cron",
+                expression: cron,
+                ...(options.timezone?.trim() ? { timezone: options.timezone.trim() } : {}),
+            },
+        });
+        if (payload.error || !payload.schedule) {
+            throw new Error(payload.error ?? `Heartbeat update failed: ${id}`);
+        }
+        return { type: "single", data: toScheduleRow(payload.schedule), schema: scheduleSchema };
+    }
+    catch (error) {
+        throw toScheduleCommandError("HEARTBEAT_UPDATE_FAILED", "update heartbeat", error);
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+async function runDeleteHeartbeat(id, options, _command) {
+    const agentId = requireCallerAgentId();
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        await requireOwnedHeartbeat(client, id, agentId);
+        const payload = await client.scheduleDelete({ id });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return {
+            type: "single",
+            data: { id: payload.scheduleId, status: "deleted" },
+            schema: heartbeatDeleteSchema,
+        };
+    }
+    catch (error) {
+        throw toScheduleCommandError("HEARTBEAT_DELETE_FAILED", "delete heartbeat", error);
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+export function createHeartbeatCommand() {
+    const heartbeat = new Command("heartbeat").description("Manage this agent's heartbeats");
+    addJsonAndDaemonHostOptions(heartbeat
+        .command("create")
+        .description("Create a recurring prompt for this agent")
+        .argument("<prompt>", "Prompt to send")
+        .requiredOption("--cron <expr>", "Five-field cron cadence")
+        .option("--timezone <iana>", "IANA time zone")
+        .option("--name <name>", "Heartbeat name")
+        .option("--max-runs <n>", "Maximum number of runs")
+        .option("--expires-in <duration>", "Time to live")).action(withOutput(runCreateHeartbeat));
+    addJsonAndDaemonHostOptions(heartbeat
+        .command("update")
+        .description("Change a heartbeat cron cadence")
+        .argument("<id>", "Heartbeat ID")
+        .requiredOption("--cron <expr>", "Five-field cron cadence")
+        .option("--timezone <iana>", "IANA time zone")).action(withOutput(runUpdateHeartbeat));
+    addJsonAndDaemonHostOptions(heartbeat.command("delete").description("Delete a heartbeat").argument("<id>", "Heartbeat ID")).action(withOutput(runDeleteHeartbeat));
+    return heartbeat;
+}
+//# sourceMappingURL=index.js.map

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

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

package/dist/commands/hub/index.js

@@ -0,0 +1,65 @@
+import { Command } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { connectToDaemon } from "../../utils/client.js";
+const schema = {
+    idField: "state",
+    columns: [
+        { header: "STATE", field: "state" },
+        { header: "HUB", field: "hub" },
+        { header: "DAEMON", field: "daemonId" },
+        { header: "SCOPES", field: "scopes" },
+        { header: "CONNECTED", field: "connectedAt" },
+        { header: "ERROR", field: "error" },
+        { header: "WARNING", field: "warning" },
+    ],
+};
+function result(status, warning) {
+    return {
+        type: "list",
+        data: [
+            {
+                state: status.state,
+                daemonId: status.daemonId,
+                hub: status.hubOrigin,
+                scopes: status.scopes.join(", "),
+                connectedAt: status.connectedAt,
+                error: status.lastError,
+                warning,
+            },
+        ],
+        schema,
+    };
+}
+async function withClient(host, action) {
+    const client = await connectToDaemon({ host });
+    try {
+        return await action(client);
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+export function createHubCommand() {
+    const hub = new Command("hub").description("Manage this daemon's Paseo Hub relationship");
+    addJsonAndDaemonHostOptions(hub.command("connect").argument("<url>").requiredOption("--token <token>")).action(withOutput(async (...args) => {
+        const url = args[0];
+        const options = args.at(-2);
+        return withClient(options.host, async (client) => result((await client.connectHub(url, options.token)).status));
+    }));
+    addJsonAndDaemonHostOptions(hub.command("status")).action(withOutput(async (...args) => {
+        const options = args.at(-2);
+        return withClient(options.host, async (client) => result((await client.getHubStatus()).status));
+    }));
+    addJsonAndDaemonHostOptions(hub
+        .command("disconnect")
+        .option("--force", "Remove local authority even if the Hub is offline")).action(withOutput(async (...args) => {
+        const options = args.at(-2);
+        return withClient(options.host, async (client) => {
+            const response = await client.disconnectHub(options.force ?? false);
+            return result(response.status, response.warning);
+        });
+    }));
+    return hub;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/open.d.ts

@@ -1,2 +1,4 @@
+import { type AgentDeepLinkTarget } from "@getpaseo/protocol/agent-deep-link";
 export declare function openDesktopWithProject(projectPath: string): Promise<void>;
+export declare function openDesktopWithAgent(target: AgentDeepLinkTarget): Promise<void>;
 //# sourceMappingURL=open.d.ts.map

package/dist/commands/open.js

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
 import { spawnProcess } from "@getpaseo/server";
+import { buildAgentDeepLink } from "@getpaseo/protocol/agent-deep-link";
 function findDesktopApp() {
     if (process.platform === "darwin") {
         const candidates = [
@@ -55,25 +56,26 @@ function spawnDetached(command, args) {
         env: cleanEnvForDesktopLaunch(),
     }).unref();
 }
+function launchDesktop(args) {
+    if (process.env.PASEO_DESKTOP_CLI === "1") {
+        throw new Error("Cannot open Paseo Desktop while running in desktop CLI passthrough mode.");
+    }
+    const desktopApp = findDesktopApp();
+    if (!desktopApp) {
+        throw new Error("Paseo desktop app not found. Install it from https://github.com/getpaseo/paseo/releases");
+    }
+    if (process.platform === "darwin") {
+        // -n forces a new instance even if the app is already running. The new
+        // instance relays its argv to the existing one through Electron's
+        // single-instance lock. -g keeps the terminal in the foreground.
+        spawnDetached("open", ["-n", "-g", "-a", desktopApp, "--args", ...args]);
+        return;
+    }
+    spawnDetached(desktopApp, args);
+}
 export async function openDesktopWithProject(projectPath) {
     try {
-        if (process.env.PASEO_DESKTOP_CLI === "1") {
-            throw new Error("Cannot open a desktop project while running in desktop CLI passthrough mode.");
-        }
-        const desktopApp = findDesktopApp();
-        if (!desktopApp) {
-            throw new Error("Paseo desktop app not found. Install it from https://github.com/getpaseo/paseo/releases");
-        }
-        if (process.platform === "darwin") {
-            // -n forces a new instance even if the app is already running.
-            // The new instance hits requestSingleInstanceLock(), fails, and relays
-            // the argv to the first instance via the second-instance event.
-            // -g keeps the terminal in the foreground (better CLI UX).
-            // Without -n, macOS just activates the existing window and drops --args.
-            spawnDetached("open", ["-n", "-g", "-a", desktopApp, "--args", projectPath]);
-            return;
-        }
-        spawnDetached(desktopApp, [projectPath]);
+        launchDesktop([projectPath]);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -81,4 +83,7 @@ export async function openDesktopWithProject(projectPath) {
         process.exitCode = 1;
     }
 }
+export async function openDesktopWithAgent(target) {
+    launchDesktop([buildAgentDeepLink(target)]);
+}
 //# sourceMappingURL=open.js.map

package/dist/commands/schedule/index.js

@@ -1,4 +1,4 @@
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { withOutput } from "../../output/index.js";
 import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
 import { runCreateCommand } from "./create.js";
@@ -16,16 +16,15 @@ export function createScheduleCommand() {
         .command("create")
         .description("Create a schedule")
         .argument("<prompt>", "Prompt to run on the schedule")
-        .option("--every <duration>", "Fixed interval cadence (for example: 5m, 1h)")
+        .option("--every <duration>", "Cron-compatible cadence preset (for example: 5m, 1h)")
         .option("--cron <expr>", "Cron cadence expression")
         .option("--timezone <iana>", "IANA time zone for cron cadence (default: UTC)")
         .option("--name <name>", "Optional schedule name")
-        .option("--target <self|new-agent|agent-id>", "Run target")
+        .addOption(new Option("--target <target>", "Legacy schedule target").hideHelp())
         .option("--provider <provider>", "Agent provider, or provider/model (e.g. codex or codex/gpt-5.4)")
         .option("--mode <mode>", "Provider-specific mode (e.g. claude bypassPermissions, opencode build)")
         .option("--cwd <path>", "Working directory (default: current; required with --host)")
-        .option("--run-now", "Fire one immediate run on creation (only with --cron)")
-        .option("--no-run-now", "Wait the full interval before the first run (only with --every)")
+        .option("--run-now", "Fire one immediate run on creation")
         .option("--max-runs <n>", "Maximum number of runs")
         .option("--expires-in <duration>", "Time to live for the schedule")).action(withOutput(runCreateCommand));
     addJsonAndDaemonHostOptions(schedule.command("ls").description("List schedules")).action(withOutput(runLsCommand));
@@ -48,7 +47,7 @@ export function createScheduleCommand() {
         .command("update")
         .description("Update an existing schedule in place")
         .argument("<id>", "Schedule ID")
-        .option("--every <duration>", "Switch to fixed interval cadence (for example: 5m, 1h)")
+        .option("--every <duration>", "Cron-compatible cadence preset (for example: 5m, 1h)")
         .option("--cron <expr>", "Switch to cron cadence expression")
         .option("--timezone <iana>", "IANA time zone for cron cadence (requires --cron)")
         .option("--name <name>", "Rename the schedule (empty string clears the name)")

package/dist/commands/schedule/inspect.js

@@ -7,6 +7,9 @@ export async function runInspectCommand(id, options, _command) {
         if (payload.error || !payload.schedule) {
             throw new Error(payload.error ?? `Schedule not found: ${id}`);
         }
+        if (payload.schedule.target.type !== "new-agent") {
+            throw new Error(`Schedule not found: ${id}`);
+        }
         const rows = createScheduleInspectRows(payload.schedule);
         return {
             type: "list",

package/dist/commands/schedule/logs.js

@@ -1,8 +1,9 @@
 import { scheduleLogSchema, toScheduleLogRow } from "./schema.js";
-import { connectScheduleClient, toScheduleCommandError, } from "./shared.js";
+import { connectScheduleClient, requireNewAgentSchedule, toScheduleCommandError, } from "./shared.js";
 export async function runLogsCommand(id, options, _command) {
     const { client } = await connectScheduleClient(options.host);
     try {
+        await requireNewAgentSchedule(client, id);
         const payload = await client.scheduleLogs({ id });
         if (payload.error) {
             throw new Error(payload.error);

package/dist/commands/schedule/ls.js

@@ -9,7 +9,9 @@ export async function runLsCommand(options, _command) {
         }
         return {
             type: "list",
-            data: payload.schedules.map(toScheduleRow),
+            data: payload.schedules
+                .filter((schedule) => schedule.target.type === "new-agent")
+                .map(toScheduleRow),
             schema: scheduleSchema,
         };
     }

package/dist/commands/schedule/pause.js

@@ -1,8 +1,9 @@
 import { scheduleSchema } from "./schema.js";
-import { connectScheduleClient, toScheduleCommandError, toScheduleRow, } from "./shared.js";
+import { connectScheduleClient, requireNewAgentSchedule, toScheduleCommandError, toScheduleRow, } from "./shared.js";
 export async function runPauseCommand(id, options, _command) {
     const { client } = await connectScheduleClient(options.host);
     try {
+        await requireNewAgentSchedule(client, id);
         const payload = await client.schedulePause({ id });
         if (payload.error || !payload.schedule) {
             throw new Error(payload.error ?? `Failed to pause schedule: ${id}`);

package/dist/commands/schedule/resume.js

@@ -1,8 +1,9 @@
 import { scheduleSchema } from "./schema.js";
-import { connectScheduleClient, toScheduleCommandError, toScheduleRow, } from "./shared.js";
+import { connectScheduleClient, requireNewAgentSchedule, toScheduleCommandError, toScheduleRow, } from "./shared.js";
 export async function runResumeCommand(id, options, _command) {
     const { client } = await connectScheduleClient(options.host);
     try {
+        await requireNewAgentSchedule(client, id);
         const payload = await client.scheduleResume({ id });
         if (payload.error || !payload.schedule) {
             throw new Error(payload.error ?? `Failed to resume schedule: ${id}`);

package/dist/commands/schedule/run-once.js

@@ -1,8 +1,9 @@
 import { scheduleSchema } from "./schema.js";
-import { connectScheduleClient, toScheduleCommandError, toScheduleRow, } from "./shared.js";
+import { connectScheduleClient, requireNewAgentSchedule, toScheduleCommandError, toScheduleRow, } from "./shared.js";
 export async function runRunOnceCommand(id, options, _command) {
     const { client } = await connectScheduleClient(options.host);
     try {
+        await requireNewAgentSchedule(client, id);
         const payload = await client.scheduleRunOnce({ id });
         if (payload.error || !payload.schedule) {
             throw new Error(payload.error ?? `Failed to run schedule once: ${id}`);

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

@@ -8,6 +8,7 @@ export declare function connectScheduleClient(host: string | undefined): Promise
     host: string;
 }>;
 export declare function toScheduleCommandError(code: string, action: string, error: unknown): CommandError;
+export declare function requireNewAgentSchedule(client: ScheduleDaemonClient, id: string): Promise<void>;
 export declare function formatCadence(cadence: ScheduleCadence): string;
 export declare function formatTarget(target: ScheduleTarget | ScheduleListItem["target"]): string;
 export declare function formatDurationMs(durationMs: number): string;
@@ -43,6 +44,7 @@ export interface ScheduleUpdateOptionsInput {
     clearExpires?: boolean;
 }
 export declare function parseScheduleUpdateInput(options: ScheduleUpdateOptionsInput): UpdateScheduleInput;
+export declare function compileEveryPresetToCron(value: string): string;
 export interface ScheduleRow {
     id: string;
     name: string | null;

package/dist/commands/schedule/shared.js

@@ -1,6 +1,7 @@
 import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
 import { parseDuration } from "../../utils/duration.js";
 import { resolveProviderAndModel } from "../../utils/provider-model.js";
+import { everyMsToFiveFieldCron } from "@getpaseo/protocol/schedule/cadence";
 export async function connectScheduleClient(host) {
     const resolvedHost = getDaemonHost({ host });
     try {
@@ -28,6 +29,12 @@ export function toScheduleCommandError(code, action, error) {
         message: `Failed to ${action}: ${message}`,
     };
 }
+export async function requireNewAgentSchedule(client, id) {
+    const payload = await client.scheduleInspect({ id });
+    if (payload.error || !payload.schedule || payload.schedule.target.type !== "new-agent") {
+        throw new Error(payload.error ?? `Schedule not found: ${id}`);
+    }
+}
 export function formatCadence(cadence) {
     if (cadence.type === "cron") {
         const timezoneSuffix = cadence.timezone ? ` (${cadence.timezone})` : "";
@@ -66,11 +73,7 @@ export function formatDurationMs(durationMs) {
 }
 function resolveScheduleTarget(args) {
     const { targetValue, hasExplicitNewAgentOption, createNewAgentTarget } = args;
-    const currentAgentId = process.env.PASEO_AGENT_ID?.trim();
     if (!targetValue) {
-        if (currentAgentId && !hasExplicitNewAgentOption) {
-            return { type: "self", agentId: currentAgentId };
-        }
         return createNewAgentTarget();
     }
     if (targetValue === "new-agent") {
@@ -84,6 +87,9 @@ function resolveScheduleTarget(args) {
         };
     }
     if (targetValue === "self") {
+        // COMPAT(scheduleSelfTarget): heartbeat creation moved to `paseo heartbeat create`.
+        // Added in v0.2.0; remove after 2027-01-17.
+        const currentAgentId = process.env.PASEO_AGENT_ID?.trim();
         if (!currentAgentId) {
             throw {
                 code: "INVALID_TARGET",
@@ -153,22 +159,8 @@ export function parseScheduleCreateInput(options) {
         ...(expiresAt ? { expiresAt } : {}),
     };
 }
-function resolveRunOnCreate(runNow, cadenceType) {
-    if (runNow === true && cadenceType === "every") {
-        throw {
-            code: "REDUNDANT_RUN_NOW",
-            message: "--run-now is redundant with --every (interval schedules already fire on creation)",
-            details: "Drop --run-now, or use --no-run-now to wait the full interval before the first run",
-        };
-    }
-    if (runNow === false && cadenceType === "cron") {
-        throw {
-            code: "REDUNDANT_NO_RUN_NOW",
-            message: "--no-run-now is redundant with --cron (cron schedules never fire on creation)",
-            details: "Drop --no-run-now, or use --run-now to fire one immediate run on creation",
-        };
-    }
-    return runNow ?? cadenceType === "every";
+function resolveRunOnCreate(runNow, _cadenceType) {
+    return runNow ?? false;
 }
 export function parseScheduleUpdateInput(options) {
     const id = options.id.trim();
@@ -220,7 +212,7 @@ function parseCadenceFromFlags(every, cron, timezone) {
         };
     }
     if (every !== undefined) {
-        return { type: "every", everyMs: parseDuration(every) };
+        return { type: "cron", expression: compileEveryPresetToCron(every) };
     }
     if (cron !== undefined) {
         return {
@@ -231,6 +223,18 @@ function parseCadenceFromFlags(every, cron, timezone) {
     }
     return undefined;
 }
+export function compileEveryPresetToCron(value) {
+    const durationMs = parseDuration(value);
+    const cron = everyMsToFiveFieldCron(durationMs);
+    if (cron) {
+        return cron;
+    }
+    throw {
+        code: "UNREPRESENTABLE_CADENCE",
+        message: `${value} cannot be represented faithfully by five-field cron`,
+        details: "Use --cron for calendar schedules",
+    };
+}
 function parseTimeZoneFlag(timeZone) {
     if (timeZone === undefined) {
         return undefined;

package/dist/commands/schedule/update.js

@@ -1,5 +1,5 @@
 import { createScheduleInspectRows, createScheduleInspectSchema, } from "./schema.js";
-import { connectScheduleClient, parseScheduleUpdateInput, toScheduleCommandError, } from "./shared.js";
+import { connectScheduleClient, parseScheduleUpdateInput, requireNewAgentSchedule, toScheduleCommandError, } from "./shared.js";
 export async function runUpdateCommand(id, options, _command) {
     const input = parseScheduleUpdateInput({
         id,
@@ -19,6 +19,7 @@ export async function runUpdateCommand(id, options, _command) {
     });
     const { client } = await connectScheduleClient(options.host);
     try {
+        await requireNewAgentSchedule(client, id);
         const payload = await client.scheduleUpdate(input);
         if (payload.error || !payload.schedule) {
             throw new Error(payload.error ?? `Failed to update schedule: ${id}`);

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