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

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.d.ts

@@ -1,3 +1,4 @@
+import { type UpdateOutcome } from "./update.js";
 import { Command } from "commander";
 import type { PluginListItem, PluginLogEntry } from "@camerontaylor/paseo-protocol/messages";
 import type { CommandOptions, ListResult, SingleResult } from "../../output/index.js";
@@ -8,10 +9,15 @@ interface PluginOptions extends CommandOptions {
     ref?: string;
     path?: string;
     all?: boolean;
+    version?: string;
+    check?: boolean;
+    yes?: boolean;
 }
 export declare function runPluginInitCommand(directory: string, options: PluginOptions, _command: Command): Promise<SingleResult<PluginScaffold>>;
 export declare function runPluginListCommand(pluginId: string | undefined, options: PluginOptions, _command: Command): Promise<ListResult<PluginListItem>>;
 export declare function runPluginLogsCommand(pluginId: string, options: PluginOptions, _command: Command): Promise<ListResult<PluginLogEntry>>;
+export declare function runPluginInstallCommand(source: string, options: PluginOptions, _command: Command): Promise<SingleResult<PluginListItem>>;
+export declare function runPluginUpdateCommand(pluginId: string | undefined, options: PluginOptions, _command: Command): Promise<ListResult<UpdateOutcome>>;
 export declare function createPluginCommand(): Command;
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/commands/plugin/index.js

@@ -1,19 +1,27 @@
+import { createInterface } from "node:readline/promises";
+import { reviewPluginUpdates } from "./update.js";
 import { Command } from "commander";
-import path from "node:path";
-import { formatPluginSourceReference, parsePluginSourceReference, } from "@camerontaylor/paseo-protocol/plugin-source-reference";
+import { formatPluginSourceReference, formatPluginIdentity, } from "@camerontaylor/paseo-protocol/plugin-source-reference";
 import { withOutput } from "../../output/index.js";
 import { addJsonAndDaemonHostOptions, addJsonOption } from "../../utils/command-options.js";
 import { scaffoldPluginDirectory } from "./scaffold.js";
-import { withPluginLogsClient, withPluginManagementClient, withPluginSourceClient, } from "./shared.js";
+import { withPluginLogsClient, withPluginUpdateClient, withPluginManagementClient, withPluginSourceClient, } from "./shared.js";
 const pluginSchema = {
     idField: "id",
     columns: [
         { header: "PLUGIN", field: "id", width: 20 },
         { header: "STATUS", field: "status", width: 10 },
         { header: "ENABLED", field: (plugin) => (plugin.enabled ? "yes" : "no"), width: 8 },
-        { header: "SOURCE", field: (plugin) => plugin.source ?? "directory", width: 10 },
-        { header: "COMMIT", field: (plugin) => shortCommit(plugin.commit), width: 14 },
-        { header: "REF", field: (plugin) => plugin.ref ?? "-", width: 24 },
+        {
+            header: "SOURCE",
+            field: (plugin) => plugin.installation ? formatPluginIdentity(plugin.installation.identity) : "-",
+            width: 40,
+        },
+        {
+            header: "REVISION",
+            field: (plugin) => plugin.installation?.currentRevision ?? "-",
+            width: 16,
+        },
         { header: "DIRECTORY", field: "path", width: 40 },
         { header: "ERROR", field: (plugin) => plugin.error ?? "", width: 40 },
     ],
@@ -33,17 +41,16 @@ const pluginLogsSchema = {
         { header: "MESSAGE", field: "message", width: 80 },
     ],
 };
-function shortCommit(commit) {
-    return commit?.slice(0, 12) ?? "-";
-}
 const pluginUpdateSchema = {
     idField: "id",
     columns: [
-        { header: "PLUGIN", field: "id", width: 20 },
-        { header: "PREVIOUS", field: (plugin) => shortCommit(plugin.previousCommit), width: 14 },
-        { header: "CURRENT", field: (plugin) => shortCommit(plugin.currentCommit), width: 14 },
-        { header: "COMMITS", field: (plugin) => String(plugin.commits), width: 8 },
-        { header: "UPDATED", field: (plugin) => (plugin.updated ? "yes" : "no"), width: 8 },
+        { header: "PLUGIN", field: "id", width: 24 },
+        { header: "RESULT", field: "outcome", width: 18 },
+        {
+            header: "DETAIL",
+            field: (item) => item.error ?? item.warning ?? item.plugin?.installation?.currentRevision ?? "",
+            width: 50,
+        },
     ],
 };
 export async function runPluginInitCommand(directory, options, _command) {
@@ -54,50 +61,55 @@ 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) {
-    process.stderr.write("Trusting plugin code: server code and Git build commands run unsandboxed on the daemon host; client code runs inside Paseo. Dependencies and future updates are part of the codebase you trust.\n");
-    const isExplicitPath = path.isAbsolute(source) ||
-        source === "." ||
-        source === ".." ||
-        source.startsWith("./") ||
-        source.startsWith("../") ||
-        source.startsWith(".\\") ||
-        source.startsWith("..\\");
-    const hasPluginPathSuffix = parsePluginSourceReference(source).pluginPath !== undefined;
-    const canUseLegacyDirectoryInstall = isExplicitPath && !hasPluginPathSuffix && !options.ref && !options.path;
+export async function runPluginInstallCommand(source, options, _command) {
+    process.stderr.write("Trusting plugin code: server code and preparation commands run unsandboxed on the daemon host; client code runs inside Paseo. Dependencies and future updates are part of the codebase you trust.\n");
     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({
-            source: sourceReference,
-            ...(options.id ? { id: options.id } : {}),
-            ...(options.ref ? { ref: options.ref } : {}),
-        }));
+    const data = await withPluginSourceClient(options.daemonTarget, (client) => client.installPluginSource({
+        source: sourceReference,
+        ...(options.id ? { id: options.id } : {}),
+        ...(options.ref ? { ref: options.ref } : {}),
+    }));
     return { type: "single", data, schema: pluginSchema };
 }
-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));
+export async function runPluginUpdateCommand(pluginId, options, _command) {
+    const data = await withPluginUpdateClient(options.daemonTarget, (client) => reviewPluginUpdates(client, { ...options, pluginId }, {
+        interactive: process.stdin.isTTY === true,
+        structured: options.json === true ||
+            ["json", "yaml"].includes(options.format?.trim().toLowerCase() ?? ""),
+        write: (text) => process.stderr.write(text),
+        confirm: async (message) => {
+            const prompt = createInterface({ input: process.stdin, output: process.stderr });
+            try {
+                return /^(y|yes)$/i.test((await prompt.question(message)).trim());
+            }
+            catch {
+                return false;
+            }
+            finally {
+                prompt.close();
+            }
+        },
+    }));
+    if (data.some((item) => item.outcome === "error"))
+        process.exitCode = 1;
     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}`);
@@ -119,16 +131,20 @@ export function createPluginCommand() {
     addJsonAndDaemonHostOptions(plugin
         .command("install")
         .alias("add")
-        .description("Trust and install a plugin from a directory or Git repository")
-        .argument("<source>", "Host directory, Git source, or Git source:plugin/path")
+        .description("Trust and install a plugin from a directory, Git repository, or npm package")
+        .argument("<source>", "Host directory, Git or npm source, optionally followed by :plugin/path")
         .option("--id <id>", "Runtime plugin ID (defaults to paseo-plugin.json id)")
         .option("--ref <ref>", "Git branch, tag, or commit")
-        .option("--path <path>", "Legacy form of the :plugin/path source suffix")).action(withOutput(install));
+        .option("--path <path>", "Legacy form of the :plugin/path source suffix")).action(withOutput(runPluginInstallCommand));
     addJsonAndDaemonHostOptions(plugin
         .command("update")
-        .description("Fetch and install Git-managed plugin updates")
+        .description("Review and update installed plugins")
         .argument("[id]")
-        .option("--all", "Update every Git-managed plugin")).action(withOutput(update));
+        .option("--all", "Review all configured plugins")
+        .option("--check", "Show available updates without installing")
+        .option("--yes", "Apply displayed updates without asking")
+        .option("--ref <ref>", "Apply a Git branch, tag, or commit without asking")
+        .option("--version <version>", "Apply an npm version, tag, or range without asking")).action(withOutput(runPluginUpdateCommand));
     for (const action of ["reload", "enable", "disable"]) {
         addJsonAndDaemonHostOptions(plugin.command(action).description(`${action} a plugin`).argument("<id>")).action(withOutput((id, options, _command) => act(action, id, options)));
     }

package/dist/commands/plugin/scaffold.js

@@ -130,6 +130,16 @@ export async function scaffoldPluginDirectory(targetDirectory, requestedId) {
         name: id,
         private: true,
         version: "0.0.0",
+        files: [
+            "paseo-plugin.json",
+            "index.client.ts",
+            "index.client.tsx",
+            "index.server.ts",
+            "index.server.tsx",
+            "client/",
+            "server/",
+            "shared/",
+        ],
         scripts: { typecheck: "tsc --noEmit" },
         devDependencies: {
             "@camerontaylor/paseo-plugin": version,

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

@@ -1,5 +1,7 @@
+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>;
+export declare function withPluginUpdateClient<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,20 @@ 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) {
-    // 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);
+export async function withPluginSourceClient(target, run) {
+    // COMPAT(pluginSourceInstallation): added in v0.8.0; remove gate after 2027-03-16 once daemon floor supports source identifiers.
+    return withPluginClient(target, "pluginSourceInstallation", "Update the host to install plugin sources.", run);
+}
+export async function withPluginUpdateClient(target, run) {
+    // COMPAT(pluginSourceUpdates): added in v0.8.0; remove after 2027-03-16 once daemon floor supports reviewed updates.
+    return withPluginClient(target, "pluginSourceUpdates", "Update the host to review plugin updates.", run);
 }
 //# sourceMappingURL=shared.js.map

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

@@ -0,0 +1,37 @@
+import type { PluginUpdatePreview, PluginUpdateResult, PluginUpdateSelection, PluginUpdateProposal } from "@camerontaylor/paseo-protocol/messages";
+interface UpdateClient {
+    previewPluginUpdates(input: {
+        pluginId?: string;
+        target?: PluginUpdateSelection;
+    }): Promise<PluginUpdatePreview[]>;
+    applyPluginUpdates(proposals: PluginUpdateProposal[]): Promise<PluginUpdateResult[]>;
+}
+export interface UpdateOptions {
+    pluginId?: string;
+    all?: boolean;
+    ref?: string;
+    version?: string;
+    check?: boolean;
+    yes?: boolean;
+}
+export interface UpdateInteraction {
+    interactive: boolean;
+    structured: boolean;
+    write(text: string): void;
+    confirm(message: string): Promise<boolean>;
+}
+export interface UpdateOutcome {
+    id: string;
+    outcome: PluginUpdatePreview["outcome"] | PluginUpdateResult["outcome"] | "declined";
+    current?: PluginUpdatePreview["current"];
+    target?: PluginUpdatePreview["target"];
+    links?: string[];
+    proposal?: PluginUpdateProposal;
+    plugin?: PluginUpdateResult["plugin"];
+    error?: string;
+    warning?: string;
+}
+export declare function reviewPluginUpdates(client: UpdateClient, options: UpdateOptions, interaction: UpdateInteraction): Promise<UpdateOutcome[]>;
+export declare function formatUpdatePreview(items: PluginUpdatePreview[]): string;
+export {};
+//# sourceMappingURL=update.d.ts.map

package/dist/commands/plugin/update.js

@@ -0,0 +1,58 @@
+export async function reviewPluginUpdates(client, options, interaction) {
+    if ((options.pluginId === undefined) === (options.all !== true))
+        throw new Error("Choose one plugin ID or pass --all");
+    if (options.ref && options.version)
+        throw new Error("Choose --ref or --version, not both");
+    let target;
+    if (options.ref)
+        target = { kind: "git", ref: options.ref };
+    if (options.version)
+        target = { kind: "npm", version: options.version };
+    if (target && options.all)
+        throw new Error("An explicit target requires one plugin ID, without --all");
+    const preview = await client.previewPluginUpdates({ pluginId: options.pluginId, target });
+    if (!interaction.structured)
+        interaction.write(formatUpdatePreview(preview));
+    if (options.check)
+        return preview;
+    const proposals = preview.flatMap((item) => (item.proposal ? [item.proposal] : []));
+    if (!proposals.length)
+        return preview;
+    if (!options.yes && !target) {
+        if (interaction.structured || !interaction.interactive)
+            throw new Error("Confirmation required; rerun with --yes.");
+        if (!(await interaction.confirm(options.all ? "Update these plugins? [y/N] " : `Update ${options.pluginId}? [y/N] `))) {
+            return preview.map((item) => (item.proposal ? { id: item.id, outcome: "declined" } : item));
+        }
+    }
+    const applied = new Map((await client.applyPluginUpdates(proposals)).map((item) => [item.id, item]));
+    return preview.map((item) => applied.get(item.id) ?? item);
+}
+export function formatUpdatePreview(items) {
+    return items
+        .map((item) => {
+        const current = item.current?.currentRevision ?? "unknown";
+        const target = item.target?.kind === "git" ? item.target.commit : item.target?.version;
+        let text;
+        switch (item.outcome) {
+            case "update":
+                text = `${current} → ${target}`;
+                break;
+            case "current":
+                text = `up to date (${current})`;
+                break;
+            case "installed-newer":
+                text = `installed ${current} is newer than latest ${target}; keeping installed version`;
+                break;
+            case "local":
+                text = "local directory; use Reload after editing";
+                break;
+            case "error":
+                text = item.error ?? "Check failed";
+                break;
+        }
+        return `${item.id}: ${text}\n${item.links.map((link) => `Review: ${link}\n`).join("")}`;
+    })
+        .join("\n");
+}
+//# sourceMappingURL=update.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) {