@camerontaylor/paseo-cli 0.8.0-fork.1 → 0.8.0-fork.3

package/dist/commands/permit/allow.js

@@ -1,4 +1,4 @@
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 /** Schema for permit allow/deny output */
 export const permitResponseSchema = {
     idField: "requestId",
@@ -21,7 +21,6 @@ export const permitResponseSchema = {
     ],
 };
 export async function runAllowCommand(agentIdOrPrefix, reqId, options, _command) {
-    const host = getDaemonHost({ host: options.host });
     // No validation needed - if no reqId provided, allow all by default
     // Parse input JSON if provided
     let updatedInput;
@@ -38,19 +37,7 @@ export async function runAllowCommand(agentIdOrPrefix, reqId, options, _command)
             throw error;
         }
     }
-    let client;
-    try {
-        client = await connectToDaemon({ host: options.host });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const error = {
-            code: "DAEMON_NOT_RUNNING",
-            message: `Cannot connect to daemon at ${host}: ${message}`,
-            details: "Start the daemon with: paseo daemon start",
-        };
-        throw error;
-    }
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const fetchResult = await client.fetchAgent({ agentId: agentIdOrPrefix });
         if (!fetchResult) {

package/dist/commands/permit/deny.js

@@ -1,7 +1,6 @@
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 import { permitResponseSchema } from "./allow.js";
 export async function runDenyCommand(agentIdOrPrefix, reqId, options, _command) {
-    const host = getDaemonHost({ host: options.host });
     // Validate arguments
     if (!options.all && !reqId) {
         const error = {
@@ -11,19 +10,7 @@ export async function runDenyCommand(agentIdOrPrefix, reqId, options, _command)
         };
         throw error;
     }
-    let client;
-    try {
-        client = await connectToDaemon({ host: options.host });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const error = {
-            code: "DAEMON_NOT_RUNNING",
-            message: `Cannot connect to daemon at ${host}: ${message}`,
-            details: "Start the daemon with: paseo daemon start",
-        };
-        throw error;
-    }
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const fetchResult = await client.fetchAgent({ agentId: agentIdOrPrefix });
         if (!fetchResult) {

package/dist/commands/permit/ls.js

@@ -1,4 +1,4 @@
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 /** Schema for permit ls output */
 export const permitLsSchema = {
     idField: "id",
@@ -20,20 +20,7 @@ function toListItem(agent, permission) {
     };
 }
 export async function runLsCommand(options, _command) {
-    const host = getDaemonHost({ host: options.host });
-    let client;
-    try {
-        client = await connectToDaemon({ host: options.host });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const error = {
-            code: "DAEMON_NOT_RUNNING",
-            message: `Cannot connect to daemon at ${host}: ${message}`,
-            details: "Start the daemon with: paseo daemon start",
-        };
-        throw error;
-    }
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const agentsPayload = await client.fetchAgents({ filter: { includeArchived: true } });
         const agents = agentsPayload.entries.map((entry) => entry.agent);

package/dist/commands/plugin/index.js

@@ -54,14 +54,14 @@ export async function runPluginInitCommand(directory, options, _command) {
     };
 }
 export async function runPluginListCommand(pluginId, options, _command) {
-    const plugins = await withPluginManagementClient(options.host, (client) => client.listPlugins());
+    const plugins = await withPluginManagementClient(options.daemonTarget, (client) => client.listPlugins());
     const data = pluginId ? plugins.filter((plugin) => plugin.id === pluginId) : plugins;
     if (pluginId && data.length === 0)
         throw new Error(`Plugin is not configured: ${pluginId}`);
     return { type: "list", data, schema: pluginSchema };
 }
 export async function runPluginLogsCommand(pluginId, options, _command) {
-    const data = await withPluginLogsClient(options.host, (client) => client.getPluginLogs(pluginId));
+    const data = await withPluginLogsClient(options.daemonTarget, (client) => client.getPluginLogs(pluginId));
     return { type: "list", data, schema: pluginLogsSchema };
 }
 async function install(source, options, _command) {
@@ -77,8 +77,8 @@ async function install(source, options, _command) {
     const canUseLegacyDirectoryInstall = isExplicitPath && !hasPluginPathSuffix && !options.ref && !options.path;
     const sourceReference = formatPluginSourceReference(source, options.path);
     const data = canUseLegacyDirectoryInstall
-        ? await withPluginManagementClient(options.host, (client) => client.installDirectoryPlugin(source, options.id))
-        : await withPluginSourceClient(options.host, (client) => client.installPluginSource({
+        ? await withPluginManagementClient(options.daemonTarget, (client) => client.installDirectoryPlugin(source, options.id))
+        : await withPluginSourceClient(options.daemonTarget, (client) => client.installPluginSource({
             source: sourceReference,
             ...(options.id ? { id: options.id } : {}),
             ...(options.ref ? { ref: options.ref } : {}),
@@ -89,15 +89,15 @@ async function update(pluginId, options, _command) {
     if ((pluginId === undefined) === (options.all !== true)) {
         throw new Error("Choose one plugin ID or pass --all");
     }
-    const data = await withPluginSourceClient(options.host, (client) => client.updatePluginSources(pluginId));
+    const data = await withPluginSourceClient(options.daemonTarget, (client) => client.updatePluginSources(pluginId));
     return { type: "list", data, schema: pluginUpdateSchema };
 }
 async function act(action, pluginId, options) {
-    const data = await withPluginManagementClient(options.host, (client) => client[`${action}Plugin`](pluginId));
+    const data = await withPluginManagementClient(options.daemonTarget, (client) => client[`${action}Plugin`](pluginId));
     return { type: "single", data, schema: pluginSchema };
 }
 async function remove(pluginId, options, _command) {
-    const data = await withPluginManagementClient(options.host, async (client) => {
+    const data = await withPluginManagementClient(options.daemonTarget, async (client) => {
         const current = (await client.listPlugins()).find((plugin) => plugin.id === pluginId);
         if (!current)
             throw new Error(`Plugin is not configured: ${pluginId}`);

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

@@ -1,5 +1,6 @@
+import type { DaemonTarget } from "../../utils/daemon-target.js";
 import type { DaemonClient } from "@camerontaylor/paseo-client/internal/daemon-client";
-export declare function withPluginManagementClient<T>(host: string | undefined, run: (client: DaemonClient) => Promise<T>): Promise<T>;
-export declare function withPluginLogsClient<T>(host: string | undefined, run: (client: DaemonClient) => Promise<T>): Promise<T>;
-export declare function withPluginSourceClient<T>(host: string | undefined, run: (client: DaemonClient) => Promise<T>): Promise<T>;
+export declare function withPluginManagementClient<T>(target: DaemonTarget, run: (client: DaemonClient) => Promise<T>): Promise<T>;
+export declare function withPluginLogsClient<T>(target: DaemonTarget, run: (client: DaemonClient) => Promise<T>): Promise<T>;
+export declare function withPluginSourceClient<T>(target: DaemonTarget, run: (client: DaemonClient) => Promise<T>): Promise<T>;
 //# sourceMappingURL=shared.d.ts.map

package/dist/commands/plugin/shared.js

@@ -1,6 +1,6 @@
 import { connectToDaemon } from "../../utils/client.js";
-async function withPluginClient(host, feature, updateMessage, run) {
-    const client = await connectToDaemon({ host });
+async function withPluginClient(target, feature, updateMessage, run) {
+    const client = await connectToDaemon({ target });
     if (client.getLastServerInfoMessage()?.features?.[feature] !== true) {
         await client.close().catch(() => undefined);
         throw {
@@ -15,16 +15,16 @@ async function withPluginClient(host, feature, updateMessage, run) {
         await client.close().catch(() => undefined);
     }
 }
-export async function withPluginManagementClient(host, run) {
+export async function withPluginManagementClient(target, run) {
     // COMPAT(pluginManagement): added in v0.3.1, remove gate after 2027-08-14.
-    return withPluginClient(host, "pluginManagement", "Update the host to use plugin management.", run);
+    return withPluginClient(target, "pluginManagement", "Update the host to use plugin management.", run);
 }
-export async function withPluginLogsClient(host, run) {
+export async function withPluginLogsClient(target, run) {
     // COMPAT(pluginLogs): added in v0.4.0, remove gate after 2027-08-16.
-    return withPluginClient(host, "pluginLogs", "Update the host to view plugin logs.", run);
+    return withPluginClient(target, "pluginLogs", "Update the host to view plugin logs.", run);
 }
-export async function withPluginSourceClient(host, run) {
+export async function withPluginSourceClient(target, run) {
     // COMPAT(pluginGitManagement): added in v0.7.0, remove gate after 2027-08-26.
-    return withPluginClient(host, "pluginGitManagement", "Update the host to install and update Git plugins.", run);
+    return withPluginClient(target, "pluginGitManagement", "Update the host to install and update Git plugins.", run);
 }
 //# sourceMappingURL=shared.js.map

package/dist/commands/project/create.js

@@ -18,10 +18,10 @@ export async function runCreateCommand(pathArg, options, _command) {
     const projectPath = resolveProjectPath({
         pathArg,
         cwd: process.cwd(),
-        daemonTarget: options.host ?? process.env.PASEO_HOST,
+        daemonTarget: options.daemonTarget.kind === "endpoint" ? options.daemonTarget.host : undefined,
     });
-    const client = await connectToDaemon({ host: options.host }).catch((error) => {
-        throw buildDaemonConnectionCommandError({ host: options.host, error });
+    const client = await connectToDaemon({ target: options.daemonTarget }).catch((error) => {
+        throw buildDaemonConnectionCommandError({ target: options.daemonTarget, error });
     });
     try {
         const payload = await client.addProject(projectPath);
@@ -31,6 +31,8 @@ export async function runCreateCommand(pathArg, options, _command) {
         return { type: "single", data: toProjectRow(payload.project), schema: projectSchema };
     }
     catch (error) {
+        if (error && typeof error === "object" && "code" in error)
+            throw error;
         const message = error instanceof Error ? error.message : String(error);
         throw { code: "PROJECT_CREATE_FAILED", message };
     }

package/dist/commands/project/delete.js

@@ -11,8 +11,8 @@ const projectDeleteSchema = {
     ],
 };
 export async function runDeleteCommand(projectId, options, _command) {
-    const client = await connectToDaemon({ host: options.host }).catch((error) => {
-        throw buildDaemonConnectionCommandError({ host: options.host, error });
+    const client = await connectToDaemon({ target: options.daemonTarget }).catch((error) => {
+        throw buildDaemonConnectionCommandError({ target: options.daemonTarget, error });
     });
     try {
         const result = await client.removeProject(projectId);
@@ -23,6 +23,8 @@ export async function runDeleteCommand(projectId, options, _command) {
         };
     }
     catch (error) {
+        if (error && typeof error === "object" && "code" in error)
+            throw error;
         const message = error instanceof Error ? error.message : String(error);
         throw { code: "PROJECT_DELETE_FAILED", message };
     }

package/dist/commands/project/ls.js

@@ -1,8 +1,8 @@
 import { buildDaemonConnectionCommandError, connectToDaemon } from "../../utils/client.js";
 import { projectSchema, toProjectRow } from "./shared.js";
 export async function runLsCommand(options, _command) {
-    const client = await connectToDaemon({ host: options.host }).catch((error) => {
-        throw buildDaemonConnectionCommandError({ host: options.host, error });
+    const client = await connectToDaemon({ target: options.daemonTarget }).catch((error) => {
+        throw buildDaemonConnectionCommandError({ target: options.daemonTarget, error });
     });
     try {
         const payload = await client.listProjects();

package/dist/commands/project/rename.js

@@ -28,8 +28,8 @@ export function resolveProjectName(input) {
 }
 export async function runRenameCommand(projectId, nameArg, options, _command) {
     const name = resolveProjectName({ name: nameArg, reset: options.reset });
-    const client = await connectToDaemon({ host: options.host }).catch((error) => {
-        throw buildDaemonConnectionCommandError({ host: options.host, error });
+    const client = await connectToDaemon({ target: options.daemonTarget }).catch((error) => {
+        throw buildDaemonConnectionCommandError({ target: options.daemonTarget, error });
     });
     try {
         const applied = await client.renameProject(projectId, name);
@@ -40,6 +40,8 @@ export async function runRenameCommand(projectId, nameArg, options, _command) {
         };
     }
     catch (error) {
+        if (error && typeof error === "object" && "code" in error)
+            throw error;
         const message = error instanceof Error ? error.message : String(error);
         throw { code: "PROJECT_RENAME_FAILED", message };
     }

package/dist/commands/provider/add.js

@@ -96,8 +96,8 @@ export async function runAddCommand(id, options, _command) {
             message: error instanceof Error ? error.message : String(error),
         };
     }
-    const host = getDaemonHost({ host: options.host });
-    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+    const host = getDaemonHost({ target: options.daemonTarget });
+    const client = await connectToDaemon({ target: options.daemonTarget }).catch((error) => {
         const message = error instanceof Error ? error.message : String(error);
         throw {
             code: "DAEMON_NOT_RUNNING",

package/dist/commands/provider/diagnostic.js

@@ -12,7 +12,7 @@ export const providerDiagnosticSchema = {
     },
 };
 export async function runDiagnosticCommand(provider, options, _command) {
-    const client = await connectToDaemon({ host: options.host });
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const result = await client.getProviderDiagnostic(provider.trim().toLowerCase());
         return {

package/dist/commands/provider/ls.js

@@ -1,18 +1,4 @@
-import { AGENT_PROVIDER_DEFINITIONS } from "@camerontaylor/paseo-protocol/provider-manifest";
-import { tryConnectToDaemon } from "../../utils/client.js";
-/** Derive provider list from the manifest — single source of truth */
-const PROVIDERS = AGENT_PROVIDER_DEFINITIONS.map((def) => ({
-    provider: def.id,
-    label: def.label,
-    source: "builtin",
-    status: "available",
-    enabled: def.enabledByDefault === false ? "Disabled" : "Enabled",
-    defaultMode: def.defaultModeId ?? "-",
-    modes: def.modes.length > 0 ? def.modes.map((m) => m.label).join(", ") : "-",
-}));
-function getStaticProviders() {
-    return PROVIDERS;
-}
+import { connectToDaemon } from "../../utils/client.js";
 /** Schema for provider ls output */
 export const providerLsSchema = {
     idField: "provider",
@@ -38,14 +24,7 @@ export const providerLsSchema = {
     ],
 };
 export async function runLsCommand(options, _command) {
-    const client = await tryConnectToDaemon({ host: options.host });
-    if (!client) {
-        return {
-            type: "list",
-            data: getStaticProviders(),
-            schema: providerLsSchema,
-        };
-    }
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const snapshot = await client.getProvidersSnapshot();
         return {
@@ -62,13 +41,6 @@ export async function runLsCommand(options, _command) {
             schema: providerLsSchema,
         };
     }
-    catch {
-        return {
-            type: "list",
-            data: getStaticProviders(),
-            schema: providerLsSchema,
-        };
-    }
     finally {
         await client.close().catch(() => { });
     }

package/dist/commands/provider/models.js

@@ -23,7 +23,7 @@ const providerModelsWithThinkingSchema = {
 };
 export async function runModelsCommand(provider, options, _command) {
     const normalizedProvider = provider.toLowerCase();
-    const client = await connectToDaemon({ host: options.host });
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const result = await client.listProviderModels(normalizedProvider);
         if (result.error) {

package/dist/commands/provider/rm.js

@@ -14,8 +14,8 @@ export async function runRmCommand(id, options, _command) {
             message: `"${id}" is a built-in provider and cannot be removed.`,
         };
     }
-    const host = getDaemonHost({ host: options.host });
-    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+    const host = getDaemonHost({ target: options.daemonTarget });
+    const client = await connectToDaemon({ target: options.daemonTarget }).catch((error) => {
         const message = error instanceof Error ? error.message : String(error);
         throw {
             code: "DAEMON_NOT_RUNNING",

package/dist/commands/schedule/create.js

@@ -14,12 +14,12 @@ export async function runCreateCommand(prompt, options, command) {
         mode: options.mode,
         thinking: options.thinking,
         cwd: options.cwd,
-        host: options.host,
+        daemonTarget: options.daemonTarget,
         maxRuns: options.maxRuns,
         expiresIn: options.expiresIn,
         runNow,
     });
-    const { client } = await connectScheduleClient(options.host);
+    const { client } = await connectScheduleClient(options.daemonTarget);
     try {
         const payload = await client.scheduleCreate(input);
         if (payload.error || !payload.schedule) {

package/dist/commands/schedule/delete.js

@@ -7,7 +7,7 @@ const scheduleDeleteSchema = {
     ],
 };
 export async function runDeleteCommand(id, options, _command) {
-    const { client } = await connectScheduleClient(options.host);
+    const { client } = await connectScheduleClient(options.daemonTarget);
     try {
         const payload = await client.scheduleDelete({ id });
         if (payload.error) {

package/dist/commands/schedule/inspect.js

@@ -1,7 +1,7 @@
 import { createScheduleInspectRows, createScheduleInspectSchema, } from "./schema.js";
 import { connectScheduleClient, toScheduleCommandError, } from "./shared.js";
 export async function runInspectCommand(id, options, _command) {
-    const { client } = await connectScheduleClient(options.host);
+    const { client } = await connectScheduleClient(options.daemonTarget);
     try {
         const payload = await client.scheduleInspect({ id });
         if (payload.error || !payload.schedule) {

package/dist/commands/schedule/logs.js

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

package/dist/commands/schedule/ls.js

@@ -1,7 +1,7 @@
 import { scheduleSchema } from "./schema.js";
 import { connectScheduleClient, toScheduleCommandError, toScheduleRow, } from "./shared.js";
 export async function runLsCommand(options, _command) {
-    const { client } = await connectScheduleClient(options.host);
+    const { client } = await connectScheduleClient(options.daemonTarget);
     try {
         const payload = await client.scheduleList();
         if (payload.error) {

package/dist/commands/schedule/pause.js

@@ -1,7 +1,7 @@
 import { scheduleSchema } from "./schema.js";
 import { connectScheduleClient, requireNewAgentSchedule, toScheduleCommandError, toScheduleRow, } from "./shared.js";
 export async function runPauseCommand(id, options, _command) {
-    const { client } = await connectScheduleClient(options.host);
+    const { client } = await connectScheduleClient(options.daemonTarget);
     try {
         await requireNewAgentSchedule(client, id);
         const payload = await client.schedulePause({ id });

package/dist/commands/schedule/resume.js

@@ -1,7 +1,7 @@
 import { scheduleSchema } from "./schema.js";
 import { connectScheduleClient, requireNewAgentSchedule, toScheduleCommandError, toScheduleRow, } from "./shared.js";
 export async function runResumeCommand(id, options, _command) {
-    const { client } = await connectScheduleClient(options.host);
+    const { client } = await connectScheduleClient(options.daemonTarget);
     try {
         await requireNewAgentSchedule(client, id);
         const payload = await client.scheduleResume({ id });

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

@@ -1,7 +1,7 @@
 import { scheduleSchema } from "./schema.js";
 import { connectScheduleClient, requireNewAgentSchedule, toScheduleCommandError, toScheduleRow, } from "./shared.js";
 export async function runRunOnceCommand(id, options, _command) {
-    const { client } = await connectScheduleClient(options.host);
+    const { client } = await connectScheduleClient(options.daemonTarget);
     try {
         await requireNewAgentSchedule(client, id);
         const payload = await client.scheduleRunOnce({ id });

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

@@ -1,9 +1,10 @@
+import type { DaemonTarget } from "../../utils/daemon-target.js";
 import type { CommandError, CommandOptions } from "../../output/index.js";
 import type { CreateScheduleInput, ScheduleCadence, ScheduleDaemonClient, ScheduleListItem, ScheduleRecord, ScheduleTarget, UpdateScheduleInput } from "./types.js";
 export interface ScheduleCommandOptions extends CommandOptions {
     host?: string;
 }
-export declare function connectScheduleClient(host: string | undefined): Promise<{
+export declare function connectScheduleClient(target: DaemonTarget): Promise<{
     client: ScheduleDaemonClient;
     host: string;
 }>;
@@ -24,6 +25,7 @@ export declare function parseScheduleCreateInput(options: {
     thinking?: string;
     cwd?: string;
     host?: string;
+    daemonTarget: import("../../utils/daemon-target.js").DaemonTarget;
     maxRuns?: string;
     expiresIn?: string;
     runNow?: boolean;

package/dist/commands/schedule/shared.js

@@ -1,16 +1,18 @@
-import { connectToDaemon, getDaemonHost, getExplicitDaemonHost } from "../../utils/client.js";
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
 import { parseDuration } from "../../utils/duration.js";
 import { resolveProviderAndModel } from "../../utils/provider-model.js";
 import { everyMsToFiveFieldCron } from "@camerontaylor/paseo-protocol/schedule/cadence";
-export async function connectScheduleClient(host) {
-    const resolvedHost = getDaemonHost({ host });
+export async function connectScheduleClient(target) {
+    const resolvedHost = getDaemonHost({ target });
     try {
         const client = (await connectToDaemon({
-            host,
+            target,
         }));
         return { client, host: resolvedHost };
     }
     catch (error) {
+        if (error && typeof error === "object" && "code" in error)
+            throw error;
         const message = error instanceof Error ? error.message : String(error);
         throw {
             code: "DAEMON_NOT_RUNNING",
@@ -116,7 +118,7 @@ export function parseScheduleCreateInput(options) {
         };
     }
     const cwdInput = options.cwd?.trim();
-    if (getExplicitDaemonHost(options.host) !== undefined && !cwdInput) {
+    if (options.daemonTarget.kind === "endpoint" && !cwdInput) {
         throw {
             code: "MISSING_CWD",
             message: "--cwd is required when --host is specified (the local working directory will not exist on the remote daemon)",

package/dist/commands/schedule/update.js

@@ -17,7 +17,7 @@ export async function runUpdateCommand(id, options, _command) {
         clearMaxRuns: options.noMaxRuns,
         clearExpires: options.noExpiresIn,
     });
-    const { client } = await connectScheduleClient(options.host);
+    const { client } = await connectScheduleClient(options.daemonTarget);
     try {
         await requireNewAgentSchedule(client, id);
         const payload = await client.scheduleUpdate(input);

package/dist/commands/script/ls.js

@@ -1,7 +1,7 @@
 import { connectWorkspaceScriptClient, resolveWorkspaceScriptWorkspaceId, toWorkspaceScriptCommandError, } from "./shared.js";
 import { workspaceScriptSchema } from "./schema.js";
 export async function runLsCommand(options, _command) {
-    const client = await connectWorkspaceScriptClient(options.host);
+    const client = await connectWorkspaceScriptClient(options.daemonTarget);
     try {
         const workspaceId = await resolveWorkspaceScriptWorkspaceId(client, options);
         const payload = await client.listWorkspaceScripts(workspaceId);

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

@@ -1,3 +1,4 @@
+import type { DaemonTarget } from "../../utils/daemon-target.js";
 import type { DaemonClient } from "@camerontaylor/paseo-client/internal/daemon-client";
 import type { CommandError, CommandOptions } from "../../output/index.js";
 export interface WorkspaceScriptCommandOptions extends CommandOptions {
@@ -5,7 +6,7 @@ export interface WorkspaceScriptCommandOptions extends CommandOptions {
     cwd?: string;
     workspace?: string;
 }
-export declare function connectWorkspaceScriptClient(host?: string): Promise<DaemonClient>;
+export declare function connectWorkspaceScriptClient(target: DaemonTarget): 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

@@ -1,9 +1,9 @@
 import { resolve } from "node:path";
 import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-export async function connectWorkspaceScriptClient(host) {
-    const daemonHost = getDaemonHost({ host });
+export async function connectWorkspaceScriptClient(target) {
+    const daemonHost = getDaemonHost({ target });
     try {
-        const client = await connectToDaemon({ host });
+        const client = await connectToDaemon({ target });
         // COMPAT(workspaceScriptManagement): added in v0.1.105, remove gate after 2027-01-10.
         if (!client.getLastServerInfoMessage()?.features?.workspaceScriptManagement) {
             await client.close().catch(() => { });

package/dist/commands/script/start.js

@@ -1,7 +1,7 @@
 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);
+    const client = await connectWorkspaceScriptClient(options.daemonTarget);
     try {
         const workspaceId = await resolveWorkspaceScriptWorkspaceId(client, options);
         const payload = await client.startWorkspaceScriptWithStatus(workspaceId, scriptName);

package/dist/commands/script/stop.js

@@ -1,7 +1,7 @@
 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);
+    const client = await connectWorkspaceScriptClient(options.daemonTarget);
     try {
         const workspaceId = await resolveWorkspaceScriptWorkspaceId(client, options);
         const payload = await client.stopWorkspaceScript(workspaceId, scriptName);

package/dist/commands/terminal/capture.d.ts

@@ -6,5 +6,5 @@ export interface TerminalCaptureOptions extends TerminalCommandOptions {
     scrollback?: boolean;
     ansi?: boolean;
 }
-export declare function runCaptureCommand(terminalId: string, _options: TerminalCaptureOptions, command: Command): Promise<void>;
+export declare function runCaptureCommand(terminalId: string, options: TerminalCaptureOptions, _command: Command): Promise<void>;
 //# sourceMappingURL=capture.d.ts.map

package/dist/commands/terminal/capture.js

@@ -1,7 +1,6 @@
 import { renderError, toCommandError } from "../../output/render.js";
 import { connectTerminalClient, resolveTerminalId, toTerminalCommandError, } from "./shared.js";
-export async function runCaptureCommand(terminalId, _options, command) {
-    const options = command.optsWithGlobals();
+export async function runCaptureCommand(terminalId, options, _command) {
     try {
         const payload = await executeCaptureCommand(terminalId, options);
         if (options.json) {
@@ -26,7 +25,7 @@ export async function runCaptureCommand(terminalId, _options, command) {
     }
 }
 async function executeCaptureCommand(terminalId, options) {
-    const { client, close } = await connectTerminalClient(options.host);
+    const { client, close } = await connectTerminalClient(options.daemonTarget);
     try {
         const resolvedId = await resolveTerminalId(client, terminalId);
         if (!resolvedId) {

package/dist/commands/terminal/create.js

@@ -1,7 +1,7 @@
 import { connectTerminalClient, toTerminalCommandError, } from "./shared.js";
 import { terminalSchema } from "./schema.js";
 export async function runCreateCommand(options, _command) {
-    const { client, close } = await connectTerminalClient(options.host);
+    const { client, close } = await connectTerminalClient(options.daemonTarget);
     try {
         const cwd = options.cwd ?? (options.workspace ? undefined : process.cwd());
         const workspaceId = options.workspace ?? (await client.workspaces.open(options.cwd ?? process.cwd())).id;

package/dist/commands/terminal/kill.js

@@ -1,7 +1,7 @@
 import { connectTerminalClient, resolveTerminalId, toTerminalCommandError, } from "./shared.js";
 import { terminalKillSchema } from "./schema.js";
 export async function runKillCommand(terminalId, options, _command) {
-    const { client, close } = await connectTerminalClient(options.host);
+    const { client, close } = await connectTerminalClient(options.daemonTarget);
     try {
         const resolvedId = await requireTerminalId(client, terminalId);
         await client.terminals.ref(resolvedId).kill();

package/dist/commands/terminal/ls.js

@@ -1,7 +1,7 @@
 import { connectTerminalClient, toTerminalCommandError, } from "./shared.js";
 import { terminalSchema } from "./schema.js";
 export async function runLsCommand(options, _command) {
-    const { client, close } = await connectTerminalClient(options.host);
+    const { client, close } = await connectTerminalClient(options.daemonTarget);
     const cwd = options.all || options.workspace ? undefined : (options.cwd ?? process.cwd());
     try {
         const payload = await client.terminals.list({ cwd, workspaceId: options.workspace });