@getpaseo/cli 0.1.91-beta.1 → 0.1.91

package/dist/commands/agent/import.js

@@ -1,14 +1,11 @@
 import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
 import { collectMultiple } from "../../utils/command-options.js";
 import { agentRunSchema } from "./run.js";
-const IMPORT_PROVIDER_LIST = ["claude", "codex", "opencode", "pi", "acp"];
-const IMPORT_PROVIDERS = new Set(IMPORT_PROVIDER_LIST);
-const IMPORT_PROVIDER_HELP = IMPORT_PROVIDER_LIST.join(", ");
 export function addImportOptions(cmd) {
     return cmd
         .description("Import an existing provider session as a Paseo agent")
         .argument("<id>", "Provider session/thread ID to import")
-        .requiredOption("--provider <provider>", `Agent provider: ${IMPORT_PROVIDER_HELP}`)
+        .requiredOption("--provider <provider>", "Agent provider id")
         .option("--cwd <path>", "Working directory for providers that require it")
         .option("--label <key=value>", "Add label(s) to the agent (can be used multiple times)", collectMultiple, []);
 }
@@ -30,13 +27,6 @@ function parseImportProvider(provider) {
             details: "Usage: paseo import --provider <provider> <id>",
         };
     }
-    if (!IMPORT_PROVIDERS.has(normalizedProvider)) {
-        throw {
-            code: "INVALID_PROVIDER",
-            message: `Unsupported provider: ${normalizedProvider}`,
-            details: `Supported providers: ${IMPORT_PROVIDER_HELP}`,
-        };
-    }
     return normalizedProvider;
 }
 function parseImportLabels(labelFlags) {

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

@@ -20,7 +20,7 @@ export type AgentLsResult = ListResult<AgentListItem>;
 export interface AgentLsOptions extends CommandOptions {
     /** -a: Include archived agents */
     all?: boolean;
-    /** Legacy flag retained for CLI compatibility */
+    /** -g: List agents across all directories */
     global?: boolean;
     /** Filter by specific status */
     status?: string;
@@ -31,11 +31,13 @@ export interface AgentLsOptions extends CommandOptions {
     /** Filter by thinking option ID */
     thinking?: string;
 }
-export declare function buildAgentLsFetchOptions(options: Pick<AgentLsOptions, "all" | "label" | "thinking">): FetchAgentsOptions;
+export declare function buildAgentLsFetchOptions(options: Pick<AgentLsOptions, "all" | "global" | "label" | "thinking">): FetchAgentsOptions;
 /**
  * Agent ls command semantics:
  * - `paseo agent ls`    → active non-archived agents
- * - `paseo agent ls -a` → include archived agents
+ * - `paseo agent ls -g` → global non-archived agents
+ * - `paseo agent ls -a` → active agents, including archived
+ * - `paseo agent ls -ag` → global agents, including archived
  */
 export declare function runLsCommand(options: AgentLsOptions, _command: Command): Promise<AgentLsResult>;
 export {};

package/dist/commands/agent/ls.js

@@ -5,7 +5,7 @@ export function addLsOptions(cmd) {
     return cmd
         .description("List agents. By default excludes archived agents.")
         .option("-a, --all", "Include archived agents")
-        .option("-g, --global", "Legacy no-op (kept for compatibility)")
+        .option("-g, --global", "List agents across all directories")
         .option("--label <key=value>", "Filter by label (can be used multiple times)", collectMultiple, [])
         .option("--thinking <id>", "Filter by thinking option ID");
 }
@@ -104,7 +104,7 @@ export function buildAgentLsFetchOptions(options) {
         daemonFilter.thinkingOptionId = normalizedThinkingOptionId;
     }
     const fetchOptions = {};
-    if (!options.all) {
+    if (!options.global) {
         fetchOptions.scope = "active";
     }
     if (Object.keys(daemonFilter).length > 0) {
@@ -115,7 +115,9 @@ export function buildAgentLsFetchOptions(options) {
 /**
  * Agent ls command semantics:
  * - `paseo agent ls`    → active non-archived agents
- * - `paseo agent ls -a` → include archived agents
+ * - `paseo agent ls -g` → global non-archived agents
+ * - `paseo agent ls -a` → active agents, including archived
+ * - `paseo agent ls -ag` → global agents, including archived
  */
 export async function runLsCommand(options, _command) {
     const host = getDaemonHost({ host: options.host });

package/dist/commands/daemon/local-daemon.js

@@ -1,5 +1,5 @@
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { loadConfig, resolvePaseoHome, spawnProcess } from "@getpaseo/server";
@@ -239,6 +239,84 @@ async function waitForPidExit(pid, timeoutMs) {
     }
     return poll();
 }
+async function waitForDaemonUnreachable(state, timeoutMs) {
+    const host = resolveTcpHostFromListen(state.listen);
+    if (!host) {
+        return true;
+    }
+    const reachableHost = host;
+    const deadline = Date.now() + timeoutMs;
+    async function poll() {
+        const client = await tryConnectToDaemon({ host: reachableHost, timeout: 500 });
+        if (!client) {
+            return true;
+        }
+        await client.close().catch(() => undefined);
+        if (Date.now() >= deadline) {
+            const finalClient = await tryConnectToDaemon({
+                host: reachableHost,
+                timeout: PID_POLL_INTERVAL_MS,
+            });
+            if (!finalClient) {
+                return true;
+            }
+            await finalClient.close().catch(() => undefined);
+            return false;
+        }
+        await sleep(PID_POLL_INTERVAL_MS);
+        return poll();
+    }
+    return poll();
+}
+function removeStalePidFile(state) {
+    if (!state.stalePidFile) {
+        return;
+    }
+    try {
+        unlinkSync(state.pidPath);
+    }
+    catch {
+        // Best-effort cleanup only. The successful lifecycle stop is authoritative.
+    }
+}
+function createNotRunningStopResult(state, pid, message) {
+    return {
+        action: "not_running",
+        home: state.home,
+        pid,
+        forced: false,
+        message,
+    };
+}
+function createStopTimeoutError(state, pid, timeoutMs) {
+    if (!state.running) {
+        const host = resolveTcpHostFromListen(state.listen);
+        return new Error(`Timed out waiting for daemon${host ? ` at ${host}` : ""} to stop after ${Math.ceil(timeoutMs / 1000)}s`);
+    }
+    return new Error(`Timed out waiting for daemon PID ${pid} to stop after ${Math.ceil(timeoutMs / 1000)}s`);
+}
+async function signalDaemonOwnerForStop(state, pid) {
+    if (pid === null) {
+        return createNotRunningStopResult(state, null, "Daemon is not running");
+    }
+    const signaled = await signalProcessTreeOrOwnerSafely(pid, "SIGTERM");
+    if (signaled) {
+        return null;
+    }
+    return createNotRunningStopResult(state, pid, "Daemon process was already stopped");
+}
+async function waitForStopAfterRequest(args) {
+    const { state, pid, timeoutMs, killTimeoutMs, force } = args;
+    let stopped = state.running && pid !== null
+        ? await waitForPidExit(pid, timeoutMs)
+        : await waitForDaemonUnreachable(state, timeoutMs);
+    if (!stopped && force && state.running && pid !== null) {
+        await signalProcessTreeOrOwnerSafely(pid, "SIGKILL");
+        stopped = await waitForPidExit(pid, killTimeoutMs);
+        return { stopped, forced: true };
+    }
+    return { stopped, forced: false };
+}
 function getErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -402,41 +480,31 @@ export async function stopLocalDaemon(options = {}) {
     const timeoutMs = options.timeoutMs ?? DEFAULT_STOP_TIMEOUT_MS;
     const killTimeoutMs = options.killTimeoutMs ?? DEFAULT_KILL_TIMEOUT_MS;
     const state = resolveLocalDaemonState({ home: options.home });
-    if (!state.pidInfo || !state.running) {
-        const staleSuffix = state.stalePidFile && state.pidInfo ? ` (stale PID file for ${state.pidInfo.pid})` : "";
-        return {
-            action: "not_running",
-            home: state.home,
-            pid: state.pidInfo?.pid ?? null,
-            forced: false,
-            message: `Daemon is not running${staleSuffix}`,
-        };
-    }
-    const pid = state.pidInfo.pid;
     const shutdownAttempt = await requestLifecycleShutdown(state, timeoutMs);
     const lifecycleRequested = shutdownAttempt.requested;
+    if (!state.pidInfo || (!state.running && !lifecycleRequested)) {
+        const staleSuffix = state.stalePidFile && state.pidInfo ? ` (stale PID file for ${state.pidInfo.pid})` : "";
+        return createNotRunningStopResult(state, state.pidInfo?.pid ?? null, `Daemon is not running${staleSuffix}`);
+    }
+    const pid = state.pidInfo?.pid ?? null;
     const fallbackMessage = shutdownAttempt.requested ? null : shutdownAttempt.reason;
-    let forced = false;
     if (!lifecycleRequested) {
-        const signaled = await signalProcessTreeOrOwnerSafely(pid, "SIGTERM");
-        if (!signaled) {
-            return {
-                action: "not_running",
-                home: state.home,
-                pid,
-                forced: false,
-                message: "Daemon process was already stopped",
-            };
-        }
-    }
-    let stopped = await waitForPidExit(pid, timeoutMs);
-    if (!stopped && options.force) {
-        forced = true;
-        await signalProcessTreeOrOwnerSafely(pid, "SIGKILL");
-        stopped = await waitForPidExit(pid, killTimeoutMs);
+        const notRunningResult = await signalDaemonOwnerForStop(state, pid);
+        if (notRunningResult)
+            return notRunningResult;
     }
+    const { stopped, forced } = await waitForStopAfterRequest({
+        state,
+        pid,
+        timeoutMs,
+        killTimeoutMs,
+        force: options.force,
+    });
     if (!stopped) {
-        throw new Error(`Timed out waiting for daemon PID ${pid} to stop after ${Math.ceil(timeoutMs / 1000)}s`);
+        throw createStopTimeoutError(state, pid, timeoutMs);
+    }
+    if (lifecycleRequested) {
+        removeStalePidFile(state);
     }
     return {
         action: "stopped",

package/dist/commands/daemon/status.js

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
 import { getOrCreateServerId, findExecutable, execCommand } from "@getpaseo/server";
-import { tryConnectToDaemon } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 import { resolveLocalDaemonState, resolveTcpHostFromListen } from "./local-daemon.js";
 import { resolveNodePathFromPid } from "./runtime-toolchain.js";
 const require = createRequire(import.meta.url);
@@ -55,7 +55,7 @@ function createStatusSchema(status) {
                     if (item.key === "Connected Daemon") {
                         if (item.value === "reachable")
                             return "green";
-                        if (item.value === "not_probed")
+                        if (item.value === "not_probed" || item.value === "auth_required")
                             return "yellow";
                         return "red";
                     }
@@ -100,7 +100,7 @@ function toStatusRows(status) {
     else {
         rows.push({
             key: "Agents",
-            value: "Unavailable (daemon API not reachable)",
+            value: `Unavailable (${status.agentsUnavailableReason ?? "daemon API not reachable"})`,
         });
     }
     if (status.note) {
@@ -164,10 +164,41 @@ function resolveOwnerLabel(uid, hostname) {
     const hostPart = hostname ?? "unknown-host";
     return `${uidPart}@${hostPart}`;
 }
+function classifyDaemonAuthProbeFailure(error) {
+    if (!(error instanceof Error))
+        return null;
+    if (error.message === "Password required")
+        return "auth_required";
+    if (error.message === "Incorrect password")
+        return "auth_failed";
+    return null;
+}
+function describeDaemonAuthProbeFailure(host, failure) {
+    if (failure === "auth_required") {
+        return `Daemon is reachable at ${host} but requires a password. Set PASEO_PASSWORD and retry.`;
+    }
+    return `Daemon is reachable at ${host} but the supplied password was rejected. Check PASEO_PASSWORD and retry.`;
+}
+function describeAgentsUnavailableReason(failure) {
+    if (failure === "auth_required")
+        return "password required";
+    return "incorrect password";
+}
 async function probeDaemonOverWebsocket(args) {
     const { host, state } = args;
-    const client = await tryConnectToDaemon({ host, timeout: 1500 });
-    if (!client) {
+    let client;
+    try {
+        client = await connectToDaemon({ host, timeout: 1500 });
+    }
+    catch (error) {
+        const authFailure = classifyDaemonAuthProbeFailure(error);
+        if (authFailure) {
+            return {
+                connectedDaemon: authFailure,
+                agentsUnavailableReason: describeAgentsUnavailableReason(authFailure),
+                note: describeDaemonAuthProbeFailure(host, authFailure),
+            };
+        }
         if (state.running) {
             return {
                 connectedDaemon: "unreachable",
@@ -247,6 +278,7 @@ function applyProbeToStatus(input) {
         runningAgents: probe.runningAgents !== undefined ? probe.runningAgents : input.runningAgents,
         idleAgents: probe.idleAgents !== undefined ? probe.idleAgents : input.idleAgents,
         daemonProviders: probe.daemonProviders ?? input.daemonProviders,
+        agentsUnavailableReason: probe.agentsUnavailableReason ?? input.agentsUnavailableReason,
         note: probe.note ? appendNote(input.note, probe.note) : input.note,
     };
 }
@@ -288,6 +320,7 @@ export async function runStatusCommand(options, _command) {
     let idleAgents = null;
     let daemonVersion = null;
     let daemonProviders;
+    let agentsUnavailableReason;
     let note;
     if (!state.running && state.stalePidFile && state.pidInfo) {
         localDaemon = "stale_pid";
@@ -303,6 +336,7 @@ export async function runStatusCommand(options, _command) {
             runningAgents,
             idleAgents,
             daemonProviders,
+            agentsUnavailableReason,
             note,
         } = applyProbeToStatus({
             probe,
@@ -313,6 +347,7 @@ export async function runStatusCommand(options, _command) {
             runningAgents,
             idleAgents,
             daemonProviders,
+            agentsUnavailableReason,
             note,
         }));
     }
@@ -346,6 +381,7 @@ export async function runStatusCommand(options, _command) {
         daemonVersion,
         desktopManaged: state.pidInfo?.desktopManaged === true,
         providers,
+        agentsUnavailableReason,
         note,
     };
     return {

package/dist/commands/provider/ls.js

@@ -5,7 +5,7 @@ const PROVIDERS = AGENT_PROVIDER_DEFINITIONS.map((def) => ({
     provider: def.id,
     label: def.label,
     status: "available",
-    enabled: "Enabled",
+    enabled: def.enabledByDefault === false ? "Disabled" : "Enabled",
     defaultMode: def.defaultModeId ?? "-",
     modes: def.modes.length > 0 ? def.modes.map((m) => m.label).join(", ") : "-",
 }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/cli",
-  "version": "0.1.91-beta.1",
+  "version": "0.1.91",
   "description": "Paseo CLI - control your AI coding agents from the command line",
   "bin": {
     "paseo": "bin/paseo"
@@ -27,9 +27,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@getpaseo/client": "0.1.91-beta.1",
-    "@getpaseo/protocol": "0.1.91-beta.1",
-    "@getpaseo/server": "0.1.91-beta.1",
+    "@getpaseo/client": "0.1.91",
+    "@getpaseo/protocol": "0.1.91",
+    "@getpaseo/server": "0.1.91",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",