agentsw 0.10.1 → 0.11.0

package/dist/commands.js

@@ -17,7 +17,7 @@ import { SafeConfigError, drainPendingWrites, readTextIfExists, setDryRun } from
 import { applyModelFilter } from "./filter.js";
 import { availableProviderId, providerIdFromBaseUrl, providerNameFromBaseUrl } from "./slug.js";
 import { t } from "./i18n.js";
-import { cancelInteractive, emitJson, error, isJson, note, out, table } from "./ui.js";
+import { cancelInteractive, emitJson, error, isJson, note, out, table, warn } from "./ui.js";
 import { withProgress } from "./progress.js";
 import { appsReport, listReport, modelsQueryReport, providerMetadataReport, providerModelsReport, statusReport, } from "./report.js";
 /** Share successes and failures without fetching until a model actually needs the supplement. */
@@ -483,12 +483,15 @@ function reportResults(results) {
             out(`${pc.yellow(t("common.skip"))} ${r.app.padEnd(9)} ${pc.dim(r.skipped)}`);
             continue;
         }
-        out(`${pc.green("ok  ")} ${r.app.padEnd(9)} ${r.changed.join(", ")}`);
+        // An empty change list means the app was already in sync: say so rather than
+        // printing a bare "ok" with nothing after it.
+        const detail = r.changed.length ? r.changed.join(", ") : pc.dim(t("preview.unchanged"));
+        out(`${pc.green("ok  ")} ${r.app.padEnd(9)} ${detail}`);
         for (const note of r.notes)
             out(`     ${" ".repeat(9)} ${pc.dim(note)}`);
     }
 }
-async function runTargets(op, provider, appsFilter, redactErrors = false) {
+async function runTargets(op, provider, appsFilter, opts = {}) {
     const selected = resolveTargets(appsFilter);
     const explicit = appsFilter !== undefined && appsFilter !== "all";
     const results = [];
@@ -502,6 +505,18 @@ async function runTargets(op, provider, appsFilter, redactErrors = false) {
             });
             continue;
         }
+        if (op === "apply" && opts.oneSlot && target.singleProvider && provider.id !== opts.oneSlot.winners.get(target.id)) {
+            const winner = opts.oneSlot.winners.get(target.id);
+            results.push({
+                app: target.id,
+                changed: [],
+                notes: [],
+                skipped: winner === undefined
+                    ? `${target.name} holds one provider at a time; left as it is because this run does not say which`
+                    : `${target.name} holds one provider at a time; written for ${winner}`,
+            });
+            continue;
+        }
         try {
             if (!explicit && !target.detect()) {
                 results.push({ app: target.id, changed: [], notes: [], skipped: `${target.name} not detected (pass --apps ${target.id} to force)` });
@@ -510,7 +525,7 @@ async function runTargets(op, provider, appsFilter, redactErrors = false) {
             results.push(await target[op](provider));
         }
         catch (err) {
-            const safe = redactErrors && !(err instanceof SafeConfigError);
+            const safe = opts.redactErrors === true && !(err instanceof SafeConfigError);
             results.push({ app: target.id, changed: [], notes: [], skipped: pc.red(`failed: ${safe ? t("preview.failedSafely") : err.message}`) });
             process.exitCode = 1;
         }
@@ -629,20 +644,20 @@ function printFileDiff(file, next, apiKey) {
     if (oldText === newText)
         out(pc.dim(t("preview.onlyRedacted")));
 }
-async function runWithOptionalDryRun(op, provider, apps, dryRun) {
+async function runWithOptionalDryRun(op, provider, apps, dryRun, oneSlot) {
     const summarize = (results, files) => ({
         apps: results.map((r) => r.app),
         files,
         skipped: results.filter((r) => r.skipped).map((r) => ({ app: r.app, reason: r.skipped })),
     });
     if (!dryRun) {
-        const results = await runTargets(op, provider, apps);
+        const results = await runTargets(op, provider, apps, { oneSlot });
         reportResults(results);
         return summarize(results, results.flatMap((r) => (r.skipped ? [] : r.changed)));
     }
     setDryRun(true);
     try {
-        const results = await runTargets(op, provider, apps, true);
+        const results = await runTargets(op, provider, apps, { redactErrors: true, oneSlot });
         const writes = drainPendingWrites();
         for (const r of results) {
             if (r.skipped)
@@ -662,12 +677,25 @@ export async function cmdUse(id, opts) {
     resolveTargets(opts.apps);
     const store = loadStore();
     const provider = getProvider(store, id);
-    if (opts.model) {
-        if (!provider.models.some((m) => m.id === opts.model)) {
-            fail(t("use.modelMissing", { model: opts.model, id, have: provider.models.map((m) => m.id).join(", ") }));
+    const requireConfigured = (model) => {
+        if (!provider.models.some((m) => m.id === model)) {
+            fail(t("use.modelMissing", { model, id, have: provider.models.map((m) => m.id).join(", ") }));
         }
+    };
+    if (opts.model) {
+        requireConfigured(opts.model);
         provider.defaultModel = opts.model;
     }
+    // The slot agents reach for cheap background work — Claude Code's haiku variables. Leaving it
+    // unset means "same as the default model", so an expensive default silently becomes the
+    // background model too; `--no-small-model` returns the slot to that fallback.
+    if (typeof opts.smallModel === "string") {
+        requireConfigured(opts.smallModel);
+        provider.smallModel = opts.smallModel;
+    }
+    else if (opts.smallModel === false) {
+        delete provider.smallModel;
+    }
     if (!opts.dryRun) {
         store.active = id;
         saveStore(store);
@@ -678,18 +706,189 @@ export async function cmdUse(id, opts) {
         emitJson({ provider: id, model: provider.defaultModel, dryRun: opts.dryRun === true, ...outcome });
     }
 }
+/**
+ * Shared by `discover` and `sync`: fetch the live model list, re-enrich from the catalog, persist.
+ * `pinned` ids survive a listing that dropped them, so they are not reported as "removed upstream".
+ * `save: false` keeps the refreshed list in memory for the caller to preview: a dry run shows what a
+ * real sync would write without leaving the fetched list behind in the store.
+ */
+async function refreshProviderModels(store, provider, save = true) {
+    const listed = await withProgress(t("add.discovering", { url: provider.baseUrl }), (progress) => discoverProviderModels(provider, {
+        onPage: ({ page, count }) => progress.update(t("progress.discoverPage", { url: provider.baseUrl, page, count })),
+    }));
+    const pinned = [provider.defaultModel, provider.smallModel].filter((model) => !!model);
+    const outcome = applyModelFilter(listed, provider.modelFilter, pinned);
+    reportDropped(outcome.dropped);
+    const ids = outcome.kept;
+    const retained = new Set([...ids, ...pinned]);
+    const known = provider.models.map((m) => m.id);
+    const added = ids.filter((m) => !known.includes(m));
+    const removed = known.filter((m) => !retained.has(m));
+    const catalog = await withProgress(t("progress.catalog"), () => loadCatalog());
+    provider.models = await withProgress(t("progress.metadata"), () => enrichProviderModels(catalog, [...retained], { ...provider, modelsDevId: provider.modelsDevId ?? guessProviderHint(catalog, provider.baseUrl) }));
+    // Reported by the caller, where it reads after the table or the per-app results instead of
+    // scrolling away above them.
+    const missing = [...new Set(pinned)].filter((model) => !ids.includes(model));
+    if (save)
+        saveStore(store);
+    return { ids, added, removed, missing, catalog };
+}
+function printModelRefresh(provider, refresh) {
+    out(`${pc.bold(provider.id)}: ${refresh.ids.length} models (${pc.green(`+${refresh.added.length}`)} / ${pc.red(`-${refresh.removed.length}`)})` +
+        (refresh.added.length ? `\n  new: ${refresh.added.join(", ")}` : "") +
+        (refresh.removed.length ? `\n  removed upstream: ${refresh.removed.join(", ")}` : ""));
+    out(table(modelRows(provider.models), MODEL_HEADER, MODEL_TABLE_OPTIONS));
+    printUncatalogedHint(provider.models, refresh.catalog, provider.modelsDevId);
+}
+/** Comma-separated ids, the same shape `--apps` takes. Repeats collapse; blanks are ignored. */
+function splitProviderList(value) {
+    return [...new Set(value.split(",").map((id) => id.trim()).filter(Boolean))];
+}
+/**
+ * One provider selection for every command that acts on providers: `--all` takes every configured
+ * one, `--provider` takes a comma-separated list, and `fallback` says what no selection means —
+ * `"active"` for the commands that write (sync), `"all"` for the ones that only read and refresh.
+ * Every id is resolved up front so an unknown one fails before the first network call, never after
+ * half a run has been saved. An empty store is an error only when `--all` asked for it by name; the
+ * implicit all-providers fallback keeps reporting zero, as it did before there was a flag.
+ */
+function resolveProviderIds(store, opts, fallback) {
+    if (opts.all && opts.provider !== undefined)
+        fail(t("select.allAndProvider"));
+    let ids;
+    if (opts.all) {
+        ids = Object.keys(store.providers);
+        if (!ids.length)
+            fail(t("select.noProviders"));
+    }
+    else if (opts.provider !== undefined) {
+        ids = splitProviderList(opts.provider);
+        if (!ids.length)
+            fail(t("select.noneSelected"));
+    }
+    else if (fallback === "all") {
+        ids = Object.keys(store.providers);
+    }
+    else {
+        if (!store.active)
+            fail(t("sync.noActive"));
+        ids = [store.active];
+    }
+    for (const id of ids)
+        getProvider(store, id);
+    return ids;
+}
+/**
+ * Apps that name a single provider are written once (see `RunTargetsOptions.oneSlot`); for the rest
+ * the last writer owns whatever "current" pointer the app keeps, so a multi-provider sync finishes
+ * on the active provider and leaves the agents where the store says they already are.
+ */
+function activeLast(store, ids) {
+    const active = store.active;
+    if (ids.length < 2 || !active || !ids.includes(active))
+        return ids;
+    return [...ids.filter((id) => id !== active), active];
+}
+/**
+ * Which provider each single-slot app should receive. The active provider wins where the app can
+ * accept it; where it cannot — Claude Code takes anthropic endpoints only, and the active provider
+ * may well be an openai one — the single compatible provider in the run wins instead, because
+ * writing the only candidate takes nothing away. With several compatible candidates and no active
+ * provider among them the choice is the user's, so the app is left pointing where it already does.
+ */
+function oneSlotWinners(selected, store, ids) {
+    const winners = new Map();
+    for (const target of selected) {
+        if (!target.singleProvider)
+            continue;
+        const usable = ids.filter((id) => supportsProtocol(target, store.providers[id].protocol));
+        const winner = store.active !== undefined && usable.includes(store.active)
+            ? store.active
+            : usable.length === 1 ? usable[0] : undefined;
+        if (winner !== undefined)
+            winners.set(target.id, winner);
+    }
+    return winners;
+}
+/** Section separator plus the tail line that says how many of several providers came through. */
+function printMultiSummary(count, failed, key) {
+    const done = count - failed;
+    out(`\n${failed
+        ? pc.yellow(t(key === "sync" ? "sync.summaryFailed" : "discover.summaryFailed", { ok: done, count }))
+        : t(key === "sync" ? "sync.summaryOk" : "discover.summaryOk", { count })}`);
+}
 export async function cmdSync(opts) {
-    resolveTargets(opts.apps);
+    const selectedTargets = resolveTargets(opts.apps);
     const store = loadStore();
-    const id = opts.provider ?? store.active;
-    if (!id)
-        fail(t("sync.noActive"));
-    const provider = getProvider(store, id);
-    out(`${t("sync.syncing", { id: pc.bold(id), model: provider.defaultModel })}\n`);
-    const outcome = await runWithOptionalDryRun("apply", provider, opts.apps, opts.dryRun);
+    const ids = activeLast(store, resolveProviderIds(store, opts, "active"));
+    const many = ids.length > 1;
+    const oneSlot = many ? { winners: oneSlotWinners(selectedTargets, store, ids) } : undefined;
+    const saveRefresh = opts.dryRun !== true;
+    const reports = [];
+    let failed = 0;
+    for (const [index, id] of ids.entries()) {
+        const provider = getProvider(store, id);
+        if (index)
+            out("");
+        let refresh;
+        if (opts.refresh !== false) {
+            try {
+                refresh = await refreshProviderModels(store, provider, saveRefresh);
+            }
+            catch (err) {
+                // One unreachable provider must not strand the others: report it, write nothing for it,
+                // and fail the run. A single-provider sync has nothing else to do, so it still throws.
+                if (!many)
+                    throw new Error(`${err.message}\n${t("sync.refreshFailed")}`);
+                warn(t("sync.refreshSkipped", { id, message: err.message }));
+                process.exitCode = 1;
+                failed += 1;
+                reports.push({ provider: id, refreshFailed: true });
+                continue;
+            }
+            if (!isJson()) {
+                printModelRefresh(provider, refresh);
+                // --dry-run promises to write nothing, so say the fetched list only lived long enough to preview.
+                if (!saveRefresh)
+                    note(t("sync.refreshNotSaved"));
+            }
+        }
+        out(`${t("sync.syncing", { id: pc.bold(id), model: provider.defaultModel })}\n`);
+        const outcome = await runWithOptionalDryRun("apply", provider, opts.apps, opts.dryRun, oneSlot);
+        if (refresh?.missing.length) {
+            const models = refresh.missing.join(", ");
+            warn(t(opts.dryRun ? "refresh.pinnedMissing" : "sync.pinnedMissingWritten", { models, id }));
+        }
+        reports.push({
+            provider: id,
+            model: provider.defaultModel,
+            ...(refresh
+                ? {
+                    refreshed: {
+                        models: refresh.ids.length,
+                        added: refresh.added,
+                        removed: refresh.removed,
+                        missing: refresh.missing,
+                        saved: saveRefresh,
+                    },
+                }
+                : {}),
+            ...outcome,
+        });
+    }
     if (isJson()) {
-        emitJson({ provider: id, model: provider.defaultModel, dryRun: opts.dryRun === true, ...outcome });
+        const first = reports[0] ?? {};
+        emitJson(many
+            ? {
+                dryRun: opts.dryRun === true,
+                providers: reports,
+                files: [...new Set(reports.flatMap((report) => report.files ?? []))],
+            }
+            : { ...first, dryRun: opts.dryRun === true });
+        return;
     }
+    if (many)
+        printMultiSummary(ids.length, failed, "sync");
 }
 export function cmdStatus() {
     const store = loadStore();
@@ -767,7 +966,8 @@ export async function cmdModels(query, opts) {
 }
 export async function cmdRefreshMeta(opts = {}) {
     const store = loadStore();
-    const providers = opts.provider ? [getProvider(store, opts.provider)] : Object.values(store.providers);
+    // Omitting the selection still means every provider: this command only reads catalogs.
+    const providers = resolveProviderIds(store, opts, "all").map((id) => getProvider(store, id));
     resolveMetadataOptions(opts);
     for (const provider of providers)
         Object.assign(provider, resolveMetadataOptions(opts, provider));
@@ -794,50 +994,61 @@ export async function cmdRefreshMeta(opts = {}) {
     for (const provider of providers)
         printUncatalogedHint(provider.models, catalog, provider.modelsDevId);
 }
-export async function cmdDiscover(id, opts) {
+export async function cmdDiscover(ids, opts) {
     resolveTargets(opts.apps);
     const store = loadStore();
-    const provider = getProvider(store, id);
-    Object.assign(provider, resolveMetadataOptions(opts, provider));
-    // flags override and re-persist the filter; --no-filter clears it
-    const flagFilter = parseFilterOpts(opts, provider.modelFilter);
-    if (opts.filter === false)
-        provider.modelFilter = undefined;
-    else if (flagFilter)
-        provider.modelFilter = flagFilter;
-    const listed = await withProgress(t("add.discovering", { url: provider.baseUrl }), (progress) => discoverProviderModels(provider, {
-        onPage: ({ page, count }) => progress.update(t("progress.discoverPage", { url: provider.baseUrl, page, count })),
-    }));
-    const pinned = [provider.defaultModel, provider.smallModel].filter((model) => !!model);
-    const outcome = applyModelFilter(listed, provider.modelFilter, pinned);
-    reportDropped(outcome.dropped);
-    const ids = outcome.kept;
-    // Pinned ids survive a listing that dropped them, so they are not "removed upstream".
-    const retainedIds = [...new Set([...ids, ...pinned])];
-    const retained = new Set(retainedIds);
-    const known = provider.models.map((m) => m.id);
-    const added = ids.filter((m) => !known.includes(m));
-    const gone = known.filter((m) => !retained.has(m));
-    const catalog = await withProgress(t("progress.catalog"), () => loadCatalog());
-    provider.models = await withProgress(t("progress.metadata"), () => enrichProviderModels(catalog, retainedIds, { ...provider, modelsDevId: provider.modelsDevId ?? guessProviderHint(catalog, provider.baseUrl) }));
-    if (!ids.includes(provider.defaultModel)) {
-        out(pc.yellow(t("discover.defaultMissing", { model: provider.defaultModel })));
+    // Ids may arrive as positional arguments, as one comma-separated list, or through `-p` for
+    // symmetry with sync; all three say the same thing, so accept them together.
+    const listed = [...(Array.isArray(ids) ? ids : [ids ?? ""]), opts.provider ?? ""].filter(Boolean).join(",");
+    const selected = resolveProviderIds(store, { provider: listed || undefined, all: opts.all }, "active");
+    // Reject bad metadata options once, before the first provider is contacted.
+    resolveMetadataOptions(opts);
+    const many = selected.length > 1;
+    const reports = [];
+    const refreshed = [];
+    for (const [index, id] of selected.entries()) {
+        const provider = getProvider(store, id);
+        if (index)
+            out("");
+        Object.assign(provider, resolveMetadataOptions(opts, provider));
+        // flags override and re-persist the filter; --no-filter clears it
+        const flagFilter = parseFilterOpts(opts, provider.modelFilter);
+        if (opts.filter === false)
+            provider.modelFilter = undefined;
+        else if (flagFilter)
+            provider.modelFilter = flagFilter;
+        let refresh;
+        try {
+            refresh = await refreshProviderModels(store, provider);
+        }
+        catch (err) {
+            // One unreachable endpoint must not strand the others; a single provider still throws.
+            if (!many)
+                throw err;
+            warn(t("sync.refreshSkipped", { id, message: err.message }));
+            process.exitCode = 1;
+            reports.push({ provider: id, refreshFailed: true });
+            continue;
+        }
+        refreshed.push(id);
+        reports.push({ provider: id, models: refresh.ids.length, added: refresh.added, removed: refresh.removed, missing: refresh.missing });
+        if (!isJson())
+            printModelRefresh(provider, refresh);
+        if (refresh.missing.length)
+            warn(t("refresh.pinnedMissing", { models: refresh.missing.join(", "), id }));
     }
-    saveStore(store);
     if (isJson()) {
-        emitJson({ provider: id, models: ids.length, added, removed: gone });
+        emitJson(many ? { providers: reports } : (reports[0] ?? {}));
         return;
     }
-    out(`${pc.bold(id)}: ${ids.length} models (${pc.green(`+${added.length}`)} / ${pc.red(`-${gone.length}`)})` +
-        (added.length ? `\n  new: ${added.join(", ")}` : "") +
-        (gone.length ? `\n  removed upstream: ${gone.join(", ")}` : ""));
-    out(table(modelRows(provider.models), MODEL_HEADER, MODEL_TABLE_OPTIONS));
-    printUncatalogedHint(provider.models, catalog, provider.modelsDevId);
-    if (opts.sync) {
+    if (many)
+        printMultiSummary(selected.length, selected.length - refreshed.length, "discover");
+    if (opts.sync && refreshed.length) {
         out("");
-        await cmdSync({ provider: id, apps: opts.apps });
+        // The lists are already fresh: write them without a second fetch.
+        await cmdSync({ provider: refreshed.join(","), apps: opts.apps, refresh: false });
     }
-    else {
+    else if (!opts.sync) {
         note(`\n${t("discover.next")}`);
     }
 }

package/dist/config-transaction.js

@@ -144,26 +144,31 @@ export function commitFileChanges(changes, opts = {}) {
     return withWriteLock(() => {
         // Another writer may have committed between planning and acquiring the lock.
         validateReads();
+        // Only a file that already existed has anything to save. When every planned
+        // file is new, no transaction directory is created: an empty one (nothing but
+        // its manifest) would read as a backup that does not exist.
         let backupDir;
         let currentFile = backupsDir;
         try {
-            fs.mkdirSync(backupsDir, { recursive: true, mode: 0o700 });
-            backupDir = fs.mkdtempSync(path.join(backupsDir, "transaction-"));
-            fs.chmodSync(backupDir, 0o700);
-            for (const [index, change] of plan.entries()) {
-                currentFile = change.file;
-                if (change.before === undefined)
-                    continue;
-                const backup = path.join(backupDir, `${index}-${path.basename(change.file)}`);
-                fs.writeFileSync(backup, change.before, { flag: "wx", mode: 0o600 });
-                fs.chmodSync(backup, 0o600);
+            if (plan.some((change) => change.before !== undefined)) {
+                fs.mkdirSync(backupsDir, { recursive: true, mode: 0o700 });
+                backupDir = fs.mkdtempSync(path.join(backupsDir, "transaction-"));
+                fs.chmodSync(backupDir, 0o700);
+                for (const [index, change] of plan.entries()) {
+                    currentFile = change.file;
+                    if (change.before === undefined)
+                        continue;
+                    const backup = path.join(backupDir, `${index}-${path.basename(change.file)}`);
+                    fs.writeFileSync(backup, change.before, { flag: "wx", mode: 0o600 });
+                    fs.chmodSync(backup, 0o600);
+                }
+                fs.writeFileSync(path.join(backupDir, "manifest.json"), JSON.stringify(plan.map((change, index) => ({
+                    file: change.file,
+                    backup: change.before === undefined ? null : `${index}-${path.basename(change.file)}`,
+                    mode: change.original.mode,
+                })), null, 2) + "\n", { flag: "wx", mode: 0o600 });
+                fs.chmodSync(path.join(backupDir, "manifest.json"), 0o600);
             }
-            fs.writeFileSync(path.join(backupDir, "manifest.json"), JSON.stringify(plan.map((change, index) => ({
-                file: change.file,
-                backup: change.before === undefined ? null : `${index}-${path.basename(change.file)}`,
-                mode: change.original.mode,
-            })), null, 2) + "\n", { flag: "wx", mode: 0o600 });
-            fs.chmodSync(path.join(backupDir, "manifest.json"), 0o600);
             validateReads();
         }
         catch {
@@ -216,7 +221,7 @@ export function commitFileChanges(changes, opts = {}) {
                 }
                 catch { /* Only remove empty directories created by this transaction. */ }
             }
-            throw new Error(`${currentFile}: configuration transaction failed; ${failed.length ? `rollback incomplete for ${failed.join(", ")}` : "previous writes rolled back"}; backups: ${backupDir}`);
+            throw new Error(`${currentFile}: configuration transaction failed; ${failed.length ? `rollback incomplete for ${failed.join(", ")}` : "previous writes rolled back"}${backupDir ? `; backups: ${backupDir}` : "; no files needed backing up"}`);
         }
         return { files, backupDir };
     });

package/dist/i18n.js

@@ -14,10 +14,10 @@ const messages = {
     "cmd.prune": { en: "remove a provider's entries from app configs (keeps it in agentsw)", "zh-CN": "从应用配置移除供应商条目(仍保留在 agentsw)" },
     "cmd.rename": { en: "rename a provider and migrate config references with backups", "zh-CN": "重命名供应商并迁移配置引用（自动备份）" },
     "cmd.use": { en: "set the active provider and write it into app configs", "zh-CN": "设为当前供应商并写入应用配置" },
-    "cmd.sync": { en: "re-apply the active provider (or --provider) to app configs", "zh-CN": "将当前供应商(或 --provider)重新应用到应用配置" },
+    "cmd.sync": { en: "refresh a provider's model list and re-apply it to app configs (--no-refresh writes the saved list)", "zh-CN": "刷新供应商模型列表并重新应用到应用配置(--no-refresh 只写入已保存的列表)" },
     "cmd.status": { en: "show detected apps and what they currently point at", "zh-CN": "显示检测到的应用及当前供应商" },
     "cmd.models": { en: "search models.dev, or show a configured provider's models", "zh-CN": "搜索 models.dev 或显示已配置供应商的模型" },
-    "cmd.discover": { en: "refresh a provider's model list and configured metadata sources", "zh-CN": "获取供应商模型列表，并通过已启用的目录补全参数" },
+    "cmd.discover": { en: "refresh model lists and configured metadata sources for one or more providers", "zh-CN": "刷新一个或多个供应商的模型列表，并通过已启用的目录补全参数" },
     "cmd.import": { en: "scan app configs, preview and dedupe existing custom providers, then import", "zh-CN": "扫描应用配置,预览并去重已有自定义供应商后导入" },
     "cmd.apps": { en: "check installed agents: current version vs latest", "zh-CN": "检查智能体已安装版本与最新版本" },
     "cmd.install": { en: "install an agent CLI", "zh-CN": "安装智能体 CLI" },
@@ -35,6 +35,7 @@ const messages = {
     "opt.models": { en: "comma-separated model ids", "zh-CN": "逗号分隔的模型 id" },
     "opt.defaultModel": { en: "default model (defaults to first)", "zh-CN": "默认模型(默认取第一个)" },
     "opt.smallModel": { en: "small/fast model (Claude Code haiku slot)", "zh-CN": "小型/快速模型(Claude Code haiku 槽位)" },
+    "opt.noSmallModel": { en: "clear the small/fast model so the default model fills that slot", "zh-CN": "清除小型/快速模型,该槽位改用默认模型" },
     "opt.reasoning": { en: "preferred reasoning effort (codex): minimal|low|medium|high", "zh-CN": "Codex 首选推理等级: minimal|low|medium|high" },
     "opt.discover": { en: "list model ids from the provider's /v1/models", "zh-CN": "从供应商 /v1/models 获取模型 id" },
     "opt.include": { en: "keep only models matching comma-separated globs", "zh-CN": "仅保留匹配逗号分隔 glob 的模型" },
@@ -47,7 +48,7 @@ const messages = {
     "opt.noGatewayMetadata": { en: "disable Gateway fetching; keep saved parameters (same as --metadata-mode off)", "zh-CN": "关闭 Gateway 获取，保留已保存参数（等同 --metadata-mode off）" },
     "opt.gatewayModels": { en: 'replace exact aliases as JSON: {"local-id":"creator/model"}; {} clears them', "zh-CN": '用 JSON 替换精确映射：{"本地模型ID":"creator/model"}；{} 清空' },
     "opt.metadataDetails": { en: "show field sources, conflicts and Gateway reference pricing as JSON (requires --provider)", "zh-CN": "以 JSON 查看字段来源、冲突和 Gateway 参考价格（需 --provider）" },
-    "opt.refreshProvider": { en: "refresh/configure only this saved provider (default: all)", "zh-CN": "仅刷新和设置该供应商（默认全部）" },
+    "opt.refreshProvider": { en: "refresh/configure only these saved providers, comma-separated (default: all)", "zh-CN": "仅刷新和设置这些供应商，逗号分隔（默认全部）" },
     "opt.yes": { en: "non-interactive; require all flags", "zh-CN": "非交互模式;要求提供全部参数" },
     "opt.prune": { en: "also remove entries from app configs", "zh-CN": "同时从应用配置中移除条目" },
     "opt.apps": { en: "comma-separated apps or 'all'", "zh-CN": "逗号分隔的应用或 'all'" },
@@ -56,9 +57,12 @@ const messages = {
     "opt.appsDetailed": { en: "comma-separated apps (claude,codex,omp,pi,prime,opencode,hermes,workbuddy,dsh) or 'all'", "zh-CN": "逗号分隔的应用(claude,codex,omp,pi,prime,opencode,hermes,workbuddy,dsh)或 'all'" },
     "opt.model": { en: "override default model while switching", "zh-CN": "切换时覆盖默认模型" },
     "opt.dryRun": { en: "preview config diff without writing", "zh-CN": "仅预览配置差异,不写入" },
-    "opt.provider": { en: "sync this provider instead of the active one", "zh-CN": "同步指定供应商而非当前供应商" },
+    "opt.provider": { en: "sync these providers instead of the active one (comma-separated)", "zh-CN": "同步指定供应商而非当前供应商(逗号分隔)" },
+    "opt.syncAll": { en: "sync every configured provider", "zh-CN": "同步全部已配置的供应商" },
+    "opt.refreshAll": { en: "refresh every configured provider", "zh-CN": "刷新全部已配置的供应商" },
     "opt.showProvider": { en: "show models of a configured provider", "zh-CN": "显示已配置供应商的模型" },
     "opt.refresh": { en: "force-refresh models.dev cache", "zh-CN": "强制刷新 models.dev 缓存" },
+    "opt.noRefresh": { en: "skip the model-list refresh; write the saved list only", "zh-CN": "跳过模型列表刷新;只写入已保存的列表" },
     "opt.limit": { en: "maximum results", "zh-CN": "最大结果数" },
     "opt.syncAfter": { en: "push refreshed provider into app configs", "zh-CN": "刷新后推送到应用配置" },
     "opt.appsSync": { en: "apps to sync when --sync is set", "zh-CN": "--sync 时要同步的应用" },
@@ -80,8 +84,7 @@ const messages = {
     "menu.use": { en: "Switch provider and default model", "zh-CN": "切换供应商和默认模型" },
     "menu.status": { en: "View each agent's current configuration", "zh-CN": "查看各智能体当前配置" },
     "menu.list": { en: "View providers saved in agentsw", "zh-CN": "查看 agentsw 供应商列表" },
-    "menu.sync": { en: "Re-sync the current provider to agents", "zh-CN": "重新同步当前供应商" },
-    "menu.discover": { en: "Update a provider's model list", "zh-CN": "更新供应商模型列表" },
+    "menu.sync": { en: "Sync providers", "zh-CN": "同步供应商" },
     "menu.metadata": { en: "Configure and refresh model metadata", "zh-CN": "设置并刷新模型参数补充源" },
     "menu.metadataHelp": { en: "Keep the model list; choose automatic, always-on or disabled AI Gateway lookup, then refresh saved parameters only.", "zh-CN": "保留模型列表，选择 AI Gateway 自动按需、始终补充或关闭，仅刷新保存的参数。" },
     "menu.metadataProvider": { en: "which provider's metadata settings should be updated?", "zh-CN": "选择要设置模型参数补充源的供应商" },
@@ -128,8 +131,8 @@ const messages = {
     "menu.appsAll": { en: "all {count} detected apps", "zh-CN": "全部 {count} 个检测到的应用" },
     "menu.appNotDetected": { en: "(not detected)", "zh-CN": "(未检测到)" },
     "menu.appsHint": { en: "↑/↓ move · Space toggle · Enter confirm", "zh-CN": "↑/↓ 移动 · 空格切换 · Enter 确认" },
-    "menu.discoverFor": { en: "which provider's model list should be updated?", "zh-CN": "选择要更新模型列表的供应商" },
-    "menu.pushRefresh": { en: "also sync this provider to agent configs after updating its model list?", "zh-CN": "更新模型列表后，是否同时将该供应商同步到智能体配置？" },
+    "menu.syncFor": { en: "which providers should be synced?", "zh-CN": "选择要同步的供应商(可多选)" },
+    "menu.providersAll": { en: "all {count} configured providers", "zh-CN": "全部 {count} 个已配置供应商" },
     "menu.removeProvider": { en: "which provider configuration should be deleted?", "zh-CN": "选择要删除配置的供应商" },
     "menu.upgrade": { en: "upgrade all installed agents that have updates?", "zh-CN": "是否升级所有有新版本的已安装智能体？" },
     "menu.installApp": { en: "Install a new coding agent", "zh-CN": "安装新的智能体" },
@@ -205,8 +208,7 @@ const messages = {
     "menu.useHelp": { en: "Select a provider and default model, then write them to compatible agent configs.", "zh-CN": "选择供应商和默认模型，然后写入支持该协议的智能体配置。" },
     "menu.statusHelp": { en: "Show detected agents, their current providers and config file locations.", "zh-CN": "查看检测到的智能体、所用供应商及配置文件位置。" },
     "menu.listHelp": { en: "Show only the providers, protocols and default models saved in agentsw.", "zh-CN": "只查看 agentsw 已保存的供应商、协议和默认模型。" },
-    "menu.syncHelp": { en: "Write the current agentsw provider to agent configs without fetching a model list or metadata catalogs.", "zh-CN": "将 agentsw 当前供应商写入智能体配置，不重新获取模型列表或元数据目录。" },
-    "menu.discoverHelp": { en: "Fetch models from the provider, fill in model metadata, and optionally sync to agents.", "zh-CN": "从供应商接口重新获取模型并补全模型参数，可选择同步到智能体。" },
+    "menu.syncHelp": { en: "Fetch each selected provider's current model list, fill in saved parameters, then write them to the selected agent configs.", "zh-CN": "依次获取所选供应商的最新模型列表并补全保存的参数，然后写入所选智能体配置。" },
     "menu.renameHelp": { en: "Change the config ID and update references; keep custom display names.", "zh-CN": "修改配置中的标识并更新关联引用，保留自定义显示名称。" },
     "menu.removeHelp": { en: "Choose where to delete: agentsw only, one agent only, or both.", "zh-CN": "先选择删除范围：仅 agentsw、仅某个智能体，或两处一起。" },
     "menu.appsHelp": { en: "Compare installed and latest versions, then choose whether to upgrade.", "zh-CN": "对比已安装版本和最新版本，再选择是否升级。" },
@@ -241,6 +243,14 @@ const messages = {
     "use.switching": { en: "switching to {id} ({protocol}) · default model {model}", "zh-CN": "正在切换到 {id} ({protocol})· 默认模型 {model}" },
     "sync.noActive": { en: "no active provider; run agentsw use <id> first", "zh-CN": "没有当前供应商;请先运行 agentsw use <id>" },
     "sync.syncing": { en: "syncing provider {id} · default model {model}", "zh-CN": "正在同步供应商 {id} · 默认模型 {model}" },
+    "select.allAndProvider": { en: "--all cannot be combined with a provider selection", "zh-CN": "--all 不能与指定的供应商同时使用" },
+    "select.noProviders": { en: "no providers configured; run agentsw add first", "zh-CN": "尚未配置任何供应商;请先运行 agentsw add" },
+    "select.noneSelected": { en: "the provider selection is empty; name at least one id", "zh-CN": "未指定任何供应商,至少需要一个 id" },
+    "sync.refreshSkipped": { en: "skipping {id}: {message}", "zh-CN": "已跳过 {id}:{message}" },
+    "sync.summaryOk": { en: "synced {count} providers", "zh-CN": "已同步 {count} 个供应商" },
+    "sync.summaryFailed": { en: "synced {ok} of {count} providers; the rest were skipped", "zh-CN": "已同步 {count} 个中的 {ok} 个供应商,其余已跳过" },
+    "sync.refreshNotSaved": { en: "dry run: the refreshed model list was not saved", "zh-CN": "试运行:刷新到的模型列表未保存" },
+    "sync.refreshFailed": { en: "could not refresh the model list; pass --no-refresh to write the saved list instead", "zh-CN": "无法刷新模型列表;可以加 --no-refresh 只写入已保存的列表" },
     "status.config": { en: "config: {file}", "zh-CN": "配置:{file}" },
     "status.active": { en: "active provider: {id}", "zh-CN": "当前供应商:{id}" },
     "status.none": { en: "(none)", "zh-CN": "(无)" },
@@ -375,9 +385,15 @@ const messages = {
     },
     "upgrade.done": { en: "{id} -> {version}", "zh-CN": "{id} -> {version}" },
     "upgrade.failed": { en: "{id} upgrade failed: {message}", "zh-CN": "{id} 升级失败:{message}" },
-    "discover.defaultMissing": {
-        en: "default model {model} no longer listed; keeping it anyway",
-        "zh-CN": "默认模型 {model} 已不在列表中;仍然保留",
+    "discover.summaryOk": { en: "refreshed {count} providers", "zh-CN": "已刷新 {count} 个供应商" },
+    "discover.summaryFailed": { en: "refreshed {ok} of {count} providers; the rest were skipped", "zh-CN": "已刷新 {count} 个中的 {ok} 个供应商,其余已跳过" },
+    "refresh.pinnedMissing": {
+        en: "{models} no longer listed by the endpoint; kept as configured — pick a listed model with: agentsw use {id} -m <model>",
+        "zh-CN": "{models} 已不在端点的模型列表中;仍按原配置保留 —— 可用 agentsw use {id} -m <model> 换成列表中的模型",
+    },
+    "sync.pinnedMissingWritten": {
+        en: "{models} no longer listed by the endpoint but was written to the agents anyway; pick a listed model with: agentsw use {id} -m <model>",
+        "zh-CN": "{models} 已不在端点的模型列表中,但仍写入了各智能体;可用 agentsw use {id} -m <model> 换成列表中的模型",
     },
     "discover.next": {
         en: "run `agentsw sync` to push into app configs",

package/dist/index.js

@@ -133,14 +133,18 @@ program
     .description(t("cmd.use"))
     .option("-a, --apps <apps>", t("opt.appsDetailed"))
     .option("-m, --model <id>", t("opt.model"))
+    .option("--small-model <id>", t("opt.smallModel"))
+    .option("--no-small-model", t("opt.noSmallModel"))
     .option("-n, --dry-run", t("opt.dryRun"))
     .action(cmdUse);
 program
     .command("sync")
     .description(t("cmd.sync"))
     .option("-a, --apps <apps>", t("opt.apps"))
-    .option("-p, --provider <id>", t("opt.provider"))
+    .option("-p, --provider <ids>", t("opt.provider"))
+    .option("--all", t("opt.syncAll"))
     .option("-n, --dry-run", t("opt.dryRun"))
+    .option("--no-refresh", t("opt.noRefresh"))
     .action(cmdSync);
 program.command("status").description(t("cmd.status")).action(cmdStatus);
 program
@@ -152,8 +156,10 @@ program
     .option("-l, --limit <n>", t("opt.limit"), "30")
     .action(cmdModels);
 program
-    .command("discover <id>")
+    .command("discover [ids...]")
     .description(t("cmd.discover"))
+    .option("-p, --provider <ids>", t("opt.refreshProvider"))
+    .option("--all", t("opt.refreshAll"))
     .option("-s, --sync", t("opt.syncAfter"))
     .option("-a, --apps <apps>", t("opt.appsSync"))
     .option("--include <globs>", t("opt.setInclude"))
@@ -181,7 +187,8 @@ program.command("upgrade [apps...]").description(t("cmd.upgrade")).action(cmdUpg
 program
     .command("refresh")
     .description(t("cmd.refresh"))
-    .option("-p, --provider <id>", t("opt.refreshProvider"))
+    .option("-p, --provider <ids>", t("opt.refreshProvider"))
+    .option("--all", t("opt.refreshAll"))
     .option("--metadata-mode <auto|on|off>", t("opt.metadataMode"))
     .option("--gateway-metadata", t("opt.gatewayMetadata"))
     .option("--no-gateway-metadata", t("opt.noGatewayMetadata"))