@camerontaylor/paseo-cli 0.8.0-fork.1 → 0.9.0-beta.2.fork.1

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 });

package/dist/commands/terminal/send-keys.d.ts

@@ -3,5 +3,5 @@ import { type TerminalCommandOptions } from "./shared.js";
 export interface TerminalSendKeysOptions extends TerminalCommandOptions {
     literal?: boolean;
 }
-export declare function runSendKeysCommand(terminalId: string, keys: string[], _options: TerminalSendKeysOptions, command: Command): Promise<void>;
+export declare function runSendKeysCommand(terminalId: string, keys: string[], options: TerminalSendKeysOptions, _command: Command): Promise<void>;
 //# sourceMappingURL=send-keys.d.ts.map

package/dist/commands/terminal/send-keys.js

@@ -1,7 +1,6 @@
 import { renderError, toCommandError } from "../../output/render.js";
 import { connectTerminalClient, resolveTerminalId, toTerminalCommandError, } from "./shared.js";
-export async function runSendKeysCommand(terminalId, keys, _options, command) {
-    const options = command.optsWithGlobals();
+export async function runSendKeysCommand(terminalId, keys, options, _command) {
     try {
         const payload = await executeSendKeysCommand(terminalId, keys, options);
         if (options.json) {
@@ -18,7 +17,7 @@ export async function runSendKeysCommand(terminalId, keys, _options, command) {
     }
 }
 async function executeSendKeysCommand(terminalId, keys, 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/shared.d.ts

@@ -1,8 +1,9 @@
+import type { DaemonTarget } from "../../utils/daemon-target.js";
 import type { CommandError, CommandOptions } from "../../output/index.js";
 export interface TerminalCommandOptions extends CommandOptions {
     host?: string;
 }
-export declare function connectTerminalClient(host?: string): Promise<{
+export declare function connectTerminalClient(target: DaemonTarget): Promise<{
     client: import("@camerontaylor/paseo-client").PaseoApi;
     daemonHost: string;
     close: () => Promise<void>;

package/dist/commands/terminal/shared.js

@@ -1,12 +1,14 @@
 import { createPaseoApi } from "@camerontaylor/paseo-client";
 import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-export async function connectTerminalClient(host) {
-    const daemonHost = getDaemonHost({ host });
+export async function connectTerminalClient(target) {
+    const daemonHost = getDaemonHost({ target });
     try {
-        const client = await connectToDaemon({ host });
+        const client = await connectToDaemon({ target });
         return { client: createPaseoApi(client), daemonHost, close: () => client.close() };
     }
     catch (err) {
+        if (err && typeof err === "object" && "code" in err)
+            throw err;
         const message = err instanceof Error ? err.message : String(err);
         const error = {
             code: "DAEMON_NOT_RUNNING",

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

@@ -7,6 +7,7 @@ interface WorkspaceArchiveResult {
 }
 export declare function runArchiveCommand(workspaceId: string, options: {
     host?: string;
+    daemonTarget: import("../../utils/daemon-target.js").DaemonTarget;
 }, _command: Command): Promise<SingleResult<WorkspaceArchiveResult>>;
 export {};
 //# sourceMappingURL=archive.d.ts.map

package/dist/commands/workspace/archive.js

@@ -8,8 +8,8 @@ const workspaceArchiveSchema = {
     ],
 };
 export async function runArchiveCommand(workspaceId, options, _command) {
-    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",
@@ -31,6 +31,8 @@ export async function runArchiveCommand(workspaceId, 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: "WORKSPACE_ARCHIVE_FAILED", message };
     }

package/dist/commands/workspace/create.js

@@ -85,8 +85,8 @@ export function buildWorkspaceSource(options) {
     throw new Error(`Unsupported workspace isolation: ${String(options.isolation)}`);
 }
 export async function runCreateCommand(options, _command) {
-    const host = getDaemonHost({ host: options.host });
-    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+    const 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",
@@ -104,6 +104,8 @@ export async function runCreateCommand(options, _command) {
         return { type: "single", data: toWorkspaceRow(payload.workspace), schema: workspaceSchema };
     }
     catch (error) {
+        if (error && typeof error === "object" && "code" in error)
+            throw error;
         const message = error instanceof Error ? error.message : String(error);
         throw { code: "WORKSPACE_CREATE_FAILED", message };
     }

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

@@ -3,5 +3,6 @@ import type { ListResult } from "../../output/index.js";
 import { type WorkspaceRow } from "./shared.js";
 export declare function runLsCommand(options: {
     host?: string;
+    daemonTarget: import("../../utils/daemon-target.js").DaemonTarget;
 }, _command: Command): Promise<ListResult<WorkspaceRow>>;
 //# sourceMappingURL=ls.d.ts.map

package/dist/commands/workspace/ls.js

@@ -1,8 +1,8 @@
 import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
 import { toWorkspaceRow, workspaceSchema } from "./shared.js";
 export async function runLsCommand(options, _command) {
-    const host = getDaemonHost({ host: options.host });
-    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+    const 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/workspace/rename.d.ts

@@ -7,6 +7,7 @@ interface WorkspaceRenameResult {
 }
 export interface WorkspaceRenameOptions {
     host?: string;
+    daemonTarget: import("../../utils/daemon-target.js").DaemonTarget;
     reset?: boolean;
 }
 /**

package/dist/commands/workspace/rename.js

@@ -33,8 +33,8 @@ export function resolveWorkspaceTitle(input) {
 }
 export async function runRenameCommand(workspaceId, titleArg, options, _command) {
     const title = resolveWorkspaceTitle({ title: titleArg, reset: options.reset });
-    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",
@@ -51,6 +51,8 @@ export async function runRenameCommand(workspaceId, titleArg, 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: "WORKSPACE_RENAME_FAILED", message };
     }

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

@@ -6,6 +6,7 @@ interface WorkspaceSetupResult {
 }
 export declare function runSetupCommand(workspaceId: string, options: {
     host?: string;
+    daemonTarget: import("../../utils/daemon-target.js").DaemonTarget;
 }, _command: Command): Promise<SingleResult<WorkspaceSetupResult>>;
 export {};
 //# sourceMappingURL=setup.d.ts.map

package/dist/commands/workspace/setup.js

@@ -7,8 +7,8 @@ const workspaceSetupSchema = {
     ],
 };
 export async function runSetupCommand(workspaceId, options, _command) {
-    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) => {
         throw {
             code: "DAEMON_NOT_RUNNING",
             message: `Cannot connect to daemon at ${host}: ${error instanceof Error ? error.message : String(error)}`,

package/dist/commands/worktree/archive.js

@@ -16,7 +16,7 @@ export async function runArchiveCommand(nameArg, options, _command) {
     return runArchiveCommandWithDeps(nameArg, options, { connectToDaemon });
 }
 export async function runArchiveCommandWithDeps(nameArg, options, deps) {
-    const host = getDaemonHost({ host: options.host });
+    const host = getDaemonHost({ target: options.daemonTarget });
     // Validate arguments
     if (!nameArg || nameArg.trim().length === 0) {
         const error = {
@@ -28,9 +28,11 @@ export async function runArchiveCommandWithDeps(nameArg, options, deps) {
     }
     let client;
     try {
-        client = await deps.connectToDaemon({ host: options.host });
+        client = await deps.connectToDaemon({ target: options.daemonTarget });
     }
     catch (err) {
+        if (err && typeof err === "object" && "code" in err)
+            throw err;
         const message = err instanceof Error ? err.message : String(err);
         const error = {
             code: "DAEMON_NOT_RUNNING",

package/dist/commands/worktree/create.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 import { buildCreateWorktreeRequest } from "./create-input.js";
 export const createSchema = {
     idField: "worktreePath",
@@ -15,15 +15,7 @@ function cmdError(code, message, details) {
 export async function runCreateCommand(options, _command) {
     const cwd = options.cwd ?? process.cwd();
     const request = buildCreateWorktreeRequest(options, cwd);
-    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);
-        throw cmdError("DAEMON_NOT_RUNNING", `Cannot connect to daemon at ${host}: ${message}`, "Start the daemon with: paseo daemon start");
-    }
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const response = await client.createPaseoWorktree(request);
         const workspace = response.workspace;

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

@@ -7,8 +7,6 @@ export interface WorktreeListItem {
     cwd: string;
     agent: string;
 }
-export declare function resolvePaseoHomePath(): string;
-export declare function resolvePaseoWorktreesDir(): string;
 /** Schema for worktree ls output */
 export declare const worktreeLsSchema: OutputSchema<WorktreeListItem>;
 export type WorktreeLsResult = ListResult<WorktreeListItem>;

package/dist/commands/worktree/ls.js

@@ -1,6 +1,5 @@
-import { homedir } from "node:os";
-import { basename, join, sep } from "node:path";
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { basename } from "node:path";
+import { connectToDaemon } from "../../utils/client.js";
 /** Shorten home directory in path */
 function shortenPath(path) {
     const home = process.env.HOME;
@@ -13,16 +12,6 @@ function shortenPath(path) {
 function extractWorktreeName(path) {
     return basename(path);
 }
-export function resolvePaseoHomePath() {
-    return process.env.PASEO_HOME ?? join(homedir(), ".paseo");
-}
-export function resolvePaseoWorktreesDir() {
-    return join(resolvePaseoHomePath(), "worktrees");
-}
-function isAgentInManagedWorktree(agentCwd) {
-    const worktreesDir = resolvePaseoWorktreesDir();
-    return agentCwd === worktreesDir || agentCwd.startsWith(worktreesDir + sep);
-}
 /** Schema for worktree ls output */
 export const worktreeLsSchema = {
     idField: "name",
@@ -34,20 +23,7 @@ export const worktreeLsSchema = {
     ],
 };
 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);
@@ -64,9 +40,7 @@ export async function runLsCommand(options, _command) {
         // Build a map of worktree paths to agent IDs
         const worktreeAgentMap = new Map();
         for (const agent of agents) {
-            if (isAgentInManagedWorktree(agent.cwd)) {
-                worktreeAgentMap.set(agent.cwd, agent.id.slice(0, 7));
-            }
+            worktreeAgentMap.set(agent.cwd, agent.id.slice(0, 7));
         }
         const items = response.worktrees.map((wt) => ({
             name: extractWorktreeName(wt.worktreePath),

package/dist/output/with-output.d.ts

@@ -7,6 +7,8 @@ import type { Command } from "commander";
 import type { AnyCommandResult, OutputOptions } from "./types.js";
 /** Options that include output settings from global options */
 export interface CommandOptions extends Partial<OutputOptions> {
+    daemonTarget: import("../utils/daemon-target.js").DaemonTarget;
+    home?: string;
     /** Daemon host target from --host option */
     host?: string;
     /** JSON output flag from --json option */

package/dist/run.js

@@ -1,3 +1,4 @@
+import { renderError, toCommandError, defaultOutputOptions } from "./output/render.js";
 import { createCli } from "./cli.js";
 import { classifyInvocation } from "./classify.js";
 import { openDesktopWithProject } from "./commands/open.js";
@@ -34,7 +35,16 @@ export async function runCli(argv, options = {}) {
         return typeof process.exitCode === "number" ? process.exitCode : 0;
     }
     const program = createCli();
-    await program.parseAsync(parseArgv, { from: "node" });
+    try {
+        await program.parseAsync(parseArgv, { from: "node" });
+    }
+    catch (error) {
+        process.stderr.write(renderError(toCommandError(error), {
+            ...defaultOutputOptions,
+            format: argv.includes("--json") ? "json" : "table",
+        }) + "\n");
+        return 1;
+    }
     return typeof process.exitCode === "number" ? process.exitCode : 0;
 }
 //# sourceMappingURL=run.js.map

package/dist/utils/client-id.d.ts

@@ -1,2 +1,2 @@
-export declare function getOrCreateCliClientId(): Promise<string>;
+export declare function getOrCreateCliClientId(home: string): Promise<string>;
 //# sourceMappingURL=client-id.d.ts.map

package/dist/utils/client-id.js

@@ -1,9 +1,7 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { ensurePrivateDirectory } from "@camerontaylor/paseo-server/daemon-control";
+import { readFile, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
-import { dirname, join } from "node:path";
-import { homedir } from "node:os";
-const CLIENT_SESSION_KEY_FILE = join(process.env.PASEO_HOME ?? join(homedir(), ".paseo"), "cli-client-id");
-let cachedClientId = null;
+import { join } from "node:path";
 function normalizeClientId(value) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : null;
@@ -11,14 +9,11 @@ function normalizeClientId(value) {
 function generateClientId() {
     return `cid_${randomUUID().replace(/-/g, "")}`;
 }
-export async function getOrCreateCliClientId() {
-    if (cachedClientId) {
-        return cachedClientId;
-    }
+export async function getOrCreateCliClientId(home) {
+    const clientSessionKeyFile = join(home, "cli-client-id");
     try {
-        const existing = normalizeClientId(await readFile(CLIENT_SESSION_KEY_FILE, "utf8"));
+        const existing = normalizeClientId(await readFile(clientSessionKeyFile, "utf8"));
         if (existing) {
-            cachedClientId = existing;
             return existing;
         }
     }
@@ -29,9 +24,8 @@ export async function getOrCreateCliClientId() {
         }
     }
     const nextValue = generateClientId();
-    await mkdir(dirname(CLIENT_SESSION_KEY_FILE), { recursive: true });
-    await writeFile(CLIENT_SESSION_KEY_FILE, nextValue, { mode: 0o600 });
-    cachedClientId = nextValue;
+    ensurePrivateDirectory(home);
+    await writeFile(clientSessionKeyFile, nextValue, { mode: 0o600 });
     return nextValue;
 }
 //# sourceMappingURL=client-id.js.map