@getpaseo/cli 0.2.2 → 0.2.4

package/dist/cli.js

@@ -7,6 +7,7 @@ import { createPermitCommand } from "./commands/permit/index.js";
 import { createProviderCommand } from "./commands/provider/index.js";
 import { createScheduleCommand } from "./commands/schedule/index.js";
 import { createSpeechCommand } from "./commands/speech/index.js";
+import { createScriptCommand } from "./commands/script/index.js";
 import { createTerminalCommand } from "./commands/terminal/index.js";
 import { createWorktreeCommand } from "./commands/worktree/index.js";
 import { createWorkspaceCommand } from "./commands/workspace/index.js";
@@ -108,6 +109,8 @@ export function createCli() {
     program.addCommand(createChatCommand());
     // Terminal commands
     program.addCommand(createTerminalCommand());
+    // Workspace script commands
+    program.addCommand(createScriptCommand());
     // Loop commands
     program.addCommand(createLoopCommand());
     // Schedule commands

package/dist/commands/agent/index.js

@@ -46,9 +46,10 @@ export function createAgentCommand() {
         .argument("<id>", "Agent ID, prefix, or name")).action(withOutput(runDetachCommand));
     addJsonAndDaemonHostOptions(agent
         .command("update")
-        .description("Update an agent's metadata")
+        .description("Update an agent's settings or metadata")
         .argument("<id>", "Agent ID (or prefix)")
         .option("--name <name>", "Update the agent's display name")
+        .option("--thinking <id>", "Update the agent's thinking option ID")
         .option("--label <label>", "Add/set label(s) on the agent (can be used multiple times or comma-separated)", collectMultiple, [])).action(withOutput(runUpdateCommand));
     return agent;
 }

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

@@ -1,18 +1,51 @@
 import type { Command } from "commander";
+import type { AgentProviderNotice } from "@getpaseo/protocol/agent-types";
+import type { AgentSnapshotPayload } from "@getpaseo/protocol/messages";
 import type { CommandOptions, SingleResult, OutputSchema } from "../../output/index.js";
 /** Result type for agent update command */
 export interface AgentUpdateResult {
     agentId: string;
     name: string | null;
     labels: string;
+    thinkingOptionId: string | null;
+    noticeType: AgentProviderNotice["type"] | null;
+    notice: string | null;
 }
 /** Schema for update command output */
 export declare const updateSchema: OutputSchema<AgentUpdateResult>;
 export interface AgentUpdateOptions extends CommandOptions {
     name?: string;
     label?: string[];
+    thinking?: string;
     host?: string;
 }
 export type AgentUpdateCommandResult = SingleResult<AgentUpdateResult>;
+export interface AgentMetadataChanges {
+    name?: string;
+    labels?: Record<string, string>;
+}
+interface AgentUpdateServerInfo {
+    features?: {
+        agentThinkingUpdate?: boolean;
+    };
+}
+export interface AgentUpdateClient {
+    getLastServerInfoMessage(): AgentUpdateServerInfo | null;
+    updateAgent(agentId: string, updates: AgentMetadataChanges): Promise<void>;
+    setAgentThinkingOption(agentId: string, thinkingOptionId: string): Promise<AgentProviderNotice | null>;
+}
+export type AgentChanges = {
+    type: "metadata";
+    updates: AgentMetadataChanges;
+} | {
+    type: "thinking";
+    thinkingOptionId: string;
+};
+export interface AppliedAgentChanges {
+    notice: AgentProviderNotice | null;
+}
+export declare function toAgentUpdateResult(agent: Pick<AgentSnapshotPayload, "id" | "title" | "labels" | "effectiveThinkingOptionId">, appliedChanges: AppliedAgentChanges): AgentUpdateResult;
+export declare function applyAgentChanges(client: AgentUpdateClient, agentId: string, changes: AgentChanges): Promise<AppliedAgentChanges>;
 export declare function runUpdateCommand(agentIdArg: string, options: AgentUpdateOptions, _command: Command): Promise<AgentUpdateCommandResult>;
+export {};
 //# sourceMappingURL=update.d.ts.map

package/dist/commands/agent/update.js

@@ -6,8 +6,35 @@ export const updateSchema = {
         { header: "AGENT ID", field: "agentId" },
         { header: "NAME", field: "name" },
         { header: "LABELS", field: "labels" },
+        { header: "THINKING", field: "thinkingOptionId" },
+        { header: "NOTICE", field: "notice" },
     ],
 };
+export function toAgentUpdateResult(agent, appliedChanges) {
+    return {
+        agentId: agent.id,
+        name: agent.title,
+        labels: formatLabels(agent.labels),
+        thinkingOptionId: agent.effectiveThinkingOptionId ?? null,
+        noticeType: appliedChanges.notice?.type ?? null,
+        notice: appliedChanges.notice?.message ?? null,
+    };
+}
+export async function applyAgentChanges(client, agentId, changes) {
+    if (changes.type === "thinking") {
+        // COMPAT(agentThinkingUpdate): added in v0.2.4, remove gate after 2027-01-28.
+        if (client.getLastServerInfoMessage()?.features?.agentThinkingUpdate !== true) {
+            throw {
+                code: "DAEMON_UPDATE_REQUIRED",
+                message: "Update the host to use agent thinking updates.",
+            };
+        }
+        const notice = await client.setAgentThinkingOption(agentId, changes.thinkingOptionId);
+        return { notice };
+    }
+    await client.updateAgent(agentId, changes.updates);
+    return { notice: null };
+}
 function parseLabelOptions(labels) {
     const parsed = {};
     if (!labels) {
@@ -50,35 +77,62 @@ function formatLabels(labels) {
     }
     return entries.map(([key, value]) => `${key}=${value}`).join(",");
 }
-export async function runUpdateCommand(agentIdArg, options, _command) {
-    const host = getDaemonHost({ host: options.host });
-    // Validate arguments
-    if (!agentIdArg || agentIdArg.trim().length === 0) {
-        const error = {
-            code: "MISSING_AGENT_ID",
-            message: "Agent ID is required",
-            details: "Usage: paseo agent update <id> [--name <name>] [--label <key=value>]",
-        };
-        throw error;
-    }
+function parseAgentChanges(options) {
     const name = options.name?.trim();
     if (options.name !== undefined && !name) {
-        const error = {
+        throw {
             code: "INVALID_NAME",
             message: "Name cannot be empty",
             details: "Use --name <name> with a non-empty value",
         };
-        throw error;
     }
     const labels = parseLabelOptions(options.label);
-    if (!name && Object.keys(labels).length === 0) {
-        const error = {
+    const thinkingOptionId = options.thinking?.trim();
+    if (options.thinking !== undefined && !thinkingOptionId) {
+        throw {
+            code: "INVALID_THINKING_OPTION",
+            message: "--thinking cannot be empty",
+            details: 'Provide a thinking option ID. Use "paseo provider models <provider> --thinking" to list valid IDs.',
+        };
+    }
+    const hasMetadataUpdates = Boolean(name) || Object.keys(labels).length > 0;
+    if (hasMetadataUpdates && thinkingOptionId) {
+        throw {
+            code: "INVALID_OPTIONS",
+            message: "--thinking cannot be combined with --name or --label",
+            details: "Run separate agent update commands for runtime settings and metadata.",
+        };
+    }
+    if (!hasMetadataUpdates && !thinkingOptionId) {
+        throw {
             code: "NO_CHANGES_PROVIDED",
             message: "Nothing to update",
-            details: "Provide at least one of: --name <name>, --label <key=value>",
+            details: "Provide at least one of: --name <name>, --label <key=value>, --thinking <id>",
+        };
+    }
+    if (thinkingOptionId) {
+        return { type: "thinking", thinkingOptionId };
+    }
+    return {
+        type: "metadata",
+        updates: {
+            ...(name ? { name } : {}),
+            ...(Object.keys(labels).length > 0 ? { labels } : {}),
+        },
+    };
+}
+export async function runUpdateCommand(agentIdArg, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    // Validate arguments
+    if (!agentIdArg || agentIdArg.trim().length === 0) {
+        const error = {
+            code: "MISSING_AGENT_ID",
+            message: "Agent ID is required",
+            details: "Usage: paseo agent update <id> [--name <name>] [--label <key=value>]",
         };
         throw error;
     }
+    const changes = parseAgentChanges(options);
     let client;
     try {
         client = await connectToDaemon({ host: options.host });
@@ -103,10 +157,7 @@ export async function runUpdateCommand(agentIdArg, options, _command) {
             throw error;
         }
         const agentId = fetchResult.agent.id;
-        await client.updateAgent(agentId, {
-            ...(name ? { name } : {}),
-            ...(Object.keys(labels).length > 0 ? { labels } : {}),
-        });
+        const appliedChanges = await applyAgentChanges(client, agentId, changes);
         const updatedResult = await client.fetchAgent({ agentId });
         if (!updatedResult) {
             throw new Error(`Agent not found after update: ${agentId}`);
@@ -114,11 +165,7 @@ export async function runUpdateCommand(agentIdArg, options, _command) {
         await client.close();
         return {
             type: "single",
-            data: {
-                agentId,
-                name: updatedResult.agent.title,
-                labels: formatLabels(updatedResult.agent.labels),
-            },
+            data: toAgentUpdateResult(updatedResult.agent, appliedChanges),
             schema: updateSchema,
         };
     }

package/dist/commands/hub/cloud-device-authorization.d.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+declare const authorizationSchema: z.ZodObject<{
+    deviceCode: z.ZodString;
+    userCode: z.ZodString;
+    verificationUri: z.ZodURL;
+    verificationUriComplete: z.ZodURL;
+    expiresAt: z.ZodString;
+    interval: z.ZodNumber;
+}, z.core.$strip>;
+declare const pollSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"pending">;
+    interval: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"slow_down">;
+    interval: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"approved">;
+    interval: z.ZodNumber;
+    enrollmentToken: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"denied">;
+    interval: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"expired">;
+    interval: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"enrolled">;
+    interval: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"retry_later">;
+}, z.core.$strip>], "status">;
+export type DeviceAuthorization = z.infer<typeof authorizationSchema>;
+export type DeviceAuthorizationPoll = z.infer<typeof pollSchema>;
+export interface CloudDeviceAuthorization {
+    start(hubUrl: string, displayName: string): Promise<DeviceAuthorization>;
+    poll(hubUrl: string, deviceCode: string, timeoutMilliseconds: number): Promise<DeviceAuthorizationPoll>;
+}
+export declare class CloudDeviceAuthorizationClient implements CloudDeviceAuthorization {
+    private readonly startTimeoutMilliseconds;
+    constructor(startTimeoutMilliseconds?: number);
+    start(hubUrl: string, displayName: string): Promise<DeviceAuthorization>;
+    poll(hubUrl: string, deviceCode: string, timeoutMilliseconds: number): Promise<DeviceAuthorizationPoll>;
+}
+export {};
+//# sourceMappingURL=cloud-device-authorization.d.ts.map

package/dist/commands/hub/cloud-device-authorization.js

@@ -0,0 +1,92 @@
+import { z } from "zod";
+const START_TIMEOUT_MS = 15000;
+const activationUrlSchema = z.url({ protocol: /^https?$/u });
+const authorizationSchema = z.object({
+    deviceCode: z.string().min(32),
+    userCode: z.string().min(1),
+    verificationUri: activationUrlSchema,
+    verificationUriComplete: activationUrlSchema,
+    expiresAt: z.string().datetime(),
+    interval: z.number().int().min(5),
+});
+const pollSchema = z.discriminatedUnion("status", [
+    z.object({ status: z.literal("pending"), interval: z.number().int().min(5) }),
+    z.object({ status: z.literal("slow_down"), interval: z.number().int().min(5) }),
+    z.object({
+        status: z.literal("approved"),
+        interval: z.number().int().min(5),
+        enrollmentToken: z.string().min(32),
+    }),
+    z.object({ status: z.literal("denied"), interval: z.number().int().min(5) }),
+    z.object({ status: z.literal("expired"), interval: z.number().int().min(5) }),
+    z.object({ status: z.literal("enrolled"), interval: z.number().int().min(5) }),
+    z.object({ status: z.literal("retry_later") }),
+]);
+export class CloudDeviceAuthorizationClient {
+    constructor(startTimeoutMilliseconds = START_TIMEOUT_MS) {
+        this.startTimeoutMilliseconds = startTimeoutMilliseconds;
+    }
+    async start(hubUrl, displayName) {
+        const signal = AbortSignal.timeout(this.startTimeoutMilliseconds);
+        try {
+            const response = await fetch(endpoint(hubUrl, "/api/device-authorizations/"), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ displayName }),
+                signal,
+            });
+            if (!response.ok)
+                throw new Error(`Cloud registration failed (${response.status})`);
+            return authorizationSchema.parse(await response.json());
+        }
+        catch (error) {
+            if (signal.aborted) {
+                throw new Error("Cloud registration start timed out", { cause: error });
+            }
+            throw error;
+        }
+    }
+    async poll(hubUrl, deviceCode, timeoutMilliseconds) {
+        const signal = AbortSignal.timeout(timeoutMilliseconds);
+        let response;
+        try {
+            response = await fetch(endpoint(hubUrl, "/api/device-authorizations/poll"), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ deviceCode }),
+                signal,
+            });
+        }
+        catch {
+            return { status: "retry_later" };
+        }
+        if ([408, 425, 429].includes(response.status) || response.status >= 500) {
+            return { status: "retry_later" };
+        }
+        if (!response.ok)
+            throw new Error(`Cloud registration poll failed (${response.status})`);
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch (error) {
+            if (signal.aborted || error instanceof TypeError)
+                return { status: "retry_later" };
+            throw error;
+        }
+        return pollSchema.parse(body);
+    }
+}
+function endpoint(hubUrl, pathname) {
+    const url = new URL(hubUrl);
+    if (!["http:", "https:"].includes(url.protocol) ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash) {
+        throw new Error("Hub URL must be an HTTP or HTTPS origin without credentials or a query");
+    }
+    url.pathname = `${url.pathname.replace(/\/$/u, "")}${pathname}`;
+    return url.toString();
+}
+//# sourceMappingURL=cloud-device-authorization.js.map

package/dist/commands/hub/device-authorization.d.ts

@@ -0,0 +1,37 @@
+import { type CloudDeviceAuthorization } from "./cloud-device-authorization.js";
+export interface AuthorizationWaiter {
+    wait(milliseconds: number): Promise<void>;
+    now(): number;
+}
+export interface BrowserOpener {
+    open(url: string): Promise<void>;
+}
+type BrowserLaunch = (command: string, args: string[]) => Promise<void>;
+interface SystemBrowserOptions {
+    hostPlatform?: NodeJS.Platform;
+    launch?: BrowserLaunch;
+}
+export declare class SystemBrowser implements BrowserOpener {
+    private readonly hostPlatform;
+    private readonly launch;
+    constructor(options?: SystemBrowserOptions);
+    open(url: string): Promise<void>;
+}
+export interface AuthorizationReporter {
+    instructions(verificationUri: string, userCode: string): void;
+}
+interface DeviceAuthorizationWorkflowOptions {
+    cloud: CloudDeviceAuthorization;
+    waiter: AuthorizationWaiter;
+    browser: BrowserOpener;
+    reporter: AuthorizationReporter;
+    openBrowser?: boolean;
+}
+export declare class DeviceAuthorizationWorkflow {
+    private readonly options;
+    constructor(options: DeviceAuthorizationWorkflowOptions);
+    authorize(hubUrl: string, displayName: string): Promise<string>;
+}
+export declare function createDeviceAuthorizationWorkflow(): DeviceAuthorizationWorkflow;
+export {};
+//# sourceMappingURL=device-authorization.d.ts.map

package/dist/commands/hub/device-authorization.js

@@ -0,0 +1,87 @@
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+import { CloudDeviceAuthorizationClient, } from "./cloud-device-authorization.js";
+export class SystemBrowser {
+    constructor(options = {}) {
+        this.hostPlatform = options.hostPlatform ?? platform();
+        this.launch = options.launch ?? launchDetached;
+    }
+    async open(url) {
+        if (this.hostPlatform === "win32") {
+            await this.launch("rundll32.exe", ["url.dll,FileProtocolHandler", url]);
+            return;
+        }
+        await this.launch(this.hostPlatform === "darwin" ? "open" : "xdg-open", [url]);
+    }
+}
+export class DeviceAuthorizationWorkflow {
+    constructor(options) {
+        this.options = options;
+    }
+    async authorize(hubUrl, displayName) {
+        const authorization = await this.options.cloud.start(hubUrl, displayName);
+        this.options.reporter.instructions(authorization.verificationUri, authorization.userCode);
+        if (this.options.openBrowser !== false) {
+            await this.options.browser.open(authorization.verificationUriComplete).catch(() => undefined);
+        }
+        let interval = authorization.interval;
+        const expiresAt = Date.parse(authorization.expiresAt);
+        while (true) {
+            const remaining = expiresAt - this.options.waiter.now();
+            if (remaining <= 0)
+                throw new Error("Daemon registration expired");
+            await this.options.waiter.wait(Math.min(interval * 1000, remaining));
+            if (this.options.waiter.now() >= expiresAt)
+                throw new Error("Daemon registration expired");
+            const pollLifetime = expiresAt - this.options.waiter.now();
+            if (pollLifetime <= 0)
+                throw new Error("Daemon registration expired");
+            const outcome = await this.options.cloud.poll(hubUrl, authorization.deviceCode, pollLifetime);
+            if (this.options.waiter.now() >= expiresAt)
+                throw new Error("Daemon registration expired");
+            if (outcome.status === "retry_later")
+                continue;
+            interval = outcome.interval;
+            if (outcome.status === "approved")
+                return outcome.enrollmentToken;
+            if (outcome.status === "denied")
+                throw new Error("Daemon registration was denied");
+            if (outcome.status === "expired")
+                throw new Error("Daemon registration expired");
+            if (outcome.status === "enrolled") {
+                throw new Error("Daemon registration was already used");
+            }
+        }
+    }
+}
+export function createDeviceAuthorizationWorkflow() {
+    return new DeviceAuthorizationWorkflow({
+        cloud: new CloudDeviceAuthorizationClient(),
+        waiter: {
+            wait: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+            now: Date.now,
+        },
+        browser: new SystemBrowser(),
+        reporter: {
+            instructions(verificationUri, userCode) {
+                process.stderr.write(`Open ${verificationUri} and enter code ${userCode}\n`);
+            },
+        },
+        openBrowser: process.stderr.isTTY === true,
+    });
+}
+async function launchDetached(command, args) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            detached: true,
+            shell: false,
+            stdio: "ignore",
+        });
+        child.once("spawn", () => {
+            child.unref();
+            resolve();
+        });
+        child.once("error", reject);
+    });
+}
+//# sourceMappingURL=device-authorization.js.map

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

@@ -1,3 +1,30 @@
 import { Command } from "commander";
-export declare function createHubCommand(): Command;
+interface HubCommandClient {
+    connectHub(url: string, token: string): Promise<{
+        status: HubStatus;
+    }>;
+    getHubStatus(): Promise<{
+        status: HubStatus;
+    }>;
+    disconnectHub(force: boolean): Promise<{
+        status: HubStatus;
+        warning?: string;
+    }>;
+    close(): Promise<void>;
+}
+interface HubStatus {
+    state: string;
+    daemonId: string | null;
+    hubOrigin: string | null;
+    scopes: string[];
+    connectedAt: string | null;
+    lastError: string | null;
+}
+interface HubCommandEnvironment {
+    connect(host: string | undefined): Promise<HubCommandClient>;
+    authorize(url: string, displayName: string): Promise<string>;
+    displayName(): string;
+}
+export declare function createHubCommand(environment?: HubCommandEnvironment): Command;
+export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/commands/hub/index.js

@@ -1,7 +1,14 @@
 import { Command } from "commander";
+import { hostname } from "node:os";
 import { withOutput } from "../../output/index.js";
 import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
 import { connectToDaemon } from "../../utils/client.js";
+import { createDeviceAuthorizationWorkflow } from "./device-authorization.js";
+const productionEnvironment = {
+    connect: (host) => connectToDaemon({ host }),
+    authorize: (url, displayName) => createDeviceAuthorizationWorkflow().authorize(url, displayName),
+    displayName: hostname,
+};
 const schema = {
     idField: "state",
     columns: [
@@ -31,8 +38,8 @@ function result(status, warning) {
         schema,
     };
 }
-async function withClient(host, action) {
-    const client = await connectToDaemon({ host });
+async function withClient(environment, host, action) {
+    const client = await environment.connect(host);
     try {
         return await action(client);
     }
@@ -40,26 +47,39 @@ async function withClient(host, action) {
         await client.close().catch(() => undefined);
     }
 }
-export function createHubCommand() {
+export function createHubCommand(environment = productionEnvironment) {
     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) => {
+    addJsonAndDaemonHostOptions(hub.command("connect").argument("<url>").option("--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));
+        return withClient(environment, options.host, async (client) => {
+            if (options.token !== undefined) {
+                return result((await client.connectHub(url, options.token)).status);
+            }
+            const existing = (await client.getHubStatus()).status;
+            if (existing.state !== "not_connected" && existing.state !== "revoked") {
+                throw new Error("This daemon already has a Hub relationship");
+            }
+            const token = await environment.authorize(url, suggestedDisplayName(environment.displayName()));
+            return result((await client.connectHub(url, 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));
+        return withClient(environment, 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) => {
+        return withClient(environment, options.host, async (client) => {
             const response = await client.disconnectHub(options.force ?? false);
             return result(response.status, response.warning);
         });
     }));
     return hub;
 }
+function suggestedDisplayName(value) {
+    return value.trim().slice(0, 100) || "Paseo daemon";
+}
 //# sourceMappingURL=index.js.map

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

@@ -9,6 +9,7 @@ export interface ScheduleCreateOptions extends ScheduleCommandOptions {
     target?: string;
     provider?: string;
     mode?: string;
+    thinking?: string;
     cwd?: string;
     maxRuns?: string;
     expiresIn?: string;

package/dist/commands/schedule/create.js

@@ -12,6 +12,7 @@ export async function runCreateCommand(prompt, options, command) {
         target: options.target,
         provider: options.provider,
         mode: options.mode,
+        thinking: options.thinking,
         cwd: options.cwd,
         host: options.host,
         maxRuns: options.maxRuns,

package/dist/commands/schedule/index.js

@@ -23,6 +23,7 @@ export function createScheduleCommand() {
         .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("--thinking <id>", "Thinking option ID for new-agent runs")
         .option("--cwd <path>", "Working directory (default: current; required with --host)")
         .option("--run-now", "Fire one immediate run on creation")
         .option("--max-runs <n>", "Maximum number of runs")

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

@@ -21,6 +21,7 @@ export declare function parseScheduleCreateInput(options: {
     target?: string;
     provider?: string;
     mode?: string;
+    thinking?: string;
     cwd?: string;
     host?: string;
     maxRuns?: string;

package/dist/commands/schedule/shared.js

@@ -82,7 +82,7 @@ function resolveScheduleTarget(args) {
     if (hasExplicitNewAgentOption) {
         throw {
             code: "INVALID_TARGET",
-            message: "--provider/--mode can only be used with a new-agent target",
+            message: "--provider/--mode/--thinking can only be used with a new-agent target",
             details: "Use --target new-agent or omit --target to create a new agent schedule",
         };
     }
@@ -125,7 +125,14 @@ export function parseScheduleCreateInput(options) {
     const runOnCreate = resolveRunOnCreate(options.runNow, cadence.type);
     const targetValue = options.target?.trim();
     const modeId = options.mode?.trim();
-    const hasExplicitNewAgentOption = options.provider !== undefined || options.mode !== undefined;
+    const thinkingOptionId = options.thinking?.trim();
+    if (options.thinking !== undefined && !thinkingOptionId) {
+        throw {
+            code: "INVALID_THINKING_OPTION",
+            message: "--thinking cannot be empty",
+        };
+    }
+    const hasExplicitNewAgentOption = options.provider !== undefined || options.mode !== undefined || options.thinking !== undefined;
     const createNewAgentTarget = () => {
         const resolvedProviderModel = resolveProviderAndModel({
             provider: options.provider,
@@ -137,6 +144,7 @@ export function parseScheduleCreateInput(options) {
                 cwd: cwdInput ?? process.cwd(),
                 ...(resolvedProviderModel.model ? { model: resolvedProviderModel.model } : {}),
                 ...(modeId ? { modeId } : {}),
+                ...(thinkingOptionId ? { thinkingOptionId } : {}),
             },
         };
     };

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

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

package/dist/commands/script/index.js

@@ -0,0 +1,19 @@
+import { Command } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { runLsCommand } from "./ls.js";
+import { runStartCommand } from "./start.js";
+import { runStopCommand } from "./stop.js";
+function addWorkspaceSelectionOptions(command) {
+    return command
+        .option("--cwd <path>", "Workspace directory (default: current directory)")
+        .option("--workspace <workspace-id>", "Workspace ID (required when a directory has multiple workspaces)");
+}
+export function createScriptCommand() {
+    const script = new Command("script").description("Manage configured workspace scripts");
+    addJsonAndDaemonHostOptions(addWorkspaceSelectionOptions(script.command("ls").description("List configured workspace scripts"))).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(addWorkspaceSelectionOptions(script.command("start").description("Start a configured workspace script").argument("<name>"))).action(withOutput(runStartCommand));
+    addJsonAndDaemonHostOptions(addWorkspaceSelectionOptions(script.command("stop").description("Stop a running workspace script").argument("<name>"))).action(withOutput(runStopCommand));
+    return script;
+}
+//# sourceMappingURL=index.js.map

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

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

package/dist/commands/script/ls.js

@@ -0,0 +1,20 @@
+import { connectWorkspaceScriptClient, resolveWorkspaceScriptWorkspaceId, toWorkspaceScriptCommandError, } from "./shared.js";
+import { workspaceScriptSchema } from "./schema.js";
+export async function runLsCommand(options, _command) {
+    const client = await connectWorkspaceScriptClient(options.host);
+    try {
+        const workspaceId = await resolveWorkspaceScriptWorkspaceId(client, options);
+        const payload = await client.listWorkspaceScripts(workspaceId);
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return { type: "list", data: payload.scripts ?? [], schema: workspaceScriptSchema };
+    }
+    catch (error) {
+        throw toWorkspaceScriptCommandError("WORKSPACE_SCRIPT_LIST_FAILED", "list workspace scripts", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=ls.js.map

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

@@ -0,0 +1,5 @@
+import type { WorkspaceScriptPayload } from "@getpaseo/protocol/messages";
+import type { OutputSchema } from "../../output/index.js";
+export type WorkspaceScriptRow = WorkspaceScriptPayload;
+export declare const workspaceScriptSchema: OutputSchema<WorkspaceScriptRow>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/commands/script/schema.js

@@ -0,0 +1,13 @@
+export const workspaceScriptSchema = {
+    idField: "scriptName",
+    columns: [
+        { header: "NAME", field: "scriptName", width: 20 },
+        { header: "TYPE", field: "type", width: 9 },
+        { header: "LIFECYCLE", field: "lifecycle", width: 10 },
+        { header: "HEALTH", field: (script) => script.health ?? "-", width: 10 },
+        { header: "PORT", field: (script) => script.port ?? "-", width: 7 },
+        { header: "PROXY URL", field: (script) => script.proxyUrl ?? "-", width: 42 },
+        { header: "TERMINAL", field: (script) => script.terminalId ?? "-", width: 12 },
+    ],
+};
+//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1,11 @@
+import type { DaemonClient } from "@getpaseo/client/internal/daemon-client";
+import type { CommandError, CommandOptions } from "../../output/index.js";
+export interface WorkspaceScriptCommandOptions extends CommandOptions {
+    host?: string;
+    cwd?: string;
+    workspace?: string;
+}
+export declare function connectWorkspaceScriptClient(host?: string): Promise<DaemonClient>;
+export declare function resolveWorkspaceScriptWorkspaceId(client: DaemonClient, options: WorkspaceScriptCommandOptions): Promise<string>;
+export declare function toWorkspaceScriptCommandError(code: string, action: string, error: unknown): CommandError;
+//# sourceMappingURL=shared.d.ts.map

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/cli",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Paseo CLI - control your AI coding agents from the command line",
   "bin": {
     "paseo": "bin/paseo"
@@ -20,22 +20,24 @@
     "build:clean": "npm run clean && npm run build",
     "prepack": "npm run build:clean",
     "typecheck": "tsgo --noEmit",
-    "test": "npm run test:local",
+    "test": "npm run test:unit && npm run test:local",
+    "test:unit": "vitest run src",
     "test:local": "tsx tests/run-all.ts",
     "test:e2e": "npm run test:local",
     "test:e2e:lifecycle": "npx tsx tests/e2e/agent-lifecycle.test.ts"
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@getpaseo/client": "0.2.2",
-    "@getpaseo/protocol": "0.2.2",
-    "@getpaseo/server": "0.2.2",
+    "@getpaseo/client": "0.2.4",
+    "@getpaseo/protocol": "0.2.4",
+    "@getpaseo/server": "0.2.4",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",
     "tree-kill": "^1.2.2",
     "ws": "^8.14.2",
-    "yaml": "^2.8.4"
+    "yaml": "^2.8.4",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@types/mime-types": "^3.0.1",