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

package/dist/commands/workspace/create.js

@@ -0,0 +1,114 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { toWorkspaceRow, workspaceSchema } from "./shared.js";
+function assertOptionsAbsent(values, message) {
+    if (values.some((value) => value !== undefined)) {
+        throw new Error(message);
+    }
+}
+function buildLocalWorkspaceSource(options, path) {
+    assertOptionsAbsent([
+        options.mode,
+        options.worktreeSlug,
+        options.newBranch,
+        options.base,
+        options.branch,
+        options.prNumber,
+        options.forge,
+    ], "Worktree options require --isolation worktree");
+    return {
+        kind: "directory",
+        path,
+        ...(options.project ? { projectId: options.project } : {}),
+    };
+}
+function buildBranchOffSource(options, source) {
+    assertOptionsAbsent([options.branch, options.prNumber, options.forge], "--branch, --pr-number, and --forge require a checkout mode");
+    return {
+        ...source,
+        action: "branch-off",
+        ...(options.newBranch ? { branchName: options.newBranch } : {}),
+        ...(options.base ? { baseBranch: options.base } : {}),
+    };
+}
+function buildBranchCheckoutSource(options, source) {
+    if (!options.branch) {
+        throw new Error("--branch is required for --mode checkout-branch");
+    }
+    assertOptionsAbsent([options.newBranch, options.base, options.prNumber, options.forge], "--new-branch, --base, --pr-number, and --forge are not valid for --mode checkout-branch");
+    return { ...source, action: "checkout", refName: options.branch };
+}
+function buildPullRequestCheckoutSource(options, source) {
+    if (options.prNumber === undefined || options.prNumber === "") {
+        throw new Error("--pr-number is required for --mode checkout-pr");
+    }
+    const prNumber = Number(options.prNumber);
+    if (!Number.isInteger(prNumber) || prNumber <= 0) {
+        throw new Error("--pr-number must be a positive integer");
+    }
+    assertOptionsAbsent([options.newBranch, options.base, options.branch], "--new-branch, --base, and --branch are not valid for --mode checkout-pr");
+    return {
+        ...source,
+        action: "checkout",
+        checkoutSource: {
+            kind: "change_request",
+            ...(options.forge ? { forge: options.forge } : {}),
+            number: prNumber,
+        },
+    };
+}
+function buildWorktreeWorkspaceSource(options, path) {
+    const source = {
+        kind: "worktree",
+        ...(path ? { cwd: path } : {}),
+        ...(options.project ? { projectId: options.project } : {}),
+        ...(options.worktreeSlug ? { worktreeSlug: options.worktreeSlug } : {}),
+    };
+    switch (options.mode ?? "branch-off") {
+        case "branch-off":
+            return buildBranchOffSource(options, source);
+        case "checkout-branch":
+            return buildBranchCheckoutSource(options, source);
+        case "checkout-pr":
+            return buildPullRequestCheckoutSource(options, source);
+        default:
+            throw new Error(`Unsupported worktree mode: ${String(options.mode)}`);
+    }
+}
+export function buildWorkspaceSource(options) {
+    if (options.isolation === "local") {
+        return buildLocalWorkspaceSource(options, options.path ?? process.cwd());
+    }
+    if (options.isolation === "worktree") {
+        const sourcePath = options.path ?? (options.project ? undefined : process.cwd());
+        return buildWorktreeWorkspaceSource(options, sourcePath);
+    }
+    throw new Error(`Unsupported workspace isolation: ${String(options.isolation)}`);
+}
+export async function runCreateCommand(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.createWorkspace({
+            source: buildWorkspaceSource(options),
+            ...(options.title ? { title: options.title } : {}),
+        });
+        if (!payload.workspace) {
+            throw new Error(payload.error ?? "Workspace creation failed");
+        }
+        return { type: "single", data: toWorkspaceRow(payload.workspace), schema: workspaceSchema };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw { code: "WORKSPACE_CREATE_FAILED", message };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=create.js.map

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

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

package/dist/commands/workspace/index.js

@@ -0,0 +1,30 @@
+import { Command } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { runArchiveCommand } from "./archive.js";
+import { runCreateCommand } from "./create.js";
+import { runLsCommand } from "./ls.js";
+export function createWorkspaceCommand() {
+    const workspace = new Command("workspace").description("Manage workspaces");
+    addJsonAndDaemonHostOptions(workspace
+        .command("create")
+        .description("Create a workspace")
+        .requiredOption("--isolation <local|worktree>", "Workspace isolation")
+        .option("--path <path>", "Local directory or source checkout (default: current)")
+        .option("--project <id>", "Existing project id")
+        .option("--title <title>", "Workspace title")
+        .option("--mode <mode>", "Worktree mode: branch-off, checkout-branch, or checkout-pr (default: branch-off)")
+        .option("--worktree-slug <slug>", "Managed worktree path slug")
+        .option("--new-branch <name>", "New branch name (--mode branch-off)")
+        .option("--base <ref>", "Base ref (--mode branch-off)")
+        .option("--branch <name>", "Existing branch (--mode checkout-branch)")
+        .option("--pr-number <n>", "Pull request or change request number (--mode checkout-pr)")
+        .option("--forge <forge>", "Forge for --mode checkout-pr (default: source checkout)")).action(withOutput(runCreateCommand));
+    addJsonAndDaemonHostOptions(workspace.command("ls").description("List active workspaces")).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(workspace
+        .command("archive")
+        .description("Archive a workspace and everything it owns")
+        .argument("<workspace-id>", "Workspace id")).action(withOutput(runArchiveCommand));
+    return workspace;
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,7 @@
+import type { Command } from "commander";
+import type { ListResult } from "../../output/index.js";
+import { type WorkspaceRow } from "./shared.js";
+export declare function runLsCommand(options: {
+    host?: string;
+}, _command: Command): Promise<ListResult<WorkspaceRow>>;
+//# sourceMappingURL=ls.d.ts.map

package/dist/commands/workspace/ls.js

@@ -0,0 +1,28 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { toWorkspaceRow, workspaceSchema } from "./shared.js";
+export async function runLsCommand(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 workspaces = [];
+        let cursor;
+        do {
+            const payload = await client.fetchWorkspaces({
+                page: { limit: 200, ...(cursor ? { cursor } : {}) },
+            });
+            workspaces.push(...payload.entries.map(toWorkspaceRow));
+            cursor = payload.pageInfo.nextCursor ?? undefined;
+        } while (cursor);
+        return { type: "list", data: workspaces, schema: workspaceSchema };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=ls.js.map

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

@@ -0,0 +1,12 @@
+import type { WorkspaceDescriptorPayload } from "@getpaseo/protocol/messages";
+import type { OutputSchema } from "../../output/index.js";
+export interface WorkspaceRow {
+    workspaceId: string;
+    project: string;
+    name: string;
+    isolation: "local" | "worktree";
+    cwd: string;
+}
+export declare const workspaceSchema: OutputSchema<WorkspaceRow>;
+export declare function toWorkspaceRow(workspace: WorkspaceDescriptorPayload): WorkspaceRow;
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/workspace/shared.js

@@ -0,0 +1,20 @@
+export const workspaceSchema = {
+    idField: "workspaceId",
+    columns: [
+        { header: "WORKSPACE ID", field: "workspaceId", width: 20 },
+        { header: "PROJECT", field: "project", width: 20 },
+        { header: "NAME", field: "name", width: 22 },
+        { header: "ISOLATION", field: "isolation", width: 10 },
+        { header: "CWD", field: "cwd", width: 42 },
+    ],
+};
+export function toWorkspaceRow(workspace) {
+    return {
+        workspaceId: workspace.id,
+        project: workspace.projectDisplayName,
+        name: workspace.name,
+        isolation: workspace.workspaceKind === "worktree" ? "worktree" : "local",
+        cwd: workspace.workspaceDirectory,
+    };
+}
+//# sourceMappingURL=shared.js.map

package/dist/utils/duration.d.ts

@@ -1,6 +1,6 @@
 /**
  * Parse duration string to milliseconds.
- * Supports formats like: 5m, 30s, 1h, 2h30m, 90, etc.
+ * Supports formats like: 5m, 30s, 1h, 2h30m, 1d, 90, etc.
  * If no unit is specified, assumes seconds.
  */
 export declare function parseDuration(input: string): number;

package/dist/utils/duration.js

@@ -1,6 +1,6 @@
 /**
  * Parse duration string to milliseconds.
- * Supports formats like: 5m, 30s, 1h, 2h30m, 90, etc.
+ * Supports formats like: 5m, 30s, 1h, 2h30m, 1d, 90, etc.
  * If no unit is specified, assumes seconds.
  */
 export function parseDuration(input) {
@@ -9,13 +9,14 @@ export function parseDuration(input) {
     if (/^\d+$/.test(trimmed)) {
         return parseInt(trimmed, 10) * 1000;
     }
+    if (!/^(?:\d+[smhd])+$/.test(trimmed)) {
+        throw new Error(`Invalid duration format: ${input}. Use formats like: 5m, 30s, 1h, 2h30m, 1d`);
+    }
     // Parse duration with units
     let totalMs = 0;
-    const regex = /(\d+)([smh])/g;
+    const regex = /(\d+)([smhd])/g;
     let match;
-    let hasMatch = false;
     while ((match = regex.exec(trimmed)) !== null) {
-        hasMatch = true;
         const value = parseInt(match[1], 10);
         const unit = match[2];
         switch (unit) {
@@ -28,11 +29,11 @@ export function parseDuration(input) {
             case "h":
                 totalMs += value * 60 * 60 * 1000;
                 break;
+            case "d":
+                totalMs += value * 24 * 60 * 60 * 1000;
+                break;
         }
     }
-    if (!hasMatch) {
-        throw new Error(`Invalid duration format: ${input}. Use formats like: 5m, 30s, 1h, 2h30m`);
-    }
     return totalMs;
 }
 //# sourceMappingURL=duration.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/cli",
-  "version": "0.2.0-beta.1",
+  "version": "0.2.0-beta.3",
   "description": "Paseo CLI - control your AI coding agents from the command line",
   "bin": {
     "paseo": "bin/paseo"
@@ -27,9 +27,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@getpaseo/client": "0.2.0-beta.1",
-    "@getpaseo/protocol": "0.2.0-beta.1",
-    "@getpaseo/server": "0.2.0-beta.1",
+    "@getpaseo/client": "0.2.0-beta.3",
+    "@getpaseo/protocol": "0.2.0-beta.3",
+    "@getpaseo/server": "0.2.0-beta.3",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",