@hyperdrive.bot/paseo-cli 0.3.33 → 0.3.35

package/dist/commands/provider/add.d.ts

@@ -0,0 +1,23 @@
+import type { Command } from "commander";
+import type { CommandOptions, SingleResult, OutputSchema } from "../../output/index.js";
+export interface ProviderAddRow {
+    provider: string;
+    label: string;
+    extends: string;
+    models: string;
+    reloaded: string;
+}
+export declare const providerAddSchema: OutputSchema<ProviderAddRow>;
+export type ProviderAddResult = SingleResult<ProviderAddRow>;
+export interface ProviderAddOptions extends CommandOptions {
+    host?: string;
+    extends?: string;
+    label?: string;
+    description?: string;
+    env?: string[];
+    model?: string[];
+    disallowedTool?: string[];
+    force?: boolean;
+}
+export declare function runAddCommand(providerId: string, options: ProviderAddOptions, _command: Command): Promise<ProviderAddResult>;
+//# sourceMappingURL=add.d.ts.map

package/dist/commands/provider/add.js

@@ -0,0 +1,110 @@
+import { loadPersistedConfig, resolvePaseoHome, savePersistedConfig, } from "@hyperdrive.bot/paseo-server";
+import { ProviderOverridesSchema } from "@hyperdrive.bot/paseo-protocol/provider-config";
+import { tryConnectToDaemon } from "../../utils/client.js";
+export const providerAddSchema = {
+    idField: "provider",
+    columns: [
+        { header: "PROVIDER", field: "provider", width: 20 },
+        { header: "LABEL", field: "label", width: 24 },
+        { header: "EXTENDS", field: "extends", width: 12 },
+        { header: "MODELS", field: "models", width: 30 },
+        {
+            header: "RELOADED",
+            field: "reloaded",
+            width: 24,
+            color: (value) => (value === "yes" ? "green" : "yellow"),
+        },
+    ],
+};
+/** `--env KEY=VALUE` (repeatable). Values may contain `=`; only the first splits. */
+function parseEnvPairs(pairs) {
+    if (!pairs || pairs.length === 0)
+        return undefined;
+    const env = {};
+    for (const pair of pairs) {
+        const separator = pair.indexOf("=");
+        if (separator <= 0) {
+            throw new Error(`Invalid --env "${pair}". Expected KEY=VALUE.`);
+        }
+        env[pair.slice(0, separator)] = pair.slice(separator + 1);
+    }
+    return env;
+}
+/** `--model id` or `--model id:Label` or `--model id:Label:default` (repeatable). */
+function parseModels(models) {
+    if (!models || models.length === 0)
+        return undefined;
+    return models.map((raw) => {
+        const [id, label, flag] = raw.split(":");
+        if (!id) {
+            throw new Error(`Invalid --model "${raw}". Expected id[:Label[:default]].`);
+        }
+        return {
+            id,
+            label: label && label.length > 0 ? label : id,
+            ...(flag === "default" ? { isDefault: true } : {}),
+        };
+    });
+}
+export async function runAddCommand(providerId, options, _command) {
+    if (!options.extends) {
+        throw new Error(`--extends is required. Choose a built-in provider (claude, codex, copilot, opencode, pi) or "acp".`);
+    }
+    const label = options.label ?? providerId;
+    const paseoHome = resolvePaseoHome();
+    const persisted = loadPersistedConfig(paseoHome);
+    const existingProviders = (persisted.agents?.providers ?? {});
+    if (existingProviders[providerId] && !options.force) {
+        throw new Error(`Provider "${providerId}" already exists in config.json. Pass --force to overwrite.`);
+    }
+    const entry = {
+        extends: options.extends,
+        label,
+        ...(options.description ? { description: options.description } : {}),
+        ...(parseEnvPairs(options.env) ? { env: parseEnvPairs(options.env) } : {}),
+        ...(parseModels(options.model) ? { models: parseModels(options.model) } : {}),
+        ...(options.disallowedTool?.length ? { disallowedTools: options.disallowedTool } : {}),
+    };
+    const nextProviders = { ...existingProviders, [providerId]: entry };
+    // Validate the WHOLE map, not just the new entry: ProviderOverridesSchema's
+    // superRefine enforces the id pattern and the extends/label requirement for
+    // custom providers, and we would rather fail here than write a config.json
+    // the daemon will reject on reload.
+    const parsed = ProviderOverridesSchema.safeParse(nextProviders);
+    if (!parsed.success) {
+        throw new Error(`Invalid provider config: ${parsed.error.issues.map((i) => i.message).join("; ")}`);
+    }
+    savePersistedConfig(paseoHome, {
+        ...persisted,
+        agents: { ...persisted.agents, providers: parsed.data },
+    });
+    // Hot-reload if a daemon is up; if not, the file write still stands and the
+    // provider is picked up on next start. Say which happened — never imply the
+    // running daemon saw it when there was no daemon to see it.
+    let reloaded = "no daemon running";
+    const client = await tryConnectToDaemon({ host: options.host });
+    if (client) {
+        try {
+            const result = await client.reloadProviderConfig();
+            reloaded =
+                result.added.includes(providerId) || result.updated.includes(providerId)
+                    ? "yes"
+                    : "daemon did not pick it up";
+        }
+        finally {
+            await client.close().catch(() => { });
+        }
+    }
+    return {
+        type: "single",
+        data: {
+            provider: providerId,
+            label,
+            extends: options.extends,
+            models: (parseModels(options.model) ?? []).map((m) => m.id).join(", ") || "—",
+            reloaded,
+        },
+        schema: providerAddSchema,
+    };
+}
+//# sourceMappingURL=add.js.map

package/dist/commands/provider/index.js

@@ -1,6 +1,8 @@
 import { Command } from "commander";
+import { runAddCommand } from "./add.js";
 import { runLsCommand } from "./ls.js";
 import { runModelsCommand } from "./models.js";
+import { runReloadCommand } from "./reload.js";
 import { withOutput } from "../../output/index.js";
 import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
 export function createProviderCommand() {
@@ -11,6 +13,25 @@ export function createProviderCommand() {
         .description("List models for a provider")
         .argument("<provider>", "Provider name (claude, codex, opencode)")
         .option("--thinking", "Include thinking option IDs for each model")).action(withOutput(runModelsCommand));
+    addJsonAndDaemonHostOptions(provider
+        .command("reload")
+        .description("Re-read providers from config.json into the running daemon (no restart)")
+        .option("--all", "Also list providers whose config did not change")).action(withOutput(runReloadCommand));
+    addJsonAndDaemonHostOptions(provider
+        .command("add")
+        .description("Add a custom provider to config.json and load it without a restart")
+        .argument("<id>", "Provider id (lowercase, e.g. zai)")
+        .requiredOption("--extends <base>", "Built-in to inherit from: claude, codex, copilot, opencode, pi, or acp")
+        .option("--label <label>", "Display name (defaults to the id)")
+        .option("--description <text>", "Description shown in the provider list")
+        .option("--env <KEY=VALUE>", "Environment variable (repeatable)", collect, [])
+        .option("--model <id[:Label[:default]]>", "Model definition (repeatable)", collect, [])
+        .option("--disallowed-tool <tool>", "Tool to disallow (repeatable)", collect, [])
+        .option("--force", "Overwrite an existing provider entry")).action(withOutput(runAddCommand));
     return provider;
 }
+/** commander repeatable-option accumulator. */
+function collect(value, previous) {
+    return [...previous, value];
+}
 //# sourceMappingURL=index.js.map

package/dist/commands/provider/reload.d.ts

@@ -0,0 +1,21 @@
+import type { Command } from "commander";
+import type { CommandOptions, ListResult, OutputSchema } from "../../output/index.js";
+/**
+ * One row per provider whose config.json entry changed. `unchanged` providers
+ * are omitted from the table by default — a reload that read back an identical
+ * file should look like a no-op, not a wall of rows.
+ */
+export interface ProviderReloadRow {
+    provider: string;
+    change: "added" | "updated" | "removed" | "unchanged";
+    label: string;
+    enabled: string;
+}
+export declare const providerReloadSchema: OutputSchema<ProviderReloadRow>;
+export type ProviderReloadResult = ListResult<ProviderReloadRow>;
+export interface ProviderReloadOptions extends CommandOptions {
+    host?: string;
+    all?: boolean;
+}
+export declare function runReloadCommand(options: ProviderReloadOptions, _command: Command): Promise<ProviderReloadResult>;
+//# sourceMappingURL=reload.d.ts.map

package/dist/commands/provider/reload.js

@@ -0,0 +1,64 @@
+import { connectToDaemon } from "../../utils/client.js";
+export const providerReloadSchema = {
+    idField: "provider",
+    columns: [
+        { header: "PROVIDER", field: "provider", width: 20 },
+        {
+            header: "CHANGE",
+            field: "change",
+            width: 10,
+            color: (value) => {
+                if (value === "added")
+                    return "green";
+                if (value === "removed")
+                    return "red";
+                if (value === "updated")
+                    return "yellow";
+                return undefined;
+            },
+        },
+        { header: "LABEL", field: "label", width: 24 },
+        { header: "ENABLED", field: "enabled", width: 10 },
+    ],
+};
+export async function runReloadCommand(options, _command) {
+    // Deliberately connectToDaemon, not tryConnectToDaemon: a reload with no
+    // daemon running is a no-op the user must hear about, not a silent success.
+    const client = await connectToDaemon({ host: options.host });
+    try {
+        const result = await client.reloadProviderConfig();
+        const labels = new Map(result.providers.map((entry) => [entry.provider, entry]));
+        const rows = [];
+        const push = (provider, change) => {
+            const entry = labels.get(provider);
+            // A removed provider is gone from the registry, so it has no label or
+            // enabled state left to report.
+            const removed = change === "removed";
+            let enabled = "—";
+            if (!removed) {
+                enabled = entry?.enabled === false ? "Disabled" : "Enabled";
+            }
+            rows.push({
+                provider,
+                change,
+                label: entry?.label ?? (removed ? "—" : provider),
+                enabled,
+            });
+        };
+        for (const provider of result.added)
+            push(provider, "added");
+        for (const provider of result.updated)
+            push(provider, "updated");
+        for (const provider of result.removed)
+            push(provider, "removed");
+        if (options.all) {
+            for (const provider of result.unchanged)
+                push(provider, "unchanged");
+        }
+        return { type: "list", data: rows, schema: providerReloadSchema };
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=reload.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperdrive.bot/paseo-cli",
-  "version": "0.3.33",
+  "version": "0.3.35",
   "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",
-    "@hyperdrive.bot/paseo-client": "0.3.33",
-    "@hyperdrive.bot/paseo-protocol": "0.3.33",
-    "@hyperdrive.bot/paseo-server": "0.3.33",
+    "@hyperdrive.bot/paseo-client": "0.3.35",
+    "@hyperdrive.bot/paseo-protocol": "0.3.35",
+    "@hyperdrive.bot/paseo-server": "0.3.35",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",