agentsw 0.9.1 → 0.10.0

package/dist/commands.js

@@ -8,7 +8,7 @@ import prompts from "prompts";
 import { loadStore, saveStore, getProvider, configFile } from "./store.js";
 import { scanCandidates, normalizeUrl, findMatchingProvider } from "./import.js";
 import { loadCatalog, searchCatalog } from "./modelsdev.js";
-import { enrichProviderModels, getMetadataMode, resolveMetadataOptions } from "./metadata.js";
+import { classifyUnresolved, enrichProviderModels, resolveMetadataOptions } from "./metadata.js";
 import { loadGatewayCatalog } from "./gateway.js";
 import { resolveTargets, supportsProtocol, targets } from "./targets/index.js";
 import { discoverProviderModels, probeProtocols } from "./discover.js";
@@ -17,38 +17,16 @@ 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 { 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. */
 function sharedGatewayLoader(refresh = false) {
     let pending;
-    return () => pending ??= loadGatewayCatalog({ refresh }).then((catalog) => catalog ?? null);
+    return () => pending ??= withProgress(t("progress.gateway"), () => loadGatewayCatalog({ refresh }).then((catalog) => catalog ?? null));
 }
 function fail(message) {
-    process.stderr.write(pc.red(`error: ${message}\n`));
-    process.exit(1);
-}
-function table(rows, header) {
-    const all = header ? [header, ...rows] : rows;
-    if (all.length === 0)
-        return "";
-    const widths = [];
-    for (const row of all) {
-        row.forEach((cell, i) => {
-            // eslint-disable-next-line no-control-regex
-            const len = cell.replace(/\u001b\[[0-9;]*m/g, "").length;
-            widths[i] = Math.max(widths[i] ?? 0, len);
-        });
-    }
-    const render = (row) => row
-        .map((cell, i) => {
-        const len = cell.replace(/\u001b\[[0-9;]*m/g, "").length;
-        return cell + " ".repeat((widths[i] ?? 0) - len);
-    })
-        .join("  ")
-        .trimEnd();
-    const lines = all.map(render);
-    if (header)
-        lines.splice(1, 0, widths.map((w) => "-".repeat(w)).join("  "));
-    return lines.join("\n");
+    error(message);
 }
 function fmtTokens(n) {
     if (!n)
@@ -70,11 +48,25 @@ function modelRows(models) {
     ]);
 }
 const MODEL_HEADER = ["MODEL", "CTX", "IN", "OUT", "REASONING", "$IN/$OUT per M"];
-/** Print a dim hint when some models have no catalog metadata. */
-function printUncatalogedHint(models) {
+/** Numbers right-align; the free-text columns shrink before ids on narrow terminals. */
+const MODEL_TABLE_OPTIONS = { align: ["left", "right", "right", "right", "left", "right"], truncate: [4, 0] };
+const MODEL_QUERY_OPTIONS = {
+    align: ["left", "left", "right", "right", "right", "left", "right"],
+    truncate: [5, 1, 0],
+};
+/**
+ * Explain why some models stayed bare: only ambiguous ids are worth the user's
+ * attention, so those are named separately from ids nothing can resolve.
+ */
+function printUncatalogedHint(models, catalog, hint) {
     const bare = models.filter((m) => m.contextWindow === undefined && !m.cost);
-    if (bare.length > 0) {
-        console.log(pc.dim(`${bare.length} model(s) have no catalog metadata (shown as "-")`));
+    if (bare.length === 0)
+        return;
+    out(pc.dim(t("meta.gap", { count: bare.length })));
+    const { ambiguous, unknown, noCreatorRow } = classifyUnresolved(catalog, bare.map((m) => m.id), hint);
+    for (const [key, ids] of [["meta.ambiguous", ambiguous], ["meta.noCreatorRow", noCreatorRow], ["meta.unknown", unknown]]) {
+        if (ids.length)
+            out(pc.dim(`  ${t(key, { count: ids.length, ids: ids.join(", "), id: ids[0] })}`));
     }
 }
 /** Guess the models.dev provider whose API host matches the configured baseUrl. */
@@ -114,14 +106,14 @@ function parseFilterOpts(opts, previous) {
 function reportDropped(dropped) {
     if (!dropped.length)
         return;
-    console.log(pc.dim(`filtered out ${dropped.length} model(s):`));
+    out(pc.dim(`filtered out ${dropped.length} model(s):`));
     for (const d of dropped)
-        console.log(pc.dim(`  - ${d.id} (${d.reason})`));
+        out(pc.dim(`  - ${d.id} (${d.reason})`));
 }
 export async function cmdAdd(opts) {
     const store = loadStore();
     resolveMetadataOptions(opts);
-    const interactive = process.stdin.isTTY && !opts.yes;
+    const interactive = process.stdin.isTTY === true && !opts.yes && !isJson();
     let answers = {};
     if (interactive) {
         prompts.override({
@@ -169,7 +161,7 @@ export async function cmdAdd(opts) {
                 name: "models",
                 message: t("add.models"),
             },
-        ], { onCancel: () => fail(t("add.cancelled")) });
+        ], { onCancel: () => cancelInteractive() });
     }
     else {
         const required = opts.discover
@@ -197,8 +189,15 @@ export async function cmdAdd(opts) {
         fail(t("add.openaiApiInvalid"));
     const baseUrl = normalizeUrl(answers.baseUrl);
     const explicitId = answers.id || undefined;
-    const existing = explicitId ? store.providers[explicitId] : findMatchingProvider(Object.values(store.providers), { protocol, baseUrl, apiKey: answers.apiKey });
-    const id = explicitId ?? existing?.id ?? availableProviderId(providerIdFromBaseUrl(baseUrl, protocol), store.providers);
+    const byId = explicitId ? store.providers[explicitId] : undefined;
+    // Endpoint plus credential is the account identity, so an explicit id never
+    // licenses a second entry for an account that is already configured.
+    const sameAccount = byId ? undefined : findMatchingProvider(Object.values(store.providers), { protocol, baseUrl, apiKey: answers.apiKey });
+    const existing = byId ?? sameAccount;
+    if (byId === undefined && explicitId && sameAccount) {
+        out(pc.yellow(t("add.alreadyConfigured", { id: pc.bold(sameAccount.id) })));
+    }
+    const id = byId?.id ?? sameAccount?.id ?? explicitId ?? availableProviderId(providerIdFromBaseUrl(baseUrl, protocol), store.providers);
     const openaiApi = protocol === "openai" ? wire ?? existing?.openaiApi : undefined;
     const metadataOptions = resolveMetadataOptions(opts, existing);
     const manualIds = (answers.models ?? "").split(",").map((s) => s.trim()).filter(Boolean);
@@ -207,11 +206,30 @@ export async function cmdAdd(opts) {
     const shouldDiscover = opts.discover || manualIds.length === 0;
     if (shouldDiscover) {
         if (!opts.discover) {
-            process.stderr.write(pc.dim(t("add.autoDiscover") + "\n"));
+            note(t("add.autoDiscover"));
+        }
+        const discover = () => withProgress(t("add.discovering", { url: baseUrl }), (progress) => discoverProviderModels({ baseUrl, apiKey: answers.apiKey, protocol }, {
+            onPage: ({ page, count }) => progress.update(t("progress.discoverPage", { url: baseUrl, page, count })),
+        }));
+        let discovered = [];
+        for (let attempt = 0;; attempt++) {
+            try {
+                discovered = await discover();
+                break;
+            }
+            catch (err) {
+                // Unattended runs keep failing fast; a person at the terminal gets a bounded retry, then manual ids.
+                if (!interactive)
+                    throw err;
+                if (attempt >= 2)
+                    break;
+                const { retry } = await prompts({ type: "toggle", name: "retry", message: t("add.retryDiscovery", { error: err.message }), initial: true }, { onCancel: () => cancelInteractive() });
+                if (!retry)
+                    break;
+            }
         }
-        process.stderr.write(pc.dim(`${t("add.discovering", { url: baseUrl })}\n`));
-        const discovered = await discoverProviderModels({ baseUrl, apiKey: answers.apiKey, protocol });
-        console.log(t("add.providerLists", { count: discovered.length }));
+        if (discovered.length)
+            out(t("add.providerLists", { count: discovered.length }));
         modelIds = [...new Set([...manualIds, ...discovered])];
     }
     const retained = [opts.defaultModel === undefined ? existing?.defaultModel : undefined, opts.smallModel === undefined ? existing?.smallModel : undefined].filter((id) => !!id);
@@ -222,9 +240,9 @@ export async function cmdAdd(opts) {
     modelIds = outcome.kept;
     if (modelIds.length === 0)
         fail(t("add.atLeastOne"));
-    const catalog = await loadCatalog();
+    const catalog = await withProgress(t("progress.catalog"), () => loadCatalog());
     const hint = opts.modelsDev ?? existing?.modelsDevId ?? guessProviderHint(catalog, answers.baseUrl);
-    const models = await enrichProviderModels(catalog, modelIds, { ...metadataOptions, modelsDevId: hint, models: existing?.models });
+    const models = await withProgress(t("progress.metadata"), () => enrichProviderModels(catalog, modelIds, { ...metadataOptions, modelsDevId: hint, models: existing?.models }));
     const matched = models.filter((m) => m.contextWindow !== undefined).length;
     const defaultModel = opts.defaultModel ?? existing?.defaultModel ?? modelIds[0];
     if (!modelIds.includes(defaultModel))
@@ -253,19 +271,23 @@ export async function cmdAdd(opts) {
         store.active = provider.id;
     saveStore(store);
     const savedStatus = t(existed ? "add.updated" : "add.added");
-    console.log(pc.green(t("add.saved", { status: savedStatus, id: pc.bold(provider.id), protocol })));
-    console.log(t("add.metadata", { matched, total: models.length }) + (hint ? t("add.providerHint", { hint }) : ""));
-    console.log(table(modelRows(models), MODEL_HEADER));
-    printUncatalogedHint(models);
-    console.log(pc.dim(`\n${t("add.next", { id: provider.id })}`));
+    if (isJson()) {
+        emitJson({ ...providerModelsReport(provider, false), created: !existed, matched });
+        return;
+    }
+    out(pc.green(t("add.saved", { status: savedStatus, id: pc.bold(provider.id), protocol })));
+    out(t("add.metadata", { matched, total: models.length }) + (hint ? t("add.providerHint", { hint }) : ""));
+    out(table(modelRows(models), MODEL_HEADER, MODEL_TABLE_OPTIONS));
+    printUncatalogedHint(models, catalog, hint);
+    note(`\n${t("add.next", { id: provider.id })}`);
 }
 /** Shared logic to create and save a single provider from discovered models. */
 async function createProvider(opts) {
     const { store, id, name, protocol, openaiApi, baseUrl, apiKey, modelIds, modelFilter } = opts;
     const metadataOptions = resolveMetadataOptions(opts, opts.existing);
-    const catalog = await loadCatalog();
+    const catalog = await withProgress(t("progress.catalog"), () => loadCatalog());
     const hint = opts.modelsDev ?? opts.existing?.modelsDevId ?? guessProviderHint(catalog, baseUrl);
-    const models = await enrichProviderModels(catalog, modelIds, { ...metadataOptions, modelsDevId: hint, models: opts.existing?.models }, { gatewayLoader: opts.gatewayLoader });
+    const models = await withProgress(t("progress.metadata"), () => enrichProviderModels(catalog, modelIds, { ...metadataOptions, modelsDevId: hint, models: opts.existing?.models }, { gatewayLoader: opts.gatewayLoader }));
     const matched = models.filter((m) => m.contextWindow !== undefined).length;
     const defaultModel = opts.defaultModel ?? opts.existing?.defaultModel ?? modelIds[0];
     if (!modelIds.includes(defaultModel))
@@ -294,10 +316,10 @@ async function createProvider(opts) {
     if (!store.active)
         store.active = provider.id;
     const savedStatus = t(existed ? "add.updated" : "add.added");
-    console.log(pc.green(t("add.saved", { status: savedStatus, id: pc.bold(provider.id), protocol })));
-    console.log(t("add.metadata", { matched, total: models.length }) + (hint ? t("add.providerHint", { hint }) : ""));
-    console.log(table(modelRows(models), MODEL_HEADER));
-    printUncatalogedHint(models);
+    out(pc.green(t("add.saved", { status: savedStatus, id: pc.bold(provider.id), protocol })));
+    out(t("add.metadata", { matched, total: models.length }) + (hint ? t("add.providerHint", { hint }) : ""));
+    out(table(modelRows(models), MODEL_HEADER, MODEL_TABLE_OPTIONS));
+    printUncatalogedHint(models, catalog, hint);
     return provider;
 }
 /**
@@ -308,14 +330,14 @@ async function createProvider(opts) {
 export async function cmdQuickAdd(opts) {
     const store = loadStore();
     resolveMetadataOptions(opts);
-    const interactive = process.stdin.isTTY && !opts.yes;
+    const interactive = process.stdin.isTTY === true && !opts.yes && !isJson();
     let baseUrl;
     let apiKey;
     if (interactive) {
         const answers = await prompts([
             { type: "text", name: "baseUrl", message: t("add.baseUrl"), validate: (v) => (/^https?:\/\//.test(v) ? true : t("add.baseUrlInvalid")) },
             { type: "password", name: "apiKey", message: t("add.apiKey") },
-        ], { onCancel: () => fail(t("add.cancelled")) });
+        ], { onCancel: () => cancelInteractive() });
         baseUrl = normalizeUrl(answers.baseUrl);
         apiKey = answers.apiKey;
     }
@@ -327,8 +349,25 @@ export async function cmdQuickAdd(opts) {
         baseUrl = normalizeUrl(opts.baseUrl);
         apiKey = opts.apiKey;
     }
-    process.stderr.write(pc.dim(t("quick.probing", { url: baseUrl }) + "\n"));
-    const protocols = await probeProtocols({ baseUrl, apiKey });
+    const probe = () => withProgress(t("quick.probing", { url: baseUrl }), (progress) => probeProtocols({ baseUrl, apiKey }, {
+        onAttempt: (protocol) => progress.update(t("progress.probe", { url: baseUrl, protocol })),
+    }));
+    let protocols = await probe();
+    // A typo in the endpoint is the common cause of "nothing answered"; let the user correct it instead of exiting.
+    for (let attempt = 0; interactive && protocols.length === 0 && attempt < 2; attempt++) {
+        const { retry } = await prompts({ type: "toggle", name: "retry", message: t("quick.retryProbe", { url: baseUrl }), initial: true }, { onCancel: () => cancelInteractive() });
+        if (!retry)
+            break;
+        const again = await prompts([
+            { type: "text", name: "baseUrl", message: t("add.baseUrl"), initial: baseUrl, validate: (v) => (/^https?:\/\//.test(v) ? true : t("add.baseUrlInvalid")) },
+            { type: "password", name: "apiKey", message: t("add.apiKey") },
+        ], { onCancel: () => cancelInteractive() });
+        if (!again.baseUrl || !again.apiKey)
+            break;
+        baseUrl = normalizeUrl(again.baseUrl);
+        apiKey = again.apiKey;
+        protocols = await probe();
+    }
     if (protocols.length === 0) {
         fail(t("quick.noProtocol"));
     }
@@ -339,13 +378,19 @@ export async function cmdQuickAdd(opts) {
     const gatewayLoader = sharedGatewayLoader();
     for (const protocol of protocols) {
         const explicitId = opts.id === undefined ? undefined : `${opts.id}${multi ? `-${protocol}` : ""}`;
-        const existing = explicitId === undefined ? findMatchingProvider(Object.values(store.providers), { protocol, baseUrl, apiKey }) : store.providers[explicitId];
-        const id = explicitId ?? existing?.id ?? availableProviderId(providerIdFromBaseUrl(baseUrl, protocol), store.providers);
+        const byId = explicitId ? store.providers[explicitId] : undefined;
+        const sameAccount = byId ? undefined : findMatchingProvider(Object.values(store.providers), { protocol, baseUrl, apiKey });
+        const existing = byId ?? sameAccount;
+        if (byId === undefined && explicitId && sameAccount) {
+            out(pc.yellow(t("add.alreadyConfigured", { id: pc.bold(sameAccount.id) })));
+        }
+        const id = byId?.id ?? sameAccount?.id ?? explicitId ?? availableProviderId(providerIdFromBaseUrl(baseUrl, protocol), store.providers);
         const name = opts.name ?? existing?.name ?? (opts.id === undefined ? providerNameFromBaseUrl(baseUrl, protocol) : multi ? `${opts.id} (${protocol})` : opts.id);
         const modelFilter = parseFilterOpts(opts, existing?.modelFilter);
-        process.stderr.write(pc.dim(`${t("add.discovering", { url: baseUrl })} [${protocol}]\n`));
-        const discovered = await discoverProviderModels({ baseUrl, apiKey, protocol });
-        console.log(t("add.providerLists", { count: discovered.length }));
+        const discovered = await withProgress(`${t("add.discovering", { url: baseUrl })} [${protocol}]`, (progress) => discoverProviderModels({ baseUrl, apiKey, protocol }, {
+            onPage: ({ page, count }) => progress.update(`${t("progress.discoverPage", { url: baseUrl, page, count })} [${protocol}]`),
+        }));
+        out(t("add.providerLists", { count: discovered.length }));
         const retained = [opts.defaultModel === undefined ? existing?.defaultModel : undefined, opts.smallModel === undefined ? existing?.smallModel : undefined].filter((id) => !!id);
         let modelIds = [...new Set([...discovered, ...retained])];
         const pinned = [...retained, ...(opts.defaultModel ? [opts.defaultModel] : []), ...(opts.smallModel ? [opts.smallModel] : [])];
@@ -353,7 +398,7 @@ export async function cmdQuickAdd(opts) {
         reportDropped(outcome.dropped);
         modelIds = outcome.kept;
         if (modelIds.length === 0) {
-            console.log(pc.yellow(t("quick.noModelsAfterFilter", { id })));
+            out(pc.yellow(t("quick.noModelsAfterFilter", { id })));
             continue;
         }
         const provider = await createProvider({
@@ -377,18 +422,26 @@ export async function cmdQuickAdd(opts) {
             gatewayLoader,
         });
         createdIds.push(provider.id);
-        console.log(pc.dim(`\n${t("add.next", { id: provider.id })}`));
+        note(`\n${t("add.next", { id: provider.id })}`);
     }
     saveStore(store);
+    if (isJson()) {
+        emitJson({ providers: createdIds });
+        return;
+    }
     if (createdIds.length > 0) {
-        console.log(pc.green(t("quick.summary", { count: createdIds.length, ids: createdIds.join(", ") })));
+        out(pc.green(t("quick.summary", { count: createdIds.length, ids: createdIds.join(", ") })));
     }
 }
 export function cmdList() {
     const store = loadStore();
+    if (isJson()) {
+        emitJson(listReport(store));
+        return;
+    }
     const ids = Object.keys(store.providers);
     if (ids.length === 0) {
-        console.log(t("list.none", { file: configFile }));
+        out(t("list.none", { file: configFile }));
         return;
     }
     const rows = ids.map((id) => {
@@ -402,23 +455,37 @@ export function cmdList() {
             String(p.models.length),
         ];
     });
-    console.log(table(rows, [" ", "ID", t("table.protocol"), "BASE URL", t("table.defaultModel"), t("table.models")]));
+    out(table(rows, [" ", "ID", t("table.protocol"), "BASE URL", t("table.defaultModel"), t("table.models")], {
+        truncate: [3, 1, 4],
+        align: ["left", "left", "left", "left", "left", "right"],
+    }));
 }
 export async function cmdPrune(id, opts) {
     const store = loadStore();
     const provider = getProvider(store, id);
-    console.log(`${t("remove.pruning", { id: pc.bold(id) })}\n`);
-    reportResults(await runTargets("prune", provider, opts.apps));
+    out(`${t("remove.pruning", { id: pc.bold(id) })}\n`);
+    const results = await runTargets("prune", provider, opts.apps);
+    if (isJson()) {
+        emitJson({
+            provider: id,
+            op: "prune",
+            apps: results.filter((r) => !r.skipped).map((r) => r.app),
+            files: results.flatMap((r) => (r.skipped ? [] : r.changed)),
+            skipped: results.filter((r) => r.skipped).map((r) => ({ app: r.app, reason: r.skipped })),
+        });
+        return;
+    }
+    reportResults(results);
 }
 function reportResults(results) {
     for (const r of results) {
         if (r.skipped) {
-            console.log(`${pc.yellow(t("common.skip"))} ${r.app.padEnd(9)} ${pc.dim(r.skipped)}`);
+            out(`${pc.yellow(t("common.skip"))} ${r.app.padEnd(9)} ${pc.dim(r.skipped)}`);
             continue;
         }
-        console.log(`${pc.green("ok  ")} ${r.app.padEnd(9)} ${r.changed.join(", ")}`);
+        out(`${pc.green("ok  ")} ${r.app.padEnd(9)} ${r.changed.join(", ")}`);
         for (const note of r.notes)
-            console.log(`     ${" ".repeat(9)} ${pc.dim(note)}`);
+            out(`     ${" ".repeat(9)} ${pc.dim(note)}`);
     }
 }
 async function runTargets(op, provider, appsFilter, redactErrors = false) {
@@ -444,7 +511,7 @@ async function runTargets(op, provider, appsFilter, redactErrors = false) {
         }
         catch (err) {
             const safe = redactErrors && !(err instanceof SafeConfigError);
-            results.push({ app: target.id, changed: [], notes: [], skipped: pc.red(`failed: ${safe ? "configuration could not be previewed safely" : err.message}`) });
+            results.push({ app: target.id, changed: [], notes: [], skipped: pc.red(`failed: ${safe ? t("preview.failedSafely") : err.message}`) });
             process.exitCode = 1;
         }
     }
@@ -481,10 +548,10 @@ function previewDocument(file, text) {
 function printFileDiff(file, next, apiKey) {
     const before = readTextIfExists(file) ?? "";
     if (before === next) {
-        console.log(`${pc.dim("unchanged")} ${file}`);
+        out(`${pc.dim(t("preview.unchanged"))} ${file}`);
         return;
     }
-    console.log(pc.bold(`--- ${file} (redacted configuration)`));
+    out(pc.bold(t("preview.header", { file })));
     let oldText;
     let newText;
     try {
@@ -534,7 +601,7 @@ function printFileDiff(file, next, apiKey) {
         newText = JSON.stringify(newDocument, redact, 2) ?? "";
     }
     catch {
-        console.log(pc.dim("[content withheld: unsupported or malformed configuration]"));
+        out(pc.dim(t("preview.contentWithheld")));
         return;
     }
     const oldLines = oldText.split("\n");
@@ -550,22 +617,28 @@ function printFileDiff(file, next, apiKey) {
         if (count > 0)
             newSeen.set(line, count - 1);
         else
-            console.log(pc.red(`- ${line}`));
+            out(pc.red(`- ${line}`));
     }
     for (const line of newLines) {
         const count = oldSeen.get(line) ?? 0;
         if (count > 0)
             oldSeen.set(line, count - 1);
         else
-            console.log(pc.green(`+ ${line}`));
+            out(pc.green(`+ ${line}`));
     }
     if (oldText === newText)
-        console.log(pc.dim("[only redacted values or formatting changed]"));
+        out(pc.dim(t("preview.onlyRedacted")));
 }
 async function runWithOptionalDryRun(op, provider, apps, dryRun) {
+    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) {
-        reportResults(await runTargets(op, provider, apps));
-        return;
+        const results = await runTargets(op, provider, apps);
+        reportResults(results);
+        return summarize(results, results.flatMap((r) => (r.skipped ? [] : r.changed)));
     }
     setDryRun(true);
     try {
@@ -573,11 +646,13 @@ async function runWithOptionalDryRun(op, provider, apps, dryRun) {
         const writes = drainPendingWrites();
         for (const r of results) {
             if (r.skipped)
-                console.log(`${pc.yellow("skip")} ${r.app.padEnd(9)} ${pc.dim(r.skipped)}`);
+                out(`${pc.yellow(t("dryRun.skip"))} ${r.app.padEnd(9)} ${pc.dim(r.skipped)}`);
         }
-        console.log(pc.bold(`\ndry run — ${writes.length} file(s) would be written:\n`));
+        out(pc.bold(`\n${t("dryRun.wouldWrite", { count: writes.length })}\n`));
         for (const w of writes)
             printFileDiff(w.file, w.content, provider.apiKey);
+        // Only paths: the staged content is redacted for humans but still configuration, not a machine interface.
+        return summarize(results, writes.map((w) => w.file));
     }
     finally {
         setDryRun(false);
@@ -597,8 +672,11 @@ export async function cmdUse(id, opts) {
         store.active = id;
         saveStore(store);
     }
-    console.log(`${t("use.switching", { id: pc.bold(id), protocol: provider.protocol, model: provider.defaultModel })}\n`);
-    await runWithOptionalDryRun("apply", provider, opts.apps, opts.dryRun);
+    out(`${t("use.switching", { id: pc.bold(id), protocol: provider.protocol, model: provider.defaultModel })}\n`);
+    const outcome = await runWithOptionalDryRun("apply", provider, opts.apps, opts.dryRun);
+    if (isJson()) {
+        emitJson({ provider: id, model: provider.defaultModel, dryRun: opts.dryRun === true, ...outcome });
+    }
 }
 export async function cmdSync(opts) {
     resolveTargets(opts.apps);
@@ -607,59 +685,85 @@ export async function cmdSync(opts) {
     if (!id)
         fail(t("sync.noActive"));
     const provider = getProvider(store, id);
-    console.log(`${t("sync.syncing", { id: pc.bold(id), model: provider.defaultModel })}\n`);
-    await runWithOptionalDryRun("apply", provider, opts.apps, opts.dryRun);
+    out(`${t("sync.syncing", { id: pc.bold(id), model: provider.defaultModel })}\n`);
+    const outcome = await runWithOptionalDryRun("apply", provider, opts.apps, opts.dryRun);
+    if (isJson()) {
+        emitJson({ provider: id, model: provider.defaultModel, dryRun: opts.dryRun === true, ...outcome });
+    }
 }
 export function cmdStatus() {
     const store = loadStore();
-    console.log(t("status.config", { file: configFile }));
-    console.log(`${t("status.active", { id: store.active ? pc.bold(store.active) : pc.dim(t("status.none")) })}\n`);
-    const rows = targets.map((target) => [
-        target.id,
-        target.detect() ? pc.green(t("common.yes")) : pc.dim(t("common.no")),
-        target.protocols.join("+"),
-        target.current() ?? pc.dim("-"),
-        pc.dim(target.configPaths[0] ?? ""),
+    const apps = targets.map((target) => ({
+        id: target.id,
+        detected: target.detect(),
+        protocols: [...target.protocols],
+        current: target.current() ?? null,
+        configPath: target.configPaths[0] ?? "",
+    }));
+    if (isJson()) {
+        emitJson(statusReport(configFile, store, apps));
+        return;
+    }
+    out(t("status.config", { file: configFile }));
+    out(`${t("status.active", { id: store.active ? pc.bold(store.active) : pc.dim(t("status.none")) })}\n`);
+    const rows = apps.map((app) => [
+        app.id,
+        app.detected ? pc.green(t("common.yes")) : pc.dim(t("common.no")),
+        app.protocols.join("+"),
+        app.current ?? pc.dim("-"),
+        pc.dim(app.configPath),
     ]);
-    console.log(table(rows, ["APP", t("table.found"), t("table.protocols"), t("table.current"), t("table.config")]));
+    out(table(rows, ["APP", t("table.found"), t("table.protocols"), t("table.current"), t("table.config")], {
+        truncate: [4, 3],
+    }));
+}
+/** `--limit` is user input: a non-numeric or non-positive value must fail, not silently list everything. */
+function parseLimit(value) {
+    const limit = value === undefined ? 30 : Number(value);
+    if (!Number.isInteger(limit) || limit < 1)
+        fail(t("error.limit"));
+    return limit;
 }
 export async function cmdModels(query, opts) {
     if (opts.metadata && !opts.provider)
-        fail("--metadata requires --provider");
+        fail(t("models.metadataRequiresProvider"));
     if (opts.provider) {
         const store = loadStore();
         const provider = getProvider(store, opts.provider);
+        if (isJson()) {
+            emitJson(providerModelsReport(provider, opts.metadata === true));
+            return;
+        }
+        // Kept as a bare document without --json: existing scripts parse it directly.
         if (opts.metadata) {
-            console.log(JSON.stringify({
-                provider: provider.id,
-                gatewayMetadata: provider.gatewayMetadata ?? "auto",
-                metadataMode: getMetadataMode(provider),
-                gatewayModelAliases: provider.gatewayModelAliases ?? {},
-                models: provider.models.map(({ id, metadata }) => ({ id, metadata })),
-            }, null, 2));
+            out(JSON.stringify(providerMetadataReport(provider), null, 2));
             return;
         }
-        console.log(`${pc.bold(provider.id)} (${provider.protocol}) · ${provider.baseUrl}`);
-        console.log(table(modelRows(provider.models), MODEL_HEADER));
-        printUncatalogedHint(provider.models);
+        out(`${pc.bold(provider.id)} (${provider.protocol}) · ${provider.baseUrl}`);
+        out(table(modelRows(provider.models), MODEL_HEADER, MODEL_TABLE_OPTIONS));
+        printUncatalogedHint(provider.models, await withProgress(t("progress.catalog"), () => loadCatalog()), provider.modelsDevId);
         return;
     }
-    const catalog = await loadCatalog({ refresh: opts.refresh });
+    const catalog = await withProgress(t("progress.catalog"), () => loadCatalog({ refresh: opts.refresh }));
     if (!catalog)
-        fail("models.dev catalog unavailable (offline and no cache)");
+        fail(t("models.catalogUnavailable"));
     if (!query)
-        fail("usage: agentsw models <query> | agentsw models --provider <id>");
-    const limit = opts.limit ? Number(opts.limit) : 30;
+        fail(t("models.usage"));
+    const limit = parseLimit(opts.limit);
     const hits = searchCatalog(catalog, query, limit);
+    if (isJson()) {
+        emitJson(modelsQueryReport(query, hits));
+        return;
+    }
     if (hits.length === 0) {
-        console.log(`no models.dev entries match "${query}"`);
+        out(t("models.noMatch", { query }));
         return;
     }
     const rows = hits.map((h) => {
         const row = modelRows([h.spec])[0];
         return [h.provider, ...row];
     });
-    console.log(table(rows, ["PROVIDER", ...MODEL_HEADER]));
+    out(table(rows, ["PROVIDER", ...MODEL_HEADER], MODEL_QUERY_OPTIONS));
 }
 export async function cmdRefreshMeta(opts = {}) {
     const store = loadStore();
@@ -667,22 +771,28 @@ export async function cmdRefreshMeta(opts = {}) {
     resolveMetadataOptions(opts);
     for (const provider of providers)
         Object.assign(provider, resolveMetadataOptions(opts, provider));
-    const catalog = await loadCatalog({ refresh: true });
+    const catalog = await withProgress(t("progress.catalog"), () => loadCatalog({ refresh: true }));
     const gatewayLoader = sharedGatewayLoader(true);
     let updated = 0;
     for (const provider of providers) {
         const before = JSON.stringify(provider.models);
-        provider.models = await enrichProviderModels(catalog, provider.models.map((m) => m.id), {
+        provider.models = await withProgress(t("progress.metadata"), () => enrichProviderModels(catalog, provider.models.map((m) => m.id), {
             ...provider,
             modelsDevId: provider.modelsDevId ?? guessProviderHint(catalog, provider.baseUrl),
-        }, { gatewayLoader });
+        }, { gatewayLoader }));
         if (JSON.stringify(provider.models) !== before)
             updated++;
     }
     saveStore(store);
-    console.log(pc.green(`checked model metadata (${updated} provider(s) changed)`));
+    if (isJson()) {
+        emitJson({ checked: providers.length, updated, providers: providers.map((p) => p.id) });
+        return;
+    }
+    out(pc.green(t("refresh.checked", { changed: updated })));
     if (updated > 0)
-        console.log(pc.dim("run `agentsw sync` to push updated metadata into app configs"));
+        note(t("refresh.next"));
+    for (const provider of providers)
+        printUncatalogedHint(provider.models, catalog, provider.modelsDevId);
 }
 export async function cmdDiscover(id, opts) {
     resolveTargets(opts.apps);
@@ -695,133 +805,182 @@ export async function cmdDiscover(id, opts) {
         provider.modelFilter = undefined;
     else if (flagFilter)
         provider.modelFilter = flagFilter;
-    process.stderr.write(pc.dim(`discovering models from ${provider.baseUrl} ...\n`));
-    const listed = await discoverProviderModels(provider);
+    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) => !ids.includes(m));
-    const catalog = await loadCatalog();
-    const retainedIds = [...new Set([...ids, ...pinned])];
-    provider.models = await enrichProviderModels(catalog, retainedIds, { ...provider, modelsDevId: provider.modelsDevId ?? guessProviderHint(catalog, provider.baseUrl) });
+    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)) {
-        console.log(pc.yellow(`default model ${provider.defaultModel} no longer listed; keeping it anyway`));
+        out(pc.yellow(t("discover.defaultMissing", { model: provider.defaultModel })));
     }
     saveStore(store);
-    console.log(`${pc.bold(id)}: ${ids.length} models (${pc.green(`+${added.length}`)} / ${pc.red(`-${gone.length}`)})` +
+    if (isJson()) {
+        emitJson({ provider: id, models: ids.length, added, removed: gone });
+        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(", ")}` : ""));
-    console.log(table(modelRows(provider.models), MODEL_HEADER));
-    printUncatalogedHint(provider.models);
+    out(table(modelRows(provider.models), MODEL_HEADER, MODEL_TABLE_OPTIONS));
+    printUncatalogedHint(provider.models, catalog, provider.modelsDevId);
     if (opts.sync) {
-        console.log("");
+        out("");
         await cmdSync({ provider: id, apps: opts.apps });
     }
     else {
-        console.log(pc.dim("\nrun `agentsw sync` to push into app configs"));
+        note(`\n${t("discover.next")}`);
     }
 }
-async function collectAppRows() {
+async function collectAppRows(onProgress) {
+    const total = appPackages.length;
+    let done = 0;
     return Promise.all(appPackages.map(async (app) => {
-        const [installedResult, latestResult] = await Promise.allSettled([
-            Promise.resolve().then(() => installedVersion(app)),
-            latestVersion(app),
-        ]);
-        const installed = installedResult.status === "fulfilled" ? installedResult.value : "?";
-        const latest = latestResult.status === "fulfilled" ? latestResult.value : undefined;
-        const knownInstalled = normalizeAppVersion(installed);
-        const knownLatest = normalizeAppVersion(latest);
-        const checkFailed = installedResult.status === "rejected"
-            ? "installed version check failed"
-            : installed && !knownInstalled
-                ? "installed version unknown"
-                : installed && !knownLatest
-                    ? "latest version unavailable"
-                    : undefined;
-        return {
-            id: app.id,
-            name: app.name,
-            installed,
-            latest,
-            upgradable: !!knownInstalled && !!knownLatest && isNewer(knownInstalled, knownLatest),
-            installable: !installed && !!appCommand(app, "install"),
-            checkFailed,
-        };
+        try {
+            const [installedResult, latestResult] = await Promise.allSettled([
+                Promise.resolve().then(() => installedVersion(app)),
+                latestVersion(app),
+            ]);
+            const installed = installedResult.status === "fulfilled" ? installedResult.value : "?";
+            const latest = latestResult.status === "fulfilled" ? latestResult.value : undefined;
+            const knownInstalled = normalizeAppVersion(installed);
+            const knownLatest = normalizeAppVersion(latest);
+            const checkFailed = installedResult.status === "rejected"
+                ? t("apps.checkFailedProbe")
+                : installed && !knownInstalled
+                    ? t("apps.checkFailedUnknown")
+                    : installed && !knownLatest
+                        ? t("apps.checkFailedLatest")
+                        : undefined;
+            return {
+                id: app.id,
+                name: app.name,
+                installed,
+                latest,
+                upgradable: !!knownInstalled && !!knownLatest && isNewer(knownInstalled, knownLatest),
+                installable: !installed && !!appCommand(app, "install"),
+                checkFailed,
+            };
+        }
+        finally {
+            onProgress?.(++done, total);
+        }
     }));
 }
+function appStatus(row) {
+    if (row.upgradable)
+        return "upgradable";
+    if (!row.installed)
+        return row.installable ? "installable" : "not-installed";
+    return row.checkFailed || !normalizeAppVersion(row.latest) ? "unknown" : "up-to-date";
+}
+function appStatusLabel(status) {
+    switch (status) {
+        case "upgradable": return pc.yellow(t("apps.upgradeAvailable"));
+        case "installable": return pc.dim(t("apps.installable"));
+        case "not-installed": return pc.dim("-");
+        case "unknown": return pc.dim(t("apps.unknown"));
+        case "up-to-date": return pc.green(t("apps.upToDate"));
+    }
+}
 export async function cmdApps() {
-    process.stderr.write(pc.dim("checking installed and latest versions ...\n"));
-    const rows = await collectAppRows();
-    console.log(table(rows.map((r) => [
+    const rows = await withProgress(t("apps.checking"), (progress) => collectAppRows((done, total) => progress.update(t("progress.apps", { done, total }))));
+    if (isJson()) {
+        const report = rows.map((row) => ({
+            id: row.id,
+            name: row.name,
+            installed: row.installed,
+            latest: row.latest,
+            upgradable: row.upgradable,
+            installable: row.installable,
+            status: appStatus(row),
+        }));
+        emitJson(appsReport(report));
+        return;
+    }
+    out(table(rows.map((r) => [
         r.id,
-        r.installed ?? pc.dim("not installed"),
+        r.installed ?? pc.dim(t("apps.notInstalled")),
         r.latest ?? pc.dim("?"),
-        r.upgradable
-            ? pc.yellow("upgrade available")
-            : !r.installed
-                ? r.installable
-                    ? pc.dim("installable")
-                    : pc.dim("-")
-                : r.checkFailed || !normalizeAppVersion(r.latest)
-                    ? pc.dim("unknown")
-                    : pc.green("up to date"),
+        appStatusLabel(appStatus(r)),
     ]), ["APP", "INSTALLED", "LATEST", "STATUS"]));
     const upgradable = rows.filter((r) => r.upgradable).map((r) => r.id);
     if (upgradable.length)
-        console.log(pc.dim(`\nupgrade with: agentsw upgrade ${upgradable.join(" ")}`));
+        note(`\n${t("apps.upgradeWith", { ids: upgradable.join(" ") })}`);
 }
 export async function cmdInstall(id) {
     const app = appPackages.find((a) => a.id === id);
     if (!app)
-        fail(`unknown app "${id}" (supported: ${appPackages.map((a) => a.id).join(", ")})`);
+        fail(t("install.unknownApp", { value: id, apps: appPackages.map((a) => a.id).join(", ") }));
     const installCmd = appCommand(app, "install");
     if (!installCmd)
-        fail(`${app.name} is not installable on ${process.platform} (or is managed by its desktop app)`);
+        fail(t("install.notInstallable", { name: app.name, platform: process.platform }));
     const installed = installedVersion(app);
     if (installed) {
-        console.log(`${app.name} already installed (${installed}); use \`agentsw upgrade ${id}\``);
+        if (isJson()) {
+            emitJson({ app: id, status: "already-installed", version: installed });
+            return;
+        }
+        out(t("install.already", { name: app.name, version: installed, id }));
         return;
     }
-    console.log(`installing ${app.name}: ${pc.dim(installCmd)}`);
+    out(t("install.installing", { name: app.name, command: pc.dim(installCmd) }));
     runShell(installCmd);
     const detected = installedVersion(app);
     if (!detected)
-        throw new Error(`${app.name}: installer completed but the app is still not detected; check the installation and PATH`);
+        throw new Error(t("install.notDetected", { name: app.name }));
     const version = normalizeAppVersion(detected);
     if (!version) {
-        console.log(pc.yellow(`${app.name}: installer completed; app detected but version unknown`));
+        if (isJson())
+            error(t("install.versionUnknown", { name: app.name }));
+        out(pc.yellow(t("install.versionUnknown", { name: app.name })));
         process.exitCode = 1;
         return;
     }
-    console.log(pc.green(`${app.name} installed: ${version}`));
+    if (isJson()) {
+        emitJson({ app: id, status: "installed", version });
+        return;
+    }
+    out(pc.green(t("install.installed", { name: app.name, version })));
 }
 export async function cmdUpgrade(ids) {
     let selected = appPackages.filter((a) => ids.length === 0 || ids.includes(a.id));
     const unknown = ids.filter((id) => !appPackages.some((a) => a.id === id));
     if (unknown.length)
-        fail(`unknown app(s): ${unknown.join(", ")}`);
+        fail(t("upgrade.unknownApps", { ids: unknown.join(", ") }));
     const expectedVersions = new Map();
+    const upgraded = [];
+    const skipped = [];
     if (ids.length === 0) {
         // no args: upgrade everything that is installed and outdated
-        process.stderr.write(pc.dim("checking versions ...\n"));
-        const rows = await collectAppRows();
+        const rows = await withProgress(t("upgrade.checking"), (progress) => collectAppRows((done, total) => progress.update(t("progress.apps", { done, total }))));
         const managed = rows.filter((row) => !!appCommand(appPackages.find((app) => app.id === row.id), "upgrade"));
         const failed = managed.filter((row) => row.checkFailed);
         for (const row of failed)
-            console.log(pc.yellow(`${row.id}: ${row.checkFailed}; update status unknown`));
+            out(pc.yellow(t("upgrade.statusUnknown", { id: row.id, reason: row.checkFailed })));
         if (failed.length)
             process.exitCode = 1;
         const upgradable = managed.filter((row) => row.upgradable);
         if (upgradable.length === 0) {
+            if (isJson()) {
+                emitJson({ upgraded, skipped: failed.map((row) => ({ id: row.id, reason: row.checkFailed })) });
+                return;
+            }
             if (failed.length)
-                console.log("could not determine update status for every installed app");
+                out(t("upgrade.cannotDetermine"));
             else if (managed.some((row) => row.installed))
-                console.log("all checked apps are up to date");
+                out(t("upgrade.allCurrent"));
             else
-                console.log("no installed CLI-managed apps to upgrade");
+                out(t("upgrade.none"));
             return;
         }
         for (const row of upgradable)
@@ -831,57 +990,68 @@ export async function cmdUpgrade(ids) {
     for (const app of selected) {
         const cmd = appCommand(app, "upgrade");
         if (!cmd) {
-            console.log(`${pc.yellow("skip")} ${app.id}: not CLI-upgradable`);
+            out(`${pc.yellow(t("dryRun.skip"))} ${t("upgrade.notCli", { id: app.id })}`);
+            skipped.push({ id: app.id, reason: "not-cli-managed" });
             process.exitCode = 1;
             continue;
         }
         try {
             if (!installedVersion(app)) {
-                console.log(`${pc.yellow("skip")} ${app.id}: not installed (use \`agentsw install ${app.id}\`)`);
+                out(`${pc.yellow(t("dryRun.skip"))} ${t("upgrade.notInstalled", { id: app.id })}`);
+                skipped.push({ id: app.id, reason: "not-installed" });
                 process.exitCode = 1;
                 continue;
             }
-            console.log(`upgrading ${app.name}: ${pc.dim(cmd)}`);
+            out(t("upgrade.upgrading", { name: app.name, command: pc.dim(cmd) }));
             runShell(cmd);
             const version = normalizeAppVersion(installedVersion(app));
             if (!version)
-                throw new Error("upgrade command completed but installed version is unknown or app is not detected");
+                throw new Error(t("upgrade.unknownVersion"));
             const expected = expectedVersions.get(app.id);
             if (expected && isNewer(version, expected))
-                throw new Error(`upgrade command completed but ${version} is older than available ${expected}`);
-            console.log(pc.green(`${app.id} -> ${version}`));
+                throw new Error(t("upgrade.olderThanAvailable", { version, expected }));
+            out(pc.green(t("upgrade.done", { id: app.id, version })));
+            upgraded.push({ id: app.id, version });
         }
         catch (err) {
-            console.log(pc.red(`${app.id} upgrade failed: ${err.message}`));
+            out(pc.red(t("upgrade.failed", { id: app.id, message: err.message })));
+            skipped.push({ id: app.id, reason: err.message });
             process.exitCode = 1;
         }
     }
+    if (isJson())
+        emitJson({ upgraded, skipped });
 }
 /** Collect custom providers, dedupe by endpoint and credentials, and import what is new. */
 export async function cmdImport(opts) {
+    const interactive = process.stdin.isTTY === true && !opts.all && !isJson();
     const metadataOptions = resolveMetadataOptions(opts);
     const rows = scanCandidates();
     const fresh = rows.filter((r) => !r.configured);
     for (const r of rows) {
         if (r.configured) {
-            console.log(`${pc.yellow(t("import.skip"))} ${pc.bold(r.id)} · ${r.protocol} · ${r.baseUrl} — ${t("import.already", { id: pc.bold(r.configured) })}`);
+            out(`${pc.yellow(t("import.skip"))} ${pc.bold(r.id)} · ${r.protocol} · ${r.baseUrl} — ${t("import.already", { id: pc.bold(r.configured) })}`);
         }
     }
     if (fresh.length === 0) {
-        console.log(rows.length ? t("import.noneNew") : t("import.noneFound"));
+        if (isJson()) {
+            emitJson({ providers: [], candidates: rows.length });
+            return;
+        }
+        out(rows.length ? t("import.noneNew") : t("import.noneFound"));
         return;
     }
-    console.log("");
-    console.log(table(fresh.map((r) => [
+    out("");
+    out(table(fresh.map((r) => [
         r.id,
         r.protocol,
         r.baseUrl,
         String(r.models.length),
         r.sources.join(","),
         r.apiKey ? pc.green(t("import.keyYes")) : r.keyEnv ? pc.yellow(t("import.keyEnv", { name: r.keyEnv })) : pc.red(t("import.keyMissing")),
-    ]), ["ID", t("table.protocol"), "BASE URL", t("table.models"), t("table.from"), t("table.key")]));
+    ]), ["ID", t("table.protocol"), "BASE URL", t("table.models"), t("table.from"), t("table.key")], { truncate: [2, 4] }));
     let chosen;
-    if (process.stdin.isTTY && !opts.all) {
+    if (interactive) {
         const { pick } = await prompts({
             type: "multiselect",
             name: "pick",
@@ -892,9 +1062,9 @@ export async function cmdImport(opts) {
                 value: i,
                 selected: true,
             })),
-        }, { onCancel: () => fail(t("add.cancelled")) });
+        }, { onCancel: () => cancelInteractive() });
         if (!Array.isArray(pick) || pick.length === 0) {
-            console.log(pc.dim(t("import.nothingSelected")));
+            out(pc.dim(t("import.nothingSelected")));
             return;
         }
         chosen = pick.map((i) => fresh[i]).filter((r) => r !== undefined);
@@ -903,14 +1073,14 @@ export async function cmdImport(opts) {
         chosen = fresh;
     }
     const store = loadStore();
-    const catalog = await loadCatalog();
+    const catalog = await withProgress(t("progress.catalog"), () => loadCatalog());
     const gatewayLoader = sharedGatewayLoader();
     const imported = [];
     for (const c of chosen) {
         let apiKey = c.apiKey;
         if (!apiKey) {
             const why = c.keyEnv ? t("import.keyRefMissing", { name: c.keyEnv }) : t("import.keyNotStored");
-            if (!process.stdin.isTTY || opts.all) {
+            if (!interactive) {
                 fail(t("import.missingKey", { id: c.id, why }));
             }
             const a = await prompts({
@@ -918,31 +1088,49 @@ export async function cmdImport(opts) {
                 name: "key",
                 message: t("import.keyPrompt", { id: c.id, url: c.baseUrl, why }),
                 validate: (v) => (v.trim() ? true : t("import.required")),
-            }, { onCancel: () => fail(t("add.cancelled")) });
+            }, { onCancel: () => cancelInteractive() });
             apiKey = a.key;
         }
         // A prompted credential can identify a provider imported earlier in this same batch.
         const existing = findMatchingProvider(Object.values(store.providers), { protocol: c.protocol, baseUrl: c.baseUrl, apiKey });
         if (existing) {
-            console.log(`${pc.yellow(t("import.skip"))} ${pc.bold(c.id)} · ${c.protocol} · ${c.baseUrl} — ${t("import.already", { id: pc.bold(existing.id) })}`);
+            out(`${pc.yellow(t("import.skip"))} ${pc.bold(c.id)} · ${c.protocol} · ${c.baseUrl} — ${t("import.already", { id: pc.bold(existing.id) })}`);
             continue;
         }
         let ids = [...c.models];
         if (ids.length === 0) {
-            process.stderr.write(pc.dim(`${t("import.discovering", { id: c.id })}\n`));
-            try {
-                ids = await discoverProviderModels({ baseUrl: c.baseUrl, apiKey: apiKey, protocol: c.protocol });
+            const discover = () => withProgress(t("import.discovering", { id: c.id }), (progress) => discoverProviderModels({ baseUrl: c.baseUrl, apiKey: apiKey, protocol: c.protocol }, {
+                onPage: ({ page, count }) => progress.update(t("progress.discoverPage", { url: c.baseUrl, page, count })),
+            }));
+            let listed;
+            for (let attempt = 0;; attempt++) {
+                try {
+                    listed = await discover();
+                    break;
+                }
+                catch (err) {
+                    if (!interactive)
+                        fail(t("import.discoveryFailed", { id: c.id, error: err.message }));
+                    // Skipping one provider keeps the rest of the batch importable.
+                    if (attempt >= 2)
+                        break;
+                    const { retry } = await prompts({ type: "toggle", name: "retry", message: t("import.retryDiscovery", { id: c.id, error: err.message }), initial: true }, { onCancel: () => cancelInteractive() });
+                    if (!retry)
+                        break;
+                }
             }
-            catch (err) {
-                fail(t("import.discoveryFailed", { id: c.id, error: err.message }));
+            if (listed === undefined) {
+                out(pc.yellow(t("import.skippedAfterFailure", { id: c.id })));
+                continue;
             }
+            ids = listed;
             ids = applyModelFilter(ids, undefined, []).kept;
         }
         if (ids.length === 0)
             fail(t("import.noModelsImport", { id: c.id }));
         const id = availableProviderId(c.id, store.providers);
         const hint = guessProviderHint(catalog, c.baseUrl);
-        const models = await enrichProviderModels(catalog, ids, { ...metadataOptions, modelsDevId: hint }, { gatewayLoader });
+        const models = await withProgress(t("progress.metadata"), () => enrichProviderModels(catalog, ids, { ...metadataOptions, modelsDevId: hint }, { gatewayLoader }));
         const defaultModel = c.defaultModel && ids.includes(c.defaultModel) ? c.defaultModel : ids[0];
         const existed = store.providers[id] !== undefined;
         store.providers[id] = {
@@ -960,9 +1148,13 @@ export async function cmdImport(opts) {
         if (!store.active)
             store.active = id;
         imported.push(id);
-        console.log(`${pc.green(t(existed ? "import.updated" : "import.imported"))} ${pc.bold(id)} · ${c.protocol} · ${c.baseUrl} · ${t("import.modelsCount", { count: ids.length })} [${t("import.from")} ${c.sources.join(", ")}]`);
+        out(`${pc.green(t(existed ? "import.updated" : "import.imported"))} ${pc.bold(id)} · ${c.protocol} · ${c.baseUrl} · ${t("import.modelsCount", { count: ids.length })} [${t("import.from")} ${c.sources.join(", ")}]`);
     }
     saveStore(store);
+    if (isJson()) {
+        emitJson({ providers: imported });
+        return;
+    }
     if (imported.length)
-        console.log(pc.dim(`\n${t("import.next", { id: imported[0] })}`));
+        note(`\n${t("import.next", { id: imported[0] })}`);
 }