theclawbay 0.3.30 → 0.3.32

package/README.md

@@ -19,13 +19,6 @@ theclawbay setup --api-key <apiKey>
 In an interactive terminal, setup shows one picker for Codex, Continue, Cline, OpenClaw, OpenCode, Kilo, Roo Code, Aider, and Windows Trae.
 Each row includes a terminal-friendly icon plus the tool's official site, and you can toggle items with arrow keys plus `Enter` or by pressing their number.
 
-History notes:
-
-- Continue setup only updates `~/.continue/config.yaml` and leaves `~/.continue/sessions` untouched.
-- Cline setup only updates `~/.cline/data/globalState.json` and `~/.cline/data/secrets.json`; task history stays in `~/.cline/state` and `~/.cline/tasks`.
-- Roo Code setup uses a managed auto-import file plus editor settings and does not touch task history. Imported Roo profiles can persist inside Roo after first launch.
-- Aider setup appends a managed block to `~/.aider.conf.yml` and enables `restore-chat-history: true` without touching `.aider.chat.history.md`.
-
 ## Optional
 
 `theclawbay link --api-key <apiKey>`

package/dist/commands/logout.js

@@ -678,10 +678,10 @@ class LogoutCommand extends base_command_1.BaseCommand {
                 this.log("- Codex login state: no cleanup needed.");
             }
             if (modelCacheCleanup.action === "removed") {
-                this.log("- Codex model cache: removed the Claw Bay GPT-5.4 seed.");
+                this.log("- Codex model cache: removed the Claw Bay GPT-5.4 / GPT-5.4 Mini seed.");
             }
             else if (modelCacheCleanup.action === "preserved") {
-                this.log("- Codex model cache: preserved an existing GPT-5.4 entry.");
+                this.log("- Codex model cache: preserved an existing GPT-5.4 / GPT-5.4 Mini entry.");
             }
             else if (modelCacheCleanup.warning) {
                 this.log(`- Codex model cache: ${modelCacheCleanup.warning}`);

package/dist/commands/setup.js

@@ -460,25 +460,51 @@ async function promptForSetupClients(clients) {
         const wasRaw = stdin.isRaw;
         const applyIndex = options.length;
         const hyperlinksEnabled = supportsTerminalHyperlinks();
+        const ansi = {
+            reset: "\x1b[0m",
+            bold: "\x1b[1m",
+            dim: "\x1b[2m",
+            inverse: "\x1b[7m",
+            red: "\x1b[31m",
+            green: "\x1b[32m",
+            yellow: "\x1b[33m",
+            gray: "\x1b[90m",
+        };
+        const paint = (text, ...codes) => `${codes.join("")}${text}${ansi.reset}`;
         const clearScreen = () => {
             stdout.write("\x1b[2J\x1b[H");
         };
         const selectedCount = () => options.filter((option) => option.checked).length;
         const render = () => {
             clearScreen();
-            stdout.write("Choose local clients to configure\n");
-            stdout.write(`Use ↑/↓ to move, Enter to toggle the highlighted integration, or press 1-${options.length} to toggle directly.\n`);
-            stdout.write("Each tool name links to its official site when your terminal supports it.\n");
-            stdout.write("Move to Apply setup and press Enter when you're ready.\n\n");
+            stdout.write(`${paint("Choose local clients to configure", ansi.bold)}\n`);
+            stdout.write(`${paint(`Use ↑/↓ to move, Enter to toggle the highlighted integration, or press 1-${options.length} to toggle directly.`, ansi.dim, ansi.gray)}\n`);
+            stdout.write(`${paint("Each tool name links to its official site when your terminal supports it.", ansi.dim, ansi.gray)}\n`);
+            stdout.write(`${paint("Move to Apply setup and press Enter when you're ready.", ansi.dim, ansi.gray)}\n\n`);
             for (const [index, option] of options.entries()) {
-                const pointer = index === cursor ? ">" : " ";
-                const mark = option.detected ? (option.checked ? "[x]" : "[ ]") : "[-]";
-                const badge = option.detected ? (option.recommended ? "recommended" : "optional") : "not detected";
-                stdout.write(`${pointer} ${index + 1}. ${mark} ${formatSetupClientLabel(option, hyperlinksEnabled)}  ${badge}\n`);
+                const pointer = index === cursor ? paint(">", ansi.bold) : " ";
+                const mark = option.detected
+                    ? option.checked
+                        ? paint("[x]", ansi.green, ansi.bold)
+                        : paint("[ ]", ansi.gray)
+                    : paint("[-]", ansi.red, ansi.bold);
+                const badge = option.detected
+                    ? option.recommended
+                        ? paint("recommended", ansi.green)
+                        : paint("optional", ansi.yellow)
+                    : paint("not detected", ansi.red);
+                const label = option.detected
+                    ? formatSetupClientLabel(option, hyperlinksEnabled)
+                    : paint(formatSetupClientLabel(option, hyperlinksEnabled), ansi.dim, ansi.gray);
+                stdout.write(`${pointer} ${index + 1}. ${mark} ${label}  ${badge}\n`);
             }
             const applyPointer = cursor === applyIndex ? ">" : " ";
-            stdout.write(`${applyPointer} Apply setup with ${selectedCount()} selected integration${selectedCount() === 1 ? "" : "s"}\n`);
-            stdout.write(`\n${hint}\n`);
+            const applyLabel = `Apply setup (${selectedCount()} selected)`;
+            const applyStyled = cursor === applyIndex
+                ? paint(` ${applyLabel} `, ansi.inverse, ansi.bold, ansi.green)
+                : paint(applyLabel, ansi.bold, ansi.green);
+            stdout.write(`\n${applyPointer} ${applyStyled}\n`);
+            stdout.write(`\n${paint(hint, ansi.dim, ansi.gray)}\n`);
         };
         const finish = () => {
             if (settled)
@@ -1467,19 +1493,19 @@ class SetupCommand extends base_command_1.BaseCommand {
                     this.log(`- Conversation cache: could not update local Codex history DB.${detail}`);
                 }
                 if (modelCacheMigration?.action === "seeded") {
-                    this.log("- Codex model cache: added GPT-5.4 to the local picker cache.");
+                    this.log("- Codex model cache: added GPT-5.4 / GPT-5.4 Mini to the local picker cache.");
                 }
                 else if (modelCacheMigration?.action === "created") {
-                    this.log("- Codex model cache: created a local picker cache with GPT-5.4.");
+                    this.log("- Codex model cache: created a local picker cache with GPT-5.4 / GPT-5.4 Mini.");
                 }
                 else if (modelCacheMigration?.action === "refreshed") {
-                    this.log("- Codex model cache: refreshed the local picker cache for GPT-5.4.");
+                    this.log("- Codex model cache: refreshed the local picker cache for GPT-5.4 / GPT-5.4 Mini.");
                 }
                 else if (modelCacheMigration?.action === "already_seeded") {
-                    this.log("- Codex model cache: GPT-5.4 was already seeded locally.");
+                    this.log("- Codex model cache: GPT-5.4 / GPT-5.4 Mini were already seeded locally.");
                 }
                 else if (modelCacheMigration?.action === "already_present") {
-                    this.log("- Codex model cache: GPT-5.4 already existed locally.");
+                    this.log("- Codex model cache: GPT-5.4 / GPT-5.4 Mini already existed locally.");
                 }
                 else if (modelCacheMigration?.warning) {
                     this.log(`- Codex model cache: ${modelCacheMigration.warning}`);

package/dist/lib/codex-model-cache-migration.js

@@ -14,10 +14,13 @@ const supported_models_1 = require("./supported-models");
 const MODELS_CACHE_FILE = "models_cache.json";
 const MODELS_CACHE_STATE_FILE = "theclawbay.models-cache.json";
 const STATE_DB_FILE_PATTERN = /^state_\d+\.sqlite$/;
-const TARGET_MODEL_ID = "gpt-5.4";
+const TARGET_MODEL_IDS = ["gpt-5.4", "gpt-5.4-mini"];
+const TARGET_MODEL_ID_SET = new Set(TARGET_MODEL_IDS);
 const SEED_MARKER_KEY = "_theclawbay_seeded";
-const SEED_MARKER_VALUE = "gpt-5.4";
-const TEMPLATE_MODEL_IDS = (0, supported_models_1.getSupportedModelIds)().filter((id) => id !== TARGET_MODEL_ID);
+// Older releases stored the model id as the marker value; accept those so cleanup still works.
+const SEED_MARKER_VALUE = "theclawbay";
+const LEGACY_SEED_MARKER_VALUES = new Set(["gpt-5.4", SEED_MARKER_VALUE, true]);
+const TEMPLATE_MODEL_IDS = (0, supported_models_1.getSupportedModelIds)().filter((id) => !TARGET_MODEL_ID_SET.has(id));
 const DEFAULT_REASONING_LEVELS = [
     { effort: "low", description: "Fast responses with lighter reasoning" },
     { effort: "medium", description: "Balances speed and reasoning depth for everyday tasks" },
@@ -88,29 +91,66 @@ async function removeFileIfExists(filePath) {
             throw error;
     }
 }
+function normalizePatchFingerprintMap(state) {
+    if (!state)
+        return {};
+    if (state.version === 1) {
+        if (!TARGET_MODEL_ID_SET.has(state.modelId))
+            return {};
+        return state.fingerprint ? { [state.modelId]: state.fingerprint } : {};
+    }
+    const output = {};
+    for (const entry of state.models) {
+        if (!TARGET_MODEL_ID_SET.has(entry.modelId))
+            continue;
+        if (entry.fingerprint)
+            output[entry.modelId] = entry.fingerprint;
+    }
+    return output;
+}
 async function readPatchState(statePath) {
     const parsed = await readJsonIfExists(statePath);
     const obj = objectRecordOr(parsed);
     if (!obj)
-        return null;
-    if (obj.version !== 1)
-        return null;
-    if (obj.modelId !== TARGET_MODEL_ID)
-        return null;
-    if (typeof obj.fingerprint !== "string" || !obj.fingerprint)
-        return null;
-    return {
-        version: 1,
-        modelId: TARGET_MODEL_ID,
-        fingerprint: obj.fingerprint,
-    };
+        return {};
+    const version = obj.version;
+    if (version === 1) {
+        const modelId = typeof obj.modelId === "string" ? obj.modelId : "";
+        const fingerprint = typeof obj.fingerprint === "string" ? obj.fingerprint : "";
+        if (!modelId || !fingerprint)
+            return {};
+        return normalizePatchFingerprintMap({ version: 1, modelId, fingerprint });
+    }
+    if (version === 2) {
+        const modelsRaw = obj.models;
+        if (!Array.isArray(modelsRaw))
+            return {};
+        const models = [];
+        for (const entry of modelsRaw) {
+            const record = objectRecordOr(entry);
+            if (!record)
+                continue;
+            const modelId = typeof record.modelId === "string" ? record.modelId : "";
+            const fingerprint = typeof record.fingerprint === "string" ? record.fingerprint : "";
+            if (!modelId || !fingerprint)
+                continue;
+            models.push({ modelId, fingerprint });
+        }
+        return normalizePatchFingerprintMap({ version: 2, models });
+    }
+    return {};
 }
-async function writePatchState(statePath, fingerprint) {
+async function writePatchState(statePath, fingerprints) {
     await promises_1.default.mkdir(node_path_1.default.dirname(statePath), { recursive: true });
+    const models = TARGET_MODEL_IDS.flatMap((modelId) => {
+        const fingerprint = fingerprints[modelId];
+        if (!fingerprint)
+            return [];
+        return [{ modelId, fingerprint }];
+    });
     const contents = JSON.stringify({
-        version: 1,
-        modelId: TARGET_MODEL_ID,
-        fingerprint,
+        version: 2,
+        models,
     }, null, 2);
     await promises_1.default.writeFile(statePath, `${contents}\n`, "utf8");
 }
@@ -118,18 +158,23 @@ function findModel(models, slug) {
     return models.find((entry) => entry.slug === slug) ?? null;
 }
 function hasSeedMarker(model) {
-    return model[SEED_MARKER_KEY] === SEED_MARKER_VALUE;
+    return LEGACY_SEED_MARKER_VALUES.has(model[SEED_MARKER_KEY]);
 }
 function applySeedMarker(model) {
     const next = cloneJson(model);
     next[SEED_MARKER_KEY] = SEED_MARKER_VALUE;
     return next;
 }
-function normalizeSeedModel(template) {
+function seedDescription(modelId) {
+    if (modelId === "gpt-5.4-mini")
+        return "Smaller GPT-5.4 variant for quick iterations.";
+    return "Latest frontier agentic coding model.";
+}
+function normalizeSeedModel(template, modelId) {
     const seed = applySeedMarker(template ?? {});
-    seed.slug = TARGET_MODEL_ID;
-    seed.display_name = TARGET_MODEL_ID;
-    seed.description = "Latest frontier agentic coding model.";
+    seed.slug = modelId;
+    seed.display_name = modelId;
+    seed.description = seedDescription(modelId);
     if (typeof seed.default_reasoning_level !== "string") {
         seed.default_reasoning_level = "medium";
     }
@@ -182,13 +227,13 @@ function normalizeSeedModel(template) {
     }
     return seed;
 }
-function buildSeedModel(models) {
+function buildSeedModel(models, modelId) {
     for (const candidate of TEMPLATE_MODEL_IDS) {
         const template = findModel(models, candidate);
         if (template)
-            return normalizeSeedModel(template);
+            return normalizeSeedModel(template, modelId);
     }
-    return normalizeSeedModel(null);
+    return normalizeSeedModel(null, modelId);
 }
 function setCacheFreshnessMetadata(doc, clientVersion) {
     let changed = false;
@@ -342,70 +387,115 @@ async function ensureCodexModelCacheHasGpt54(params) {
                 await removeFileIfExists(statePath);
                 return {
                     action: "skipped",
-                    warning: "Codex models cache was not found, and Codex version could not be inferred for a safe GPT-5.4 seed.",
+                    warning: "Codex models cache was not found, and Codex version could not be inferred for a safe GPT-5.4 / GPT-5.4 Mini seed.",
                 };
             }
-            const seed = buildSeedModel([]);
+            const docModels = [];
+            const nextState = {};
+            for (const modelId of TARGET_MODEL_IDS) {
+                const seed = buildSeedModel(docModels, modelId);
+                docModels.push(seed);
+                nextState[modelId] = fingerprintModel(seed);
+            }
             const doc = {
                 fetched_at: new Date().toISOString(),
                 client_version: clientVersion,
-                models: [seed],
+                models: docModels,
             };
             await promises_1.default.mkdir(params.codexHome, { recursive: true });
             await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-            await writePatchState(statePath, fingerprintModel(seed));
+            await writePatchState(statePath, nextState);
             return { action: "created" };
         }
         const doc = normalizeCacheDocument(parsed);
         if (!doc) {
             return {
                 action: "skipped",
-                warning: "Codex models cache exists but is not valid JSON in the expected format; skipped GPT-5.4 seed.",
+                warning: "Codex models cache exists but is not valid JSON in the expected format; skipped GPT-5.4 / GPT-5.4 Mini seed.",
             };
         }
         const clientVersion = (await inferCodexClientVersion(params.codexHome)) ??
             (typeof doc.client_version === "string" && doc.client_version ? doc.client_version : null);
-        const existingModel = findModel(doc.models, TARGET_MODEL_ID);
-        if (existingModel) {
-            const currentFingerprint = fingerprintModel(existingModel);
-            if (existingState && existingState.fingerprint === currentFingerprint && !hasSeedMarker(existingModel)) {
-                const seededModel = applySeedMarker(existingModel);
-                doc.models = doc.models.map((entry) => (entry.slug === TARGET_MODEL_ID ? seededModel : entry));
-                setCacheFreshnessMetadata(doc, clientVersion);
-                await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-                await writePatchState(statePath, fingerprintModel(seededModel));
-                return { action: "seeded" };
-            }
-            if (hasSeedMarker(existingModel)) {
-                const docChanged = setCacheFreshnessMetadata(doc, clientVersion);
-                if (!existingState || existingState.fingerprint !== currentFingerprint) {
-                    await writePatchState(statePath, currentFingerprint);
-                    await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-                    return { action: "refreshed" };
+        let changed = false;
+        let seeded = false;
+        let stateChanged = false;
+        const nextState = { ...existingState };
+        for (const modelId of TARGET_MODEL_IDS) {
+            const existingModel = findModel(doc.models, modelId);
+            const trackedFingerprint = existingState[modelId];
+            if (existingModel) {
+                const currentFingerprint = fingerprintModel(existingModel);
+                if (hasSeedMarker(existingModel)) {
+                    if (!trackedFingerprint || trackedFingerprint !== currentFingerprint) {
+                        nextState[modelId] = currentFingerprint;
+                        stateChanged = true;
+                    }
+                    continue;
                 }
-                if (docChanged) {
-                    await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-                    return { action: "refreshed" };
+                if (trackedFingerprint && trackedFingerprint === currentFingerprint) {
+                    const seededModel = applySeedMarker(existingModel);
+                    doc.models = doc.models.map((entry) => (entry.slug === modelId ? seededModel : entry));
+                    nextState[modelId] = fingerprintModel(seededModel);
+                    seeded = true;
+                    changed = true;
+                    stateChanged = true;
+                    continue;
                 }
-                return { action: "already_seeded" };
+                if (trackedFingerprint && trackedFingerprint !== currentFingerprint) {
+                    delete nextState[modelId];
+                    stateChanged = true;
+                }
+                continue;
             }
-            if (existingState && existingState.fingerprint !== currentFingerprint) {
-                await removeFileIfExists(statePath);
+            const seed = buildSeedModel(doc.models, modelId);
+            doc.models = [seed, ...doc.models];
+            nextState[modelId] = fingerprintModel(seed);
+            seeded = true;
+            changed = true;
+            stateChanged = true;
+        }
+        // Keep The Claw Bay seeds grouped at the top for easy discovery in the picker.
+        const bySlug = new Map();
+        const rest = [];
+        for (const entry of doc.models) {
+            const slug = typeof entry.slug === "string" ? entry.slug : "";
+            if (slug && TARGET_MODEL_ID_SET.has(slug) && !bySlug.has(slug)) {
+                bySlug.set(slug, entry);
+                continue;
             }
-            if (setCacheFreshnessMetadata(doc, clientVersion)) {
-                await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-                return { action: "refreshed" };
+            rest.push(entry);
+        }
+        const orderedTargets = [];
+        for (const id of TARGET_MODEL_IDS) {
+            const entry = bySlug.get(id);
+            if (entry)
+                orderedTargets.push(entry);
+        }
+        doc.models = [...orderedTargets, ...rest];
+        if (setCacheFreshnessMetadata(doc, clientVersion)) {
+            changed = true;
+        }
+        if (changed) {
+            await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+        }
+        const hasAnyTracked = TARGET_MODEL_IDS.some((id) => Boolean(nextState[id]));
+        if (!hasAnyTracked) {
+            if (Object.keys(existingState).length > 0) {
+                await removeFileIfExists(statePath);
             }
-            return {
-                action: existingState && existingState.fingerprint === currentFingerprint ? "already_seeded" : "already_present",
-            };
         }
-        const seed = buildSeedModel(doc.models);
-        doc.models = [seed, ...doc.models];
-        setCacheFreshnessMetadata(doc, clientVersion);
-        await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
-        await writePatchState(statePath, fingerprintModel(seed));
-        return { action: "seeded" };
+        else if (stateChanged || seeded) {
+            await writePatchState(statePath, nextState);
+        }
+        if (seeded)
+            return { action: "seeded" };
+        if (changed || stateChanged)
+            return { action: "refreshed" };
+        const allSeeded = TARGET_MODEL_IDS.every((id) => {
+            const model = findModel(doc.models, id);
+            return Boolean(model && hasSeedMarker(model));
+        });
+        return { action: allSeeded ? "already_seeded" : "already_present" };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -420,7 +510,7 @@ async function cleanupSeededCodexModelCache(params) {
     const statePath = node_path_1.default.join(params.codexHome, MODELS_CACHE_STATE_FILE);
     try {
         const state = await readPatchState(statePath);
-        if (!state) {
+        if (Object.keys(state).length === 0) {
             return { action: "none" };
         }
         const parsed = await readJsonIfExists(cachePath);
@@ -432,27 +522,26 @@ async function cleanupSeededCodexModelCache(params) {
         if (!doc) {
             return {
                 action: "none",
-                warning: "Codex models cache exists but is not valid JSON in the expected format; left GPT-5.4 cache patch state untouched.",
+                warning: "Codex models cache exists but is not valid JSON in the expected format; left GPT-5.4 / GPT-5.4 Mini cache patch state untouched.",
             };
         }
-        const existingModel = findModel(doc.models, TARGET_MODEL_ID);
-        if (!existingModel) {
-            await removeFileIfExists(statePath);
-            return { action: "none" };
-        }
-        const currentFingerprint = fingerprintModel(existingModel);
-        if (!hasSeedMarker(existingModel)) {
-            await removeFileIfExists(statePath);
-            return { action: "preserved" };
-        }
-        if (currentFingerprint !== state.fingerprint) {
-            await writePatchState(statePath, currentFingerprint);
-            doc.models = doc.models.filter((entry) => entry.slug !== TARGET_MODEL_ID);
-            await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+        let removed = 0;
+        let preserved = 0;
+        doc.models = doc.models.filter((entry) => {
+            const slug = typeof entry.slug === "string" ? entry.slug : "";
+            if (!slug || !TARGET_MODEL_ID_SET.has(slug))
+                return true;
+            if (!hasSeedMarker(entry)) {
+                preserved += 1;
+                return true;
+            }
+            removed += 1;
+            return false;
+        });
+        if (removed === 0) {
             await removeFileIfExists(statePath);
-            return { action: "removed" };
+            return { action: preserved > 0 ? "preserved" : "none" };
         }
-        doc.models = doc.models.filter((entry) => entry.slug !== TARGET_MODEL_ID);
         await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
         await removeFileIfExists(statePath);
         return { action: "removed" };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theclawbay",
-  "version": "0.3.30",
+  "version": "0.3.32",
   "description": "CLI for connecting Codex, Continue, Cline, OpenClaw, OpenCode, Kilo, Roo Code, Aider, and experimental Trae to The Claw Bay.",
   "license": "MIT",
   "bin": {

package/theclawbay-supported-models.json

@@ -8,6 +8,15 @@
     "cachedInputPer1M": 0.25,
     "outputPer1M": 15.0
   },
+  {
+    "id": "gpt-5.4-mini",
+    "label": "GPT-5.4 Mini",
+    "note": "Smaller GPT-5.4 variant for quick iterations.",
+    "tone": "sea",
+    "inputPer1M": 1.25,
+    "cachedInputPer1M": 0.125,
+    "outputPer1M": 10.0
+  },
   {
     "id": "gpt-5.3-codex",
     "label": "GPT-5.3 Codex",