agentsw 0.9.2 → 0.10.1

package/dist/menu.js

@@ -9,8 +9,9 @@ import { cmdRemoveProvider, cmdRename } from "./provider-actions.js";
 import { listRemovableProviders } from "./remove.js";
 import { providerIdFromBaseUrl } from "./slug.js";
 import { targets } from "./targets/index.js";
+import { ActionCancelled, out, setInMenu } from "./ui.js";
 function bye() {
-    console.log(pc.dim(`\n${t("menu.bye")}`));
+    out(pc.dim(`\n${t("menu.bye")}`));
     process.exit(0);
 }
 const cancel = { onCancel: () => bye() };
@@ -34,14 +35,14 @@ async function chooseLanguage() {
     const store = loadStore();
     store.language = language;
     saveStore(store);
-    console.log(pc.green(t("language.saved")));
+    out(pc.green(t("language.saved")));
 }
 /** select an existing provider; prints a hint and returns undefined when none configured */
 async function pickProvider(message) {
     const store = loadStore();
     const ids = Object.keys(store.providers);
     if (ids.length === 0) {
-        console.log(pc.yellow(t("menu.noProvidersHint")));
+        out(pc.yellow(t("menu.noProvidersHint")));
         return undefined;
     }
     const { id } = await prompts({
@@ -49,15 +50,18 @@ async function pickProvider(message) {
         name: "id",
         message,
         hint: t("menu.selectInstructions"),
-        choices: ids.map((pid) => {
-            const p = store.providers[pid];
-            return {
-                title: `${pid} · ${p.protocol} · ${t("menu.defaultModel")} ${p.defaultModel}${store.active === pid ? `  (${t("menu.active")})` : ""}`,
-                value: pid,
-            };
-        }),
+        choices: [
+            { title: t("menu.back"), value: "__back__" },
+            ...ids.map((pid) => {
+                const p = store.providers[pid];
+                return {
+                    title: `${pid} · ${p.protocol} · ${t("menu.defaultModel")} ${p.defaultModel}${store.active === pid ? `  (${t("menu.active")})` : ""}`,
+                    value: pid,
+                };
+            }),
+        ],
     }, cancel);
-    if (!id)
+    if (!id || id === "__back__")
         return undefined;
     const p = store.providers[id];
     return { id, defaultModel: p.defaultModel, models: p.models.map((m) => m.id) };
@@ -151,7 +155,7 @@ async function removeFromMenu() {
         ? listRemovableProviders(app)
         : Object.values(loadStore().providers).map((provider) => ({ id: provider.id, name: provider.name }));
     if (!entries.length) {
-        console.log(pc.dim(t("menu.noRemovable")));
+        out(pc.dim(t("menu.noRemovable")));
         return;
     }
     const { selected } = await prompts({
@@ -159,10 +163,13 @@ async function removeFromMenu() {
         name: "selected",
         message: t("menu.removeProvider"),
         hint: t("menu.selectInstructions"),
-        choices: entries.map((entry, index) => ({
-            title: `${entry.id} · ${entry.app ?? "agentsw"}${entry.name && entry.name !== entry.id ? ` · ${entry.name}` : ""}`,
-            value: index,
-        })),
+        choices: [
+            { title: t("menu.back"), value: "__back__" },
+            ...entries.map((entry, index) => ({
+                title: `${entry.id} · ${entry.app ?? "agentsw"}${entry.name && entry.name !== entry.id ? ` · ${entry.name}` : ""}`,
+                value: index,
+            })),
+        ],
     }, cancel);
     const picked = entries[selected];
     if (!picked)
@@ -179,16 +186,19 @@ async function removeFromMenu() {
     }
 }
 export async function cmdMenu() {
-    if (!loadStore().language)
+    let store = loadStore();
+    if (!store.language) {
         await chooseLanguage();
-    console.log(pc.bold("agentsw") + pc.dim(t("menu.title")));
-    if (Object.keys(loadStore().providers).length === 0) {
-        console.log(pc.yellow(t("menu.noProviders")));
+        store = loadStore(); // chooseLanguage persists the preference, so re-read before trusting the rest
+    }
+    out(pc.bold("agentsw") + pc.dim(t("menu.title")));
+    if (Object.keys(store.providers).length === 0) {
+        out(pc.yellow(t("menu.noProviders")));
         if (await askToggle(t("menu.firstScan"), true))
             await cmdImport({});
     }
     for (;;) {
-        console.log("");
+        out("");
         const { action } = await prompts({
             type: "select",
             name: "action",
@@ -214,114 +224,124 @@ export async function cmdMenu() {
         }, cancel);
         if (action === undefined || action === "quit")
             return;
-        if (action === "quickAdd") {
-            await cmdQuickAdd({});
-        }
-        else if (action === "add") {
-            const { src } = await prompts({
-                type: "select",
-                name: "src",
-                message: t("menu.modelSource"),
-                hint: t("menu.selectInstructions"),
-                choices: [
-                    { title: t("menu.modelDiscover"), value: "discover" },
-                    { title: t("menu.modelManual"), value: "manual" },
-                ],
-            }, cancel);
-            await cmdAdd({ discover: src === "discover" });
-        }
-        else if (action === "import") {
-            await cmdImport({});
-        }
-        else if (action === "use") {
-            const picked = await pickProvider(t("menu.pickProvider"));
-            if (!picked)
-                continue;
-            const apps = await pickApps(t("menu.pickApps"));
-            const { model } = await prompts({
-                type: picked.models.length > 1 ? "select" : null,
-                name: "model",
-                message: t("menu.defaultModel"),
-                hint: t("menu.selectInstructions"),
-                choices: [
-                    { title: t("menu.keepDefault", { model: picked.defaultModel }), value: "" },
-                    ...picked.models.filter((m) => m !== picked.defaultModel).map((m) => ({ title: m, value: m })),
-                ],
-            }, cancel);
-            await cmdUse(picked.id, { model: model || undefined, apps });
-        }
-        else if (action === "status") {
-            cmdStatus();
-        }
-        else if (action === "list") {
-            cmdList();
-        }
-        else if (action === "sync") {
-            await cmdSync({ apps: await pickApps(t("menu.pickApps")) });
-        }
-        else if (action === "discover") {
-            const picked = await pickProvider(t("menu.discoverFor"));
-            if (!picked)
-                continue;
-            const sync = await askToggle(t("menu.pushRefresh"));
-            await cmdDiscover(picked.id, { sync, apps: sync ? await pickApps(t("menu.pickApps")) : undefined });
-        }
-        else if (action === "metadata") {
-            const picked = await pickProvider(t("menu.metadataProvider"));
-            if (!picked)
-                continue;
-            const current = loadStore().providers[picked.id];
-            const { metadataMode } = await prompts({
-                type: "select",
-                name: "metadataMode",
-                message: t("menu.metadataMode"),
-                hint: t("menu.selectInstructions"),
-                initial: ["auto", "on", "off"].indexOf(getMetadataMode(current)),
-                choices: [
-                    { title: t("menu.metadataAuto"), description: t("menu.metadataAutoHelp"), value: "auto" },
-                    { title: t("menu.metadataOn"), description: t("menu.metadataOnHelp"), value: "on" },
-                    { title: t("menu.metadataOff"), description: t("menu.metadataOffHelp"), value: "off" },
-                ],
-            }, cancel);
-            await cmdRefreshMeta({ provider: picked.id, metadataMode });
-        }
-        else if (action === "rename" || action === "remove") {
-            try {
+        // One guard for every action: a cancelled prompt unwinds to here, and any other failure reports itself
+        // and returns to the menu instead of ending the session.
+        setInMenu(true);
+        try {
+            if (action === "quickAdd") {
+                await cmdQuickAdd({});
+            }
+            else if (action === "add") {
+                const { src } = await prompts({
+                    type: "select",
+                    name: "src",
+                    message: t("menu.modelSource"),
+                    hint: t("menu.selectInstructions"),
+                    choices: [
+                        { title: t("menu.modelDiscover"), value: "discover" },
+                        { title: t("menu.modelManual"), value: "manual" },
+                    ],
+                }, cancel);
+                await cmdAdd({ discover: src === "discover" });
+            }
+            else if (action === "import") {
+                await cmdImport({});
+            }
+            else if (action === "use") {
+                const picked = await pickProvider(t("menu.pickProvider"));
+                if (!picked)
+                    continue;
+                const apps = await pickApps(t("menu.pickApps"));
+                const { model } = await prompts({
+                    type: picked.models.length > 1 ? "select" : null,
+                    name: "model",
+                    message: t("menu.defaultModel"),
+                    hint: t("menu.selectInstructions"),
+                    choices: [
+                        { title: t("menu.keepDefault", { model: picked.defaultModel }), value: "" },
+                        ...picked.models.filter((m) => m !== picked.defaultModel).map((m) => ({ title: m, value: m })),
+                    ],
+                }, cancel);
+                await cmdUse(picked.id, { model: model || undefined, apps });
+            }
+            else if (action === "status") {
+                cmdStatus();
+            }
+            else if (action === "list") {
+                cmdList();
+            }
+            else if (action === "sync") {
+                await cmdSync({ apps: await pickApps(t("menu.pickApps")) });
+            }
+            else if (action === "discover") {
+                const picked = await pickProvider(t("menu.discoverFor"));
+                if (!picked)
+                    continue;
+                const sync = await askToggle(t("menu.pushRefresh"));
+                await cmdDiscover(picked.id, { sync, apps: sync ? await pickApps(t("menu.pickApps")) : undefined });
+            }
+            else if (action === "metadata") {
+                const picked = await pickProvider(t("menu.metadataProvider"));
+                if (!picked)
+                    continue;
+                const current = loadStore().providers[picked.id];
+                const { metadataMode } = await prompts({
+                    type: "select",
+                    name: "metadataMode",
+                    message: t("menu.metadataMode"),
+                    hint: t("menu.selectInstructions"),
+                    initial: ["auto", "on", "off"].indexOf(getMetadataMode(current)),
+                    choices: [
+                        { title: t("menu.metadataAuto"), description: t("menu.metadataAutoHelp"), value: "auto" },
+                        { title: t("menu.metadataOn"), description: t("menu.metadataOnHelp"), value: "on" },
+                        { title: t("menu.metadataOff"), description: t("menu.metadataOffHelp"), value: "off" },
+                    ],
+                }, cancel);
+                await cmdRefreshMeta({ provider: picked.id, metadataMode });
+            }
+            else if (action === "rename" || action === "remove") {
                 if (action === "rename")
                     await renameFromMenu();
                 else
                     await removeFromMenu();
             }
-            catch (error) {
-                console.error(pc.red(error instanceof Error ? error.message : String(error)));
+            else if (action === "apps") {
+                await cmdApps();
+                if (await askToggle(t("menu.upgrade")))
+                    await cmdUpgrade([]);
             }
-        }
-        else if (action === "apps") {
-            await cmdApps();
-            if (await askToggle(t("menu.upgrade")))
-                await cmdUpgrade([]);
-        }
-        else if (action === "install") {
-            const installable = appPackages
-                .filter((a) => !installedVersion(a) && appCommand(a, "install"))
-                .map((a) => ({ title: `${a.id} · ${a.name}`, value: a.id }));
-            if (installable.length === 0) {
-                console.log(pc.dim(t("menu.allInstalled")));
-                continue;
+            else if (action === "install") {
+                const installable = appPackages
+                    .filter((a) => !installedVersion(a) && appCommand(a, "install"))
+                    .map((a) => ({ title: `${a.id} · ${a.name}`, value: a.id }));
+                if (installable.length === 0) {
+                    out(pc.dim(t("menu.allInstalled")));
+                    continue;
+                }
+                const { appId } = await prompts({
+                    type: "select",
+                    name: "appId",
+                    message: t("menu.pickApp"),
+                    hint: t("menu.selectInstructions"),
+                    choices: installable,
+                }, cancel);
+                if (!appId)
+                    continue;
+                await cmdInstall(appId);
             }
-            const { appId } = await prompts({
-                type: "select",
-                name: "appId",
-                message: t("menu.pickApp"),
-                hint: t("menu.selectInstructions"),
-                choices: installable,
-            }, cancel);
-            if (!appId)
-                continue;
-            await cmdInstall(appId);
+            else if (action === "language") {
+                await chooseLanguage();
+            }
+        }
+        catch (error) {
+            // Ctrl-C inside a sub-prompt means "abandon this action", not "quit the app".
+            if (error instanceof ActionCancelled)
+                out(pc.dim(t("menu.cancelledAction")));
+            else
+                console.error(pc.red(error instanceof Error ? error.message : String(error)));
         }
-        else if (action === "language") {
-            await chooseLanguage();
+        finally {
+            setInMenu(false);
         }
     }
 }

package/dist/metadata.js

@@ -116,7 +116,10 @@ function indexCatalog(catalog) {
     for (const provider of Object.values(catalog)) {
         for (const [key, model] of Object.entries(provider.models)) {
             const modelId = model.id.includes("/") ? model.id : `${provider.id}/${model.id}`;
-            const entry = { provider: provider.id, modelId, identity: model.canonical_model_id ?? modelId, model };
+            const entry = {
+                provider: provider.id, modelId, identity: model.canonical_model_id ?? modelId,
+                claimed: model.canonical_model_id !== undefined, model,
+            };
             for (const id of new Set([key, model.id]))
                 push(exact, id, entry);
             push(canonical, modelId, entry);
@@ -125,10 +128,29 @@ function indexCatalog(catalog) {
     }
     return { exact, canonical, identities };
 }
+/**
+ * The identities a group of catalog rows stands for.
+ *
+ * Only `canonical_model_id` is evidence. Counting the fallback guess of a row
+ * that declares nothing would let one sloppy reseller row invent a second
+ * creator and block an otherwise unique match — the id then reports as
+ * ambiguous even though every row that does carry the field names one model.
+ * A group where *nothing* declares an identity is a different situation: there
+ * is no primary evidence to weigh, so the listings' own ids are all the group
+ * can be held to, which is exactly the conservative answer. An empty group
+ * stays empty — that is "no evidence at all", not "one guess".
+ */
+function claimIdentities(entries) {
+    const list = entries ?? [];
+    const claimed = new Set(list.filter((entry) => entry.claimed).map((entry) => entry.identity));
+    if (claimed.size)
+        return claimed;
+    return new Set(list.map((entry) => entry.identity));
+}
 /** Creator identity of a catalog model id, or undefined when its rows disagree. */
 function catalogIdentity(index, modelId) {
-    const identities = new Set(index?.canonical.get(modelId)?.map((entry) => entry.identity));
-    return identities?.size === 1 ? [...identities][0] : undefined;
+    const identities = claimIdentities(index?.canonical.get(modelId));
+    return identities.size === 1 ? [...identities][0] : undefined;
 }
 /**
  * The creator's own listing for an identity, when models.dev carries one.
@@ -164,7 +186,7 @@ function selectExact(index, id, hint, aliases, gateway, gatewayBareIds) {
             const candidate = gatewayBareIds?.get(id);
             const evidence = index?.exact.get(id);
             const hintedEvidence = hint ? evidence?.filter((entry) => entry.provider === hint) : undefined;
-            const identities = new Set((hintedEvidence?.length ? hintedEvidence : evidence)?.map((entry) => entry.identity));
+            const identities = claimIdentities(hintedEvidence?.length ? hintedEvidence : evidence);
             // Gateway names the creator while models.dev names the listing provider, so
             // the two agree only once both are reduced to a creator identity. A gateway
             // id the catalog has no row for stands for itself.
@@ -181,7 +203,7 @@ function selectExact(index, id, hint, aliases, gateway, gatewayBareIds) {
         : (bare && hint ? index?.canonical.get(`${hint}/${id}`) : undefined)
             ?? index?.canonical.get(id) ?? index?.exact.get(id);
     const hinted = candidates?.find((entry) => entry.provider === hint);
-    const identities = new Set(candidates?.map((entry) => entry.identity));
+    const identities = claimIdentities(candidates);
     // Reseller rows for one model share an identity but disagree on limits and
     // prices, so only the creator's own row is authoritative.
     const primary = hinted ?? (identities.size === 1 ? creatorEntry(index, [...identities][0]) : undefined);
@@ -440,10 +462,13 @@ export function classifyUnresolved(catalog, ids, hint) {
         const candidates = hinted ?? index.canonical.get(id) ?? index.exact.get(id);
         if (!candidates?.length)
             unknown.push(id);
-        else if (new Set(candidates.map((entry) => entry.identity)).size > 1)
-            ambiguous.push(id);
-        else if (!creatorEntry(index, [...new Set(candidates.map((entry) => entry.identity))][0]))
-            noCreatorRow.push(id);
+        else {
+            const identities = claimIdentities(candidates);
+            if (identities.size > 1)
+                ambiguous.push(id);
+            else if (!creatorEntry(index, [...identities][0]))
+                noCreatorRow.push(id);
+        }
     }
     return { ambiguous, unknown, noCreatorRow };
 }

package/dist/modelsdev.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import fs from "node:fs";
 import { configDir } from "./store.js";
 import { readJsonIfExists, writeFileAtomic } from "./fsutil.js";
+import { warn } from "./ui.js";
 const API_URL = "https://models.dev/api.json";
 const CACHE_FILE = path.join(configDir, "models-dev.json");
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
@@ -10,29 +11,56 @@ const catalogFetchedAt = new WeakMap();
 export function getCatalogFetchedAt(catalog) {
     return catalogFetchedAt.get(catalog);
 }
+/**
+ * models.dev maps provider ids to providers, each carrying a model dictionary.
+ * A 200 response that is not shaped like a catalog (an error document from a proxy
+ * or mirror, say) must never be cached: later runs would then re-read the broken
+ * file on every load, long after the network recovered.
+ */
+function isCatalog(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    return Object.values(value).every((provider) => {
+        if (!provider || typeof provider !== "object" || Array.isArray(provider))
+            return false;
+        const models = provider.models;
+        return !!models && typeof models === "object" && !Array.isArray(models);
+    });
+}
+/** A cache file that is missing, unreadable or malformed is simply not a catalog. */
 function readCachedCatalog() {
-    const catalog = readJsonIfExists(CACHE_FILE);
-    if (catalog) {
-        try {
-            catalogFetchedAt.set(catalog, fs.statSync(CACHE_FILE).mtime.toISOString());
-        }
-        catch {
-            // A concurrently removed cache still supplies useful metadata without a fetch time.
-        }
+    let parsed;
+    try {
+        parsed = readJsonIfExists(CACHE_FILE);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isCatalog(parsed))
+        return undefined;
+    const catalog = parsed;
+    try {
+        catalogFetchedAt.set(catalog, fs.statSync(CACHE_FILE).mtime.toISOString());
+    }
+    catch {
+        // A concurrently removed cache still supplies useful metadata without a fetch time.
     }
     return catalog;
 }
+function cacheIsFresh() {
+    try {
+        return Date.now() - fs.statSync(CACHE_FILE).mtimeMs < CACHE_TTL_MS;
+    }
+    catch {
+        return false;
+    }
+}
 export async function loadCatalog(opts = {}) {
     if (!opts.refresh) {
-        try {
-            const stat = fs.statSync(CACHE_FILE);
-            const fresh = Date.now() - stat.mtimeMs < CACHE_TTL_MS;
-            if (fresh || opts.offline)
-                return readCachedCatalog();
-        }
-        catch {
-            /* no cache */
-        }
+        const cached = readCachedCatalog();
+        // A malformed cache falls through to a fetch rather than failing the command.
+        if (cached && (opts.offline || cacheIsFresh()))
+            return cached;
     }
     if (opts.offline)
         return readCachedCatalog();
@@ -41,17 +69,19 @@ export async function loadCatalog(opts = {}) {
         if (!res.ok)
             throw new Error(`models.dev responded ${res.status}`);
         const text = await res.text();
-        const catalog = JSON.parse(text); // validate before caching
+        const parsed = JSON.parse(text);
+        if (!isCatalog(parsed))
+            throw new Error("models.dev returned an unexpected catalog shape");
         writeFileAtomic(CACHE_FILE, text);
-        catalogFetchedAt.set(catalog, new Date().toISOString());
-        return catalog;
+        catalogFetchedAt.set(parsed, new Date().toISOString());
+        return parsed;
     }
     catch (err) {
         // network failure: fall back to stale cache if present
         const cached = readCachedCatalog();
         if (cached)
             return cached;
-        process.stderr.write(`warning: could not fetch models.dev catalog: ${err.message}\n`);
+        warn(`could not fetch models.dev catalog: ${err.message}`);
         return undefined;
     }
 }

package/dist/progress.js

@@ -0,0 +1,116 @@
+import pc from "picocolors";
+import { isJson, isQuiet, note } from "./ui.js";
+const FRAMES = ["|", "/", "-", "\\"];
+const CLEAR = "\r\u001b[2K";
+/** `npm test` frequently runs in a real terminal, where stderr is still a TTY — never animate under it. */
+function isTestRunner() {
+    return process.env.NODE_TEST_CONTEXT !== undefined || process.argv.includes("--test");
+}
+export function progressEnabled(options = {}) {
+    if (options.enabled !== undefined)
+        return options.enabled;
+    const stream = options.stream ?? process.stderr;
+    return stream.isTTY === true
+        && !isJson()
+        && !isQuiet()
+        && !isTestRunner()
+        && process.env.AGENTSW_NO_PROGRESS !== "1";
+}
+let live;
+/**
+ * Progress feedback for slow awaits. Renders one animated stderr line on a TTY; everywhere else it degrades
+ * to the single dim line the CLI printed before, so pipes and CI logs keep exactly the same content.
+ */
+export function startProgress(message, options = {}) {
+    // A nested caller borrows the live line: it may retitle it, but stopping must not tear down the owner.
+    if (live) {
+        const owner = live;
+        const previous = owner.setText(message);
+        let finished = false;
+        return {
+            update(next) { owner.setText(next); },
+            stop() {
+                if (finished)
+                    return;
+                finished = true;
+                owner.setText(previous);
+            },
+            succeed() { },
+            fail() { },
+        };
+    }
+    const enabled = progressEnabled(options);
+    const stream = options.stream ?? process.stderr;
+    const intervalMs = options.intervalMs ?? 80;
+    const delayMs = options.delayMs ?? 150;
+    const frames = options.frames ?? FRAMES;
+    let text = message;
+    let frame = 0;
+    let timer;
+    let painted = false;
+    let stopped = false;
+    // Disabled path: reproduce the old static line exactly once. Callers no longer print it themselves.
+    if (!enabled)
+        note(message);
+    const clear = () => {
+        if (painted)
+            stream.write(CLEAR);
+        painted = false;
+    };
+    const paint = () => {
+        stream.write(`${CLEAR}${pc.dim(frames[frame % frames.length])} ${pc.dim(text)}`);
+        painted = true;
+        frame++;
+    };
+    const onInterrupt = () => {
+        clear();
+        process.exit(130);
+    };
+    const finish = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        if (timer) {
+            clearTimeout(timer);
+            clearInterval(timer);
+            timer = undefined;
+        }
+        if (enabled)
+            process.removeListener("SIGINT", onInterrupt);
+        clear();
+        if (live?.handle === handle)
+            live = undefined;
+    };
+    const handle = {
+        update(next) { text = next; },
+        stop: finish,
+        succeed(message) { finish(); if (message)
+            note(message); },
+        fail(message) { finish(); if (message)
+            stream.write(pc.red(message) + "\n"); },
+    };
+    live = { handle, setText(next) { const previous = text; text = next; return previous; } };
+    if (enabled) {
+        process.once("SIGINT", onInterrupt);
+        // Nothing is painted until the delay elapses, so cached and local work never flickers.
+        timer = setTimeout(() => {
+            if (stopped)
+                return;
+            paint();
+            timer = setInterval(() => { if (!stopped)
+                paint(); }, intervalMs);
+            timer.unref();
+        }, delayMs);
+        timer.unref();
+    }
+    return handle;
+}
+export async function withProgress(message, fn, options) {
+    const handle = startProgress(message, options);
+    try {
+        return await fn(handle);
+    }
+    finally {
+        handle.stop();
+    }
+}