@getpaseo/cli 0.1.96 → 0.1.97-beta.1

package/dist/cli.js

@@ -9,6 +9,7 @@ import { createScheduleCommand } from "./commands/schedule/index.js";
 import { createSpeechCommand } from "./commands/speech/index.js";
 import { createTerminalCommand } from "./commands/terminal/index.js";
 import { createWorktreeCommand } from "./commands/worktree/index.js";
+import { createHooksCommand } from "./commands/hooks.js";
 import { startCommand as daemonStartCommand } from "./commands/daemon/start.js";
 import { runStatusCommand as runDaemonStatusCommand } from "./commands/daemon/status.js";
 import { runRestartCommand as runDaemonRestartCommand } from "./commands/daemon/restart.js";
@@ -62,6 +63,7 @@ export function createCli() {
     // Top-level local daemon shortcuts
     program.addCommand(onboardCommand());
     program.addCommand(daemonStartCommand());
+    program.addCommand(createHooksCommand());
     addJsonOption(program
         .command("status")
         .description('Show local daemon status (alias for "paseo daemon status")'))

package/dist/commands/agent/run.d.ts

@@ -23,6 +23,7 @@ export interface AgentRunOptions extends CommandOptions {
     mode?: string;
     worktree?: string;
     base?: string;
+    workspace?: string;
     image?: string[];
     cwd?: string;
     env?: string[];

package/dist/commands/agent/run.js

@@ -21,6 +21,7 @@ export function addRunOptions(cmd) {
         .option("--mode <mode>", "Provider-specific mode (e.g., plan, default, bypass)")
         .option("--worktree <name>", "Create agent in a new git worktree")
         .option("--base <branch>", "Base branch for worktree (default: current branch)")
+        .option("--workspace <id>", "Run in an existing workspace (default: a new workspace is created per run; falls back to $PASEO_WORKSPACE_ID)")
         .option("--image <path>", "Attach image(s) to the initial prompt (can be used multiple times)", collectMultiple, [])
         .option("--cwd <path>", "Working directory (default: current)")
         .option("--env <key=value>", "Set environment variable(s) for the agent process (can be used multiple times)", collectMultiple, [])
@@ -178,6 +179,20 @@ function validateRunOptions(prompt, options, outputSchema) {
             details: "Usage: paseo agent run --worktree <name> --base <branch> <prompt>",
         };
     }
+    if (options.worktree && options.workspace) {
+        throw {
+            code: "INVALID_OPTIONS",
+            message: "--worktree and --workspace cannot be combined",
+            details: "--workspace runs in an existing workspace; --worktree mints a new one",
+        };
+    }
+    if (options.worktree && !options.workspace && process.env.PASEO_WORKSPACE_ID) {
+        throw {
+            code: "INVALID_OPTIONS",
+            message: "--worktree cannot be combined with an ambient PASEO_WORKSPACE_ID",
+            details: "PASEO_WORKSPACE_ID selects an existing workspace; --worktree mints a new one. Unset PASEO_WORKSPACE_ID to use --worktree.",
+        };
+    }
     if (outputSchema && options.detach) {
         throw {
             code: "INVALID_OPTIONS",
@@ -274,6 +289,48 @@ async function connectToDaemonOrThrow(hostOption, host) {
         };
     }
 }
+// Workspace policy for `paseo run`. Precedence:
+//   1. --workspace <id>            -> run in that existing workspace
+//   2. $PASEO_WORKSPACE_ID         -> exported by workspace terminals
+//   3. --worktree <name>           -> mint a new worktree-backed workspace
+//   4. bare run                    -> mint a new local-backed workspace for cwd
+// --worktree is rejected alongside both --workspace and an ambient
+// $PASEO_WORKSPACE_ID (validateRunOptions), so worktree resolution here never
+// races an existing-workspace selection.
+async function resolveRunWorkspace(client, options, cwd) {
+    // An explicit --worktree mints its own workspace; --workspace and an ambient
+    // PASEO_WORKSPACE_ID are both rejected alongside --worktree upstream.
+    const explicit = options.worktree
+        ? undefined
+        : options.workspace?.trim() || process.env.PASEO_WORKSPACE_ID?.trim();
+    if (explicit) {
+        console.error(`Using workspace ${explicit}`);
+        return { id: explicit, cwd };
+    }
+    // TODO: thread the run `prompt` as firstAgentContext so workspace-level
+    // title/branch generation picks up the task description (U8/U6 deferred).
+    const result = options.worktree
+        ? await client.createWorkspace({
+            source: {
+                kind: "worktree",
+                cwd,
+                worktreeSlug: options.worktree,
+                baseBranch: options.base,
+            },
+        })
+        : await client.createWorkspace({ source: { kind: "directory", path: cwd } });
+    if (!result.workspace) {
+        throw {
+            code: "WORKSPACE_CREATE_FAILED",
+            message: result.error ?? "Failed to create workspace for this run",
+        };
+    }
+    const branch = result.workspace.gitRuntime?.currentBranch;
+    const label = branch ? `${result.workspace.name} (${branch})` : result.workspace.name;
+    console.error(`Created workspace ${result.workspace.id} - ${label}`);
+    console.error("Tip: pass --workspace <id> (or set PASEO_WORKSPACE_ID) to run in an existing workspace.");
+    return { id: result.workspace.id, cwd: result.workspace.workspaceDirectory ?? cwd };
+}
 export async function runRunCommand(prompt, options, _command) {
     const host = getDaemonHost({ host: options.host });
     const outputSchema = options.outputSchema ? loadOutputSchema(options.outputSchema) : undefined;
@@ -295,23 +352,20 @@ export async function runRunCommand(prompt, options, _command) {
             throw error;
         }
         const images = loadRunImages(options.image);
-        const git = options.worktree
-            ? {
-                createWorktree: true,
-                worktreeSlug: options.worktree,
-                baseBranch: options.base,
-            }
-            : undefined;
         const labels = parseRunLabels(options.label);
         const env = parseRunEnv(options.env);
         const requestEnv = Object.keys(env).length > 0 ? env : undefined;
+        const workspace = await resolveRunWorkspace(client, options, cwd);
+        const workspaceId = workspace.id;
+        const runCwd = workspace.cwd;
         if (outputSchema) {
             let structuredAgent = null;
             const callStructuredTurn = async (structuredPrompt) => {
                 if (!structuredAgent) {
                     structuredAgent = await client.createAgent({
                         provider: resolvedProviderModel.provider,
-                        cwd,
+                        cwd: runCwd,
+                        workspaceId,
                         title: resolvedTitle,
                         modeId: options.mode,
                         model: resolvedProviderModel.model,
@@ -320,8 +374,6 @@ export async function runRunCommand(prompt, options, _command) {
                         outputSchema,
                         images,
                         env: requestEnv,
-                        git,
-                        worktreeName: options.worktree,
                         labels: Object.keys(labels).length > 0 ? labels : undefined,
                     });
                 }
@@ -366,7 +418,8 @@ export async function runRunCommand(prompt, options, _command) {
         // Create the agent
         const agent = await client.createAgent({
             provider: resolvedProviderModel.provider,
-            cwd,
+            cwd: runCwd,
+            workspaceId,
             title: resolvedTitle,
             modeId: options.mode,
             model: resolvedProviderModel.model,
@@ -374,8 +427,6 @@ export async function runRunCommand(prompt, options, _command) {
             initialPrompt: prompt,
             images,
             env: requestEnv,
-            git,
-            worktreeName: options.worktree,
             labels: Object.keys(labels).length > 0 ? labels : undefined,
         });
         // Default run behavior is foreground: wait for completion unless --detach is set.

package/dist/commands/hooks.d.ts

@@ -0,0 +1,19 @@
+import { Command } from "commander";
+interface HookEnvironment {
+    PASEO_TERMINAL_ID?: string;
+    PASEO_ACTIVITY_TOKEN?: string;
+    PASEO_TERMINAL_ACTIVITY_URL?: string;
+}
+interface HookInput {
+    [Symbol.asyncIterator](): AsyncIterator<string | Buffer>;
+    isTTY?: boolean;
+}
+interface HooksRuntime {
+    env: HookEnvironment;
+    input: HookInput;
+    fetch: typeof fetch;
+}
+export declare function createHooksCommand(): Command;
+export declare function runHooksCommand(agent: string, event: string, runtime?: HooksRuntime): Promise<void>;
+export {};
+//# sourceMappingURL=hooks.d.ts.map

package/dist/commands/hooks.js

@@ -0,0 +1,89 @@
+import { Command } from "commander";
+import { resolveHookActivity } from "@getpaseo/server/agent-hooks";
+export function createHooksCommand() {
+    return new Command("hooks")
+        .description("Record agent hook activity")
+        .argument("<agent>", "Agent hook source")
+        .argument("<event>", "Agent hook event")
+        .action((agent, event) => runHooksCommand(agent, event));
+}
+export async function runHooksCommand(agent, event, runtime = {
+    env: process.env,
+    input: process.stdin,
+    fetch,
+}) {
+    const target = resolveTarget(runtime.env);
+    if (!target)
+        return;
+    const state = await resolveHookActivity({
+        provider: agent,
+        event,
+        input: {
+            isTTY: runtime.input.isTTY,
+            read: () => readInput(runtime.input),
+        },
+    });
+    if (!state)
+        return;
+    await postActivity(target, state, runtime.fetch);
+}
+function resolveTarget(env) {
+    const terminalId = env.PASEO_TERMINAL_ID;
+    const token = env.PASEO_ACTIVITY_TOKEN;
+    const url = env.PASEO_TERMINAL_ACTIVITY_URL;
+    if (!terminalId || !token || !url)
+        return null;
+    return { terminalId, token, url };
+}
+async function readInput(input) {
+    const iterator = input[Symbol.asyncIterator]();
+    const chunks = [];
+    while (true) {
+        const next = await withTimeout(iterator.next(), 100);
+        if (!next) {
+            await iterator.return?.();
+            return null;
+        }
+        if (next.done)
+            return chunks.join("");
+        chunks.push(String(next.value));
+    }
+}
+async function withTimeout(promise, ms) {
+    let timeout;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((resolve) => {
+                timeout = setTimeout(() => resolve(null), ms);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+async function postActivity(target, state, send) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 500);
+    try {
+        await send(target.url, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                terminalId: target.terminalId,
+                token: target.token,
+                state,
+            }),
+            signal: controller.signal,
+        });
+    }
+    catch {
+        return;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+//# sourceMappingURL=hooks.js.map

package/dist/commands/terminal/create.js

@@ -4,7 +4,17 @@ export async function runCreateCommand(options, _command) {
     const { client } = await connectTerminalClient(options.host);
     const cwd = options.cwd ?? process.cwd();
     try {
-        const payload = await client.createTerminal(cwd, options.name);
+        const opened = await client.openProject(cwd);
+        if (!opened.workspace) {
+            const error = {
+                code: "WORKSPACE_OPEN_FAILED",
+                message: opened.error ?? "Failed to open workspace",
+            };
+            throw error;
+        }
+        const payload = await client.createTerminal(cwd, options.name, undefined, {
+            workspaceId: opened.workspace.id,
+        });
         if (!payload.terminal) {
             const error = {
                 code: "TERMINAL_CREATE_FAILED",

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

@@ -1,4 +1,5 @@
 import type { Command } from "commander";
+import { connectToDaemon } from "../../utils/client.js";
 import type { CommandOptions, SingleResult, OutputSchema } from "../../output/index.js";
 /** Result type for worktree archive command */
 export interface WorktreeArchiveResult {
@@ -13,4 +14,7 @@ export interface WorktreeArchiveOptions extends CommandOptions {
 }
 export type WorktreeArchiveCommandResult = SingleResult<WorktreeArchiveResult>;
 export declare function runArchiveCommand(nameArg: string, options: WorktreeArchiveOptions, _command: Command): Promise<WorktreeArchiveCommandResult>;
+export declare function runArchiveCommandWithDeps(nameArg: string, options: WorktreeArchiveOptions, deps: {
+    connectToDaemon: typeof connectToDaemon;
+}): Promise<WorktreeArchiveCommandResult>;
 //# sourceMappingURL=archive.d.ts.map

package/dist/commands/worktree/archive.js

@@ -13,6 +13,9 @@ export const archiveSchema = {
     ],
 };
 export async function runArchiveCommand(nameArg, options, _command) {
+    return runArchiveCommandWithDeps(nameArg, options, { connectToDaemon });
+}
+export async function runArchiveCommandWithDeps(nameArg, options, deps) {
     const host = getDaemonHost({ host: options.host });
     // Validate arguments
     if (!nameArg || nameArg.trim().length === 0) {
@@ -25,7 +28,7 @@ export async function runArchiveCommand(nameArg, options, _command) {
     }
     let client;
     try {
-        client = await connectToDaemon({ host: options.host });
+        client = await deps.connectToDaemon({ host: options.host });
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -59,9 +62,11 @@ export async function runArchiveCommand(nameArg, options, _command) {
             };
             throw error;
         }
-        // Archive the worktree
+        // Archive the worktree. scope:"worktree" archives every active workspace on
+        // the directory and then removes the directory (Paseo-owned gated).
         const response = await client.archivePaseoWorktree({
             worktreePath: worktree.worktreePath,
+            scope: "worktree",
         });
         await client.close();
         if (response.error) {

package/dist/commands/worktree/create.js

@@ -30,7 +30,10 @@ export async function runCreateCommand(options, _command) {
         if (!workspace || response.error) {
             throw cmdError("WORKTREE_CREATE_FAILED", `Failed to create worktree: ${response.error ?? "no workspace returned"}`);
         }
-        const worktreePath = workspace.workspaceDirectory ?? workspace.id;
+        if (!workspace.workspaceDirectory) {
+            throw cmdError("WORKTREE_CREATE_FAILED", "Failed to create worktree: workspace directory missing from daemon response");
+        }
+        const worktreePath = workspace.workspaceDirectory;
         return {
             type: "single",
             data: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/cli",
-  "version": "0.1.96",
+  "version": "0.1.97-beta.1",
   "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.1.96",
-    "@getpaseo/protocol": "0.1.96",
-    "@getpaseo/server": "0.1.96",
+    "@getpaseo/client": "0.1.97-beta.1",
+    "@getpaseo/protocol": "0.1.97-beta.1",
+    "@getpaseo/server": "0.1.97-beta.1",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",