@camerontaylor/paseo-cli 0.11.2-fork.2 → 0.12.0-fork.1

package/dist/commands/permit/allow.js

@@ -30,95 +30,109 @@ export function toPermissionResponseItem(agentId, permission, result) {
         result,
     };
 }
-export async function runAllowCommand(agentIdOrPrefix, reqId, options, _command) {
-    // No validation needed - if no reqId provided, allow all by default
-    // Parse input JSON if provided
-    let updatedInput;
-    if (options.input) {
-        try {
-            updatedInput = JSON.parse(options.input);
-        }
-        catch (err) {
-            const error = {
-                code: "INVALID_JSON",
-                message: `Invalid JSON for --input: ${err instanceof Error ? err.message : String(err)}`,
-                details: 'Provide valid JSON, e.g., --input \'{"key": "value"}\'',
-            };
-            throw error;
-        }
-    }
-    const client = await connectToDaemon({ target: options.daemonTarget });
-    try {
-        const fetchResult = await client.fetchAgent({ agentId: agentIdOrPrefix });
-        if (!fetchResult) {
-            await client.close();
-            const error = {
-                code: "AGENT_NOT_FOUND",
-                message: `Agent not found: ${agentIdOrPrefix}`,
-                details: 'Use "paseo ls" to list available agents',
-            };
-            throw error;
-        }
-        const agent = fetchResult.agent;
-        const resolvedAgentId = agent.id;
-        // Get pending permissions for this agent
-        const pendingPermissions = agent.pendingPermissions || [];
-        if (pendingPermissions.length === 0) {
-            await client.close();
-            const error = {
-                code: "NO_PENDING_PERMISSIONS",
-                message: `No pending permissions for agent ${agent.id.slice(0, 7)}`,
-            };
-            throw error;
-        }
-        // Determine which permissions to allow
-        let permissionsToAllow;
-        if (!reqId || options.all) {
-            // Default: allow all pending permissions if no req_id specified
-            // --all flag is kept as an explicit alias for clarity
-            permissionsToAllow = pendingPermissions;
+export function createAllowCommand(connect = connectToDaemon) {
+    return async function runAllowCommand(agentIdOrPrefix, reqId, options, _command) {
+        // No validation needed - if no reqId provided, allow all by default
+        // Parse input JSON if provided
+        let updatedInput;
+        if (options.input) {
+            try {
+                updatedInput = JSON.parse(options.input);
+            }
+            catch (err) {
+                const error = {
+                    code: "INVALID_JSON",
+                    message: `Invalid JSON for --input: ${err instanceof Error ? err.message : String(err)}`,
+                    details: 'Provide valid JSON, e.g., --input \'{"key": "value"}\'',
+                };
+                throw error;
+            }
         }
-        else {
-            // Find permission by ID prefix
-            const permission = pendingPermissions.find((p) => p.id === reqId || p.id.startsWith(reqId));
-            if (!permission) {
+        const client = await connect({ target: options.daemonTarget });
+        try {
+            const fetchResult = await client.fetchAgent({ agentId: agentIdOrPrefix });
+            if (!fetchResult) {
+                await client.close();
+                const error = {
+                    code: "AGENT_NOT_FOUND",
+                    message: `Agent not found: ${agentIdOrPrefix}`,
+                    details: 'Use "paseo ls" to list available agents',
+                };
+                throw error;
+            }
+            const agent = fetchResult.agent;
+            const resolvedAgentId = agent.id;
+            // Get pending permissions for this agent
+            const pendingPermissions = agent.pendingPermissions || [];
+            if (pendingPermissions.length === 0) {
                 await client.close();
                 const error = {
-                    code: "PERMISSION_NOT_FOUND",
-                    message: `Permission request not found: ${reqId}`,
-                    details: `Available requests: ${pendingPermissions.map((p) => p.id.slice(0, 8)).join(", ")}`,
+                    code: "NO_PENDING_PERMISSIONS",
+                    message: `No pending permissions for agent ${agent.id.slice(0, 7)}`,
                 };
                 throw error;
             }
-            permissionsToAllow = [permission];
+            // Determine which permissions to allow
+            let permissionsToAllow;
+            if (!reqId || options.all) {
+                // Default: allow all pending permissions if no req_id specified
+                // --all flag is kept as an explicit alias for clarity
+                permissionsToAllow = pendingPermissions;
+            }
+            else {
+                // Find permission by ID prefix
+                const permission = pendingPermissions.find((p) => p.id === reqId || p.id.startsWith(reqId));
+                if (!permission) {
+                    await client.close();
+                    const error = {
+                        code: "PERMISSION_NOT_FOUND",
+                        message: `Permission request not found: ${reqId}`,
+                        details: `Available requests: ${pendingPermissions.map((p) => p.id.slice(0, 8)).join(", ")}`,
+                    };
+                    throw error;
+                }
+                permissionsToAllow = [permission];
+            }
+            // Allow permissions
+            const results = await Promise.all(permissionsToAllow.map(async (permission) => {
+                try {
+                    await client.respondToPermissionAndWait(resolvedAgentId, permission.id, {
+                        behavior: "allow",
+                        ...(updatedInput ? { updatedInput } : {}),
+                    });
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    const error = {
+                        code: "PERMISSION_RESPONSE_UNCONFIRMED",
+                        message: `Permission response unconfirmed for request ${permission.id}: ${message}`,
+                        details: 'Use "paseo permit ls" to check whether the request is still pending',
+                    };
+                    throw error;
+                }
+                return toPermissionResponseItem(resolvedAgentId, permission, "allowed");
+            }));
+            await client.close();
+            return {
+                type: "list",
+                data: results,
+                schema: permitResponseSchema,
+            };
         }
-        // Allow permissions
-        const results = await Promise.all(permissionsToAllow.map(async (permission) => {
-            await client.respondToPermission(resolvedAgentId, permission.id, {
-                behavior: "allow",
-                ...(updatedInput ? { updatedInput } : {}),
-            });
-            return toPermissionResponseItem(resolvedAgentId, permission, "allowed");
-        }));
-        await client.close();
-        return {
-            type: "list",
-            data: results,
-            schema: permitResponseSchema,
-        };
-    }
-    catch (err) {
-        await client.close().catch(() => { });
-        // Re-throw CommandErrors
-        if (err && typeof err === "object" && "code" in err) {
-            throw err;
+        catch (err) {
+            await client.close().catch(() => { });
+            // Re-throw CommandErrors
+            if (err && typeof err === "object" && "code" in err) {
+                throw err;
+            }
+            const message = err instanceof Error ? err.message : String(err);
+            const error = {
+                code: "ALLOW_PERMISSION_FAILED",
+                message: `Failed to allow permission: ${message}`,
+            };
+            throw error;
         }
-        const message = err instanceof Error ? err.message : String(err);
-        const error = {
-            code: "ALLOW_PERMISSION_FAILED",
-            message: `Failed to allow permission: ${message}`,
-        };
-        throw error;
-    }
+    };
 }
+export const runAllowCommand = createAllowCommand();
 //# sourceMappingURL=allow.js.map

package/dist/commands/permit/deny.d.ts

@@ -1,6 +1,6 @@
 import type { Command } from "commander";
 import type { CommandOptions, ListResult } from "../../output/index.js";
-import { type PermissionResponseItem } from "./allow.js";
+import { type PermissionResponseItem, type PermitClientConnector } from "./allow.js";
 export type PermitDenyResult = ListResult<PermissionResponseItem>;
 export interface PermitDenyOptions extends CommandOptions {
     all?: boolean;
@@ -8,5 +8,6 @@ export interface PermitDenyOptions extends CommandOptions {
     interrupt?: boolean;
     host?: string;
 }
-export declare function runDenyCommand(agentIdOrPrefix: string, reqId: string | undefined, options: PermitDenyOptions, _command: Command): Promise<PermitDenyResult>;
+export declare function createDenyCommand(connect?: PermitClientConnector): (agentIdOrPrefix: string, reqId: string | undefined, options: PermitDenyOptions, _command: Command) => Promise<PermitDenyResult>;
+export declare const runDenyCommand: (agentIdOrPrefix: string, reqId: string | undefined, options: PermitDenyOptions, _command: Command) => Promise<PermitDenyResult>;
 //# sourceMappingURL=deny.d.ts.map

package/dist/commands/permit/deny.js

@@ -1,86 +1,100 @@
 import { connectToDaemon } from "../../utils/client.js";
 import { permitResponseSchema, toPermissionResponseItem, } from "./allow.js";
-export async function runDenyCommand(agentIdOrPrefix, reqId, options, _command) {
-    // Validate arguments
-    if (!options.all && !reqId) {
-        const error = {
-            code: "MISSING_ARGUMENT",
-            message: "Request ID is required unless --all is specified",
-            details: "Usage: paseo permit deny <agent> <req_id> or paseo permit deny <agent> --all",
-        };
-        throw error;
-    }
-    const client = await connectToDaemon({ target: options.daemonTarget });
-    try {
-        const fetchResult = await client.fetchAgent({ agentId: agentIdOrPrefix });
-        if (!fetchResult) {
-            await client.close();
-            const error = {
-                code: "AGENT_NOT_FOUND",
-                message: `Agent not found: ${agentIdOrPrefix}`,
-                details: 'Use "paseo ls" to list available agents',
-            };
-            throw error;
-        }
-        const agent = fetchResult.agent;
-        const resolvedAgentId = agent.id;
-        // Get pending permissions for this agent
-        const pendingPermissions = agent.pendingPermissions || [];
-        if (pendingPermissions.length === 0) {
-            await client.close();
+export function createDenyCommand(connect = connectToDaemon) {
+    return async function runDenyCommand(agentIdOrPrefix, reqId, options, _command) {
+        // Validate arguments
+        if (!options.all && !reqId) {
             const error = {
-                code: "NO_PENDING_PERMISSIONS",
-                message: `No pending permissions for agent ${agent.id.slice(0, 7)}`,
+                code: "MISSING_ARGUMENT",
+                message: "Request ID is required unless --all is specified",
+                details: "Usage: paseo permit deny <agent> <req_id> or paseo permit deny <agent> --all",
             };
             throw error;
         }
-        // Determine which permissions to deny
-        let permissionsToDeny;
-        if (options.all) {
-            permissionsToDeny = pendingPermissions;
-        }
-        else {
-            // Find permission by ID prefix
-            const permission = pendingPermissions.find((p) => p.id === reqId || p.id.startsWith(reqId));
-            if (!permission) {
+        const client = await connect({ target: options.daemonTarget });
+        try {
+            const fetchResult = await client.fetchAgent({ agentId: agentIdOrPrefix });
+            if (!fetchResult) {
+                await client.close();
+                const error = {
+                    code: "AGENT_NOT_FOUND",
+                    message: `Agent not found: ${agentIdOrPrefix}`,
+                    details: 'Use "paseo ls" to list available agents',
+                };
+                throw error;
+            }
+            const agent = fetchResult.agent;
+            const resolvedAgentId = agent.id;
+            // Get pending permissions for this agent
+            const pendingPermissions = agent.pendingPermissions || [];
+            if (pendingPermissions.length === 0) {
                 await client.close();
                 const error = {
-                    code: "PERMISSION_NOT_FOUND",
-                    message: `Permission request not found: ${reqId}`,
-                    details: `Available requests: ${pendingPermissions.map((p) => p.id.slice(0, 8)).join(", ")}`,
+                    code: "NO_PENDING_PERMISSIONS",
+                    message: `No pending permissions for agent ${agent.id.slice(0, 7)}`,
                 };
                 throw error;
             }
-            permissionsToDeny = [permission];
+            // Determine which permissions to deny
+            let permissionsToDeny;
+            if (options.all) {
+                permissionsToDeny = pendingPermissions;
+            }
+            else {
+                // Find permission by ID prefix
+                const permission = pendingPermissions.find((p) => p.id === reqId || p.id.startsWith(reqId));
+                if (!permission) {
+                    await client.close();
+                    const error = {
+                        code: "PERMISSION_NOT_FOUND",
+                        message: `Permission request not found: ${reqId}`,
+                        details: `Available requests: ${pendingPermissions.map((p) => p.id.slice(0, 8)).join(", ")}`,
+                    };
+                    throw error;
+                }
+                permissionsToDeny = [permission];
+            }
+            // Deny permissions
+            const results = await Promise.all(permissionsToDeny.map(async (permission) => {
+                try {
+                    await client.respondToPermissionAndWait(resolvedAgentId, permission.id, {
+                        behavior: "deny",
+                        ...(options.message ? { message: options.message } : {}),
+                        ...(options.interrupt ? { interrupt: true } : {}),
+                    });
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    const error = {
+                        code: "PERMISSION_RESPONSE_UNCONFIRMED",
+                        message: `Permission response unconfirmed for request ${permission.id}: ${message}`,
+                        details: 'Use "paseo permit ls" to check whether the request is still pending',
+                    };
+                    throw error;
+                }
+                return toPermissionResponseItem(resolvedAgentId, permission, "denied");
+            }));
+            await client.close();
+            return {
+                type: "list",
+                data: results,
+                schema: permitResponseSchema,
+            };
         }
-        // Deny permissions
-        const results = await Promise.all(permissionsToDeny.map(async (permission) => {
-            await client.respondToPermission(resolvedAgentId, permission.id, {
-                behavior: "deny",
-                ...(options.message ? { message: options.message } : {}),
-                ...(options.interrupt ? { interrupt: true } : {}),
-            });
-            return toPermissionResponseItem(resolvedAgentId, permission, "denied");
-        }));
-        await client.close();
-        return {
-            type: "list",
-            data: results,
-            schema: permitResponseSchema,
-        };
-    }
-    catch (err) {
-        await client.close().catch(() => { });
-        // Re-throw CommandErrors
-        if (err && typeof err === "object" && "code" in err) {
-            throw err;
+        catch (err) {
+            await client.close().catch(() => { });
+            // Re-throw CommandErrors
+            if (err && typeof err === "object" && "code" in err) {
+                throw err;
+            }
+            const message = err instanceof Error ? err.message : String(err);
+            const error = {
+                code: "DENY_PERMISSION_FAILED",
+                message: `Failed to deny permission: ${message}`,
+            };
+            throw error;
         }
-        const message = err instanceof Error ? err.message : String(err);
-        const error = {
-            code: "DENY_PERMISSION_FAILED",
-            message: `Failed to deny permission: ${message}`,
-        };
-        throw error;
-    }
+    };
 }
+export const runDenyCommand = createDenyCommand();
 //# sourceMappingURL=deny.js.map

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

@@ -0,0 +1,29 @@
+import { Command } from "commander";
+import type { DaemonClient } from "@camerontaylor/paseo-client/internal/daemon-client";
+import type { UsageReportEntry } from "@camerontaylor/paseo-protocol/messages";
+import { type ConnectOptions } from "../../utils/client.js";
+import { type CommandOptions, type CommandResult } from "../../output/index.js";
+interface UsageOptions extends CommandOptions {
+    agent?: string;
+    refresh?: boolean;
+}
+type UsageSelection = {
+    kind: "list";
+} | {
+    kind: "inspect";
+    id: string;
+};
+interface UsageClient {
+    getLastServerInfoMessage(): {
+        features?: {
+            usageSources?: boolean;
+        };
+    } | null;
+    listUsageReports: DaemonClient["listUsageReports"];
+    close: DaemonClient["close"];
+}
+type ConnectUsage = (options: ConnectOptions) => Promise<UsageClient>;
+export declare function runUsageCommand(options: UsageOptions, selection: UsageSelection, connect?: ConnectUsage): Promise<CommandResult<UsageReportEntry>>;
+export declare function createUsageCommand(): Command;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/usage/index.js

@@ -0,0 +1,62 @@
+import { Command } from "commander";
+import { connectToDaemon } from "../../utils/client.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { withOutput } from "../../output/index.js";
+import { usageSchema } from "./presentation.js";
+export async function runUsageCommand(options, selection, connect = connectToDaemon) {
+    const conflictingSelectors = selection.kind === "inspect" && options.agent !== undefined;
+    if (conflictingSelectors) {
+        throw {
+            code: "INVALID_OPTIONS",
+            message: "--agent cannot be combined with usage inspect. Use usage ls --agent <id> for agent account usage, or usage inspect <report-id> for an exact report.",
+        };
+    }
+    const client = await connect({ target: options.daemonTarget });
+    try {
+        if (client.getLastServerInfoMessage()?.features?.usageSources !== true) {
+            throw { code: "UNSUPPORTED_HOST", message: "Update the host to use usage reports." };
+        }
+        if (selection.kind === "list") {
+            const { reports } = await client.listUsageReports({
+                agentId: options.agent,
+                forceRefresh: options.refresh,
+            });
+            return { type: "list", data: reports, schema: usageSchema };
+        }
+        // Report-ID queries only select known accounts. Discover before selecting, including on cold hosts.
+        const { reports } = await client.listUsageReports();
+        let entry = reports.find((report) => report.id === selection.id);
+        if (entry && options.refresh) {
+            const refreshed = await client.listUsageReports({
+                reportIds: [selection.id],
+                forceRefresh: true,
+            });
+            entry = refreshed.reports.find((report) => report.id === selection.id);
+        }
+        if (!entry) {
+            throw { code: "REPORT_NOT_FOUND", message: `Unknown usage report: ${selection.id}` };
+        }
+        return { type: "single", data: entry, schema: usageSchema };
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+function addListOptions(command) {
+    return addJsonAndDaemonHostOptions(command)
+        .option("--agent <id>", "Show account quota associated with this agent (not agent token consumption)")
+        .option("--refresh", "Refresh usage instead of using the host cache");
+}
+export function createUsageCommand() {
+    const usage = addListOptions(new Command("usage").description("Show account usage reports"));
+    const list = (options, _command) => runUsageCommand(options, { kind: "list" });
+    usage.action(withOutput(list));
+    addListOptions(usage.command("ls").description("List account quotas and balances")).action(withOutput(list));
+    addJsonAndDaemonHostOptions(usage
+        .command("inspect")
+        .description("Show a complete account usage report")
+        .argument("<report-id>", "Exact opaque Report ID")
+        .option("--refresh", "Refresh the selected report instead of using the host cache")).action(withOutput((id, options, _command) => runUsageCommand(options, { kind: "inspect", id })));
+    return usage;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/usage/presentation.d.ts

@@ -0,0 +1,4 @@
+import type { UsageReportEntry } from "@camerontaylor/paseo-protocol/messages";
+import { type OutputSchema } from "../../output/index.js";
+export declare const usageSchema: OutputSchema<UsageReportEntry>;
+//# sourceMappingURL=presentation.d.ts.map

package/dist/commands/usage/presentation.js

@@ -0,0 +1,146 @@
+import { renderTable } from "../../output/index.js";
+function value(input) {
+    return input == null ? "-" : String(input);
+}
+function percent(input) {
+    return input == null ? "-" : `${input}%`;
+}
+function problemText(problem) {
+    if (problem.kind === "no_quota")
+        return problem.detail;
+    const remedy = problem.refreshedBy
+        ? `Run ${problem.refreshedBy} to refresh login.`
+        : "Sign in again.";
+    if (problem.kind === "expired")
+        return `Login expired at ${problem.expiresAt}. ${remedy}`;
+    return `Login rejected (HTTP ${problem.status}). ${remedy}`;
+}
+function failureText(report) {
+    if (report.status === "error")
+        return report.error;
+    if (report.status === "unavailable")
+        return problemText(report.problem);
+    return "-";
+}
+function windowText(window) {
+    return `${window.label}: ${percent(window.usedPct)} used, ${percent(window.remainingPct)} remaining`;
+}
+function balanceText(balance) {
+    return `${balance.label}: ${value(balance.used)} used, ${value(balance.remaining)} remaining, ${value(balance.limit)} limit (${balance.unit})`;
+}
+function summary(entry) {
+    const { report } = entry;
+    if (report.status !== "available") {
+        const lines = [failureText(report)];
+        for (const login of entry.loginErrors ?? [])
+            lines.push(`${login.harness}: ${failureText(login.report)}`);
+        if (entry.lastSuccessful) {
+            lines.push(`Last successful: ${entry.lastSuccessful.fetchedAt}`);
+            lines.push(...availableSummary(entry.lastSuccessful.report).map((line) => `Retained: ${line}`));
+        }
+        else
+            lines.push("No successful update");
+        return lines;
+    }
+    return [...availableSummary(report), `Last successful: ${successfulTime(entry)}`];
+}
+function availableSummary(report) {
+    const lines = report.windows.map(windowText);
+    lines.push(...(report.balances ?? []).map(balanceText));
+    return lines.length ? lines : ["-"];
+}
+const summarySchema = {
+    idField: "id",
+    columns: [
+        { header: "REPORT ID", field: "id" },
+        { header: "SOURCE", field: "source" },
+        { header: "ACCOUNT", field: "account" },
+        { header: "STATUS", field: "status" },
+        { header: "USAGE", field: "usage" },
+        { header: "FETCHED (LATEST ATTEMPT)", field: "fetched" },
+    ],
+};
+function inspect(entry) {
+    const lines = [
+        `Report ID: ${entry.id}`,
+        `Source: ${entry.sourceLabel}`,
+        `Source ID: ${entry.sourceId}`,
+        `Account: ${value(entry.account.label)}`,
+        `Status: ${entry.report.status}`,
+        `Latest attempt: ${value(entry.fetchedAt)}`,
+    ];
+    const report = entry.report.status === "available" ? entry.report : entry.lastSuccessful?.report;
+    const successfulAt = successfulTime(entry);
+    lines.push(successfulAt ? `Last successful: ${successfulAt}` : "No successful update");
+    if (entry.report.status !== "available")
+        lines.push(`Reason: ${failureText(entry.report)}`);
+    if (report) {
+        if (entry.report.status !== "available")
+            lines.push("Retained usage:");
+        lines.push(...availableDetails(report));
+    }
+    if (entry.loginErrors?.length) {
+        lines.push("Login failures:");
+        for (const login of entry.loginErrors)
+            lines.push(`  ${login.harness}: ${failureText(login.report)}`);
+    }
+    return lines.join("\n");
+}
+export const usageSchema = {
+    idField: "id",
+    columns: [],
+    renderHuman(result, options) {
+        if (result.type === "single")
+            return inspect(result.data);
+        if (!result.data.length)
+            return "No usage reports returned";
+        const rows = [];
+        for (const entry of result.data) {
+            for (const [index, usage] of summary(entry).entries()) {
+                const first = index === 0;
+                rows.push({
+                    id: first ? entry.id : "",
+                    source: first ? entry.sourceLabel : "",
+                    account: first ? value(entry.account.label) : "",
+                    status: first ? entry.report.status : "",
+                    usage,
+                    fetched: first ? value(entry.fetchedAt) : "",
+                });
+            }
+        }
+        return renderTable({ type: "list", data: rows, schema: summarySchema }, options);
+    },
+};
+function availableDetails(report) {
+    const lines = [];
+    lines.push(`Plan: ${value(report.planLabel)}`, "Windows:");
+    if (!report.windows.length)
+        lines.push("  -");
+    for (const window of report.windows) {
+        lines.push(`  ${windowText(window)} [${window.id}]`, `    Resets: ${value(window.resetsAt)}`);
+        if (window.runsOutAt != null)
+            lines.push(`    Runs out: ${window.runsOutAt}`);
+        if (window.shortfallPct != null)
+            lines.push(`    Shortfall: ${percent(window.shortfallPct)}`);
+    }
+    lines.push("Balances:");
+    if (!report.balances?.length)
+        lines.push("  -");
+    for (const balance of report.balances ?? []) {
+        lines.push(`  ${balanceText(balance)} [${balance.id}]`, `    Resets: ${value(balance.resetsAt)}`);
+    }
+    lines.push("Details:");
+    if (!report.details?.length)
+        lines.push("  -");
+    for (const detail of report.details ?? [])
+        lines.push(`  ${detail.label}: ${detail.value}`);
+    return lines;
+}
+function successfulTime(entry) {
+    // COMPAT(usageSuccessfulAt): added in v0.12.0, remove after 2027-04-17 once daemon floor >= v0.12.0.
+    // Only available reports from older daemons can use their attempt timestamp as freshness.
+    if (entry.report.status === "available")
+        return entry.successfulAt ?? entry.fetchedAt;
+    return entry.lastSuccessful?.fetchedAt;
+}
+//# sourceMappingURL=presentation.js.map

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

@@ -13,6 +13,7 @@ export interface WorkspaceCreateOptions extends CommandOptions {
     branch?: string;
     prNumber?: string;
     forge?: string;
+    background?: boolean;
 }
 export declare function buildWorkspaceSource(options: WorkspaceCreateOptions): {
     projectId?: string | undefined;

package/dist/commands/workspace/create.js

@@ -1,4 +1,5 @@
 import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { resolveCallerAgentId } from "../../utils/caller-agent.js";
 import { toWorkspaceRow, workspaceSchema } from "./shared.js";
 function assertOptionsAbsent(values, message) {
     if (values.some((value) => value !== undefined)) {
@@ -94,9 +95,12 @@ export async function runCreateCommand(options, _command) {
         };
     });
     try {
+        const callerAgentId = await resolveCallerAgentId(client);
         const payload = await client.createWorkspace({
             source: buildWorkspaceSource(options),
             ...(options.title ? { title: options.title } : {}),
+            ...(options.background !== undefined ? { background: options.background } : {}),
+            ...(callerAgentId ? { callerAgentId } : {}),
         });
         if (!payload.workspace) {
             throw new Error(payload.error ?? "Workspace creation failed");