theclawbay 0.3.2 → 0.3.4

package/dist/commands/logout.js

@@ -8,6 +8,7 @@ const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const base_command_1 = require("../lib/base-command");
 const codex_history_migration_1 = require("../lib/codex-history-migration");
+const codex_model_cache_migration_1 = require("../lib/codex-model-cache-migration");
 const paths_1 = require("../lib/config/paths");
 const OPENAI_PROVIDER_ID = "openai";
 const DEFAULT_PROVIDER_ID = "theclawbay";
@@ -245,6 +246,9 @@ class LogoutCommand extends base_command_1.BaseCommand {
                 targetProvider: OPENAI_PROVIDER_ID,
                 sourceProviders: HISTORY_PROVIDER_DB_MIGRATE_SOURCES,
             });
+            const modelCacheCleanup = await (0, codex_model_cache_migration_1.cleanupSeededCodexModelCache)({
+                codexHome: paths_1.codexDir,
+            });
             delete process.env[ENV_KEY_NAME];
             this.log("Logout complete");
             this.log(`- Managed configs removed: ${deletedManagedPaths}`);
@@ -271,6 +275,18 @@ class LogoutCommand extends base_command_1.BaseCommand {
                 const detail = stateDbMigration.warning ? ` ${stateDbMigration.warning}` : "";
                 this.log(`- Conversation cache: could not update local Codex history DB.${detail}`);
             }
+            if (modelCacheCleanup.action === "removed") {
+                this.log("- Codex model cache: removed the Claw Bay GPT-5.4 seed.");
+            }
+            else if (modelCacheCleanup.action === "preserved") {
+                this.log("- Codex model cache: preserved an existing GPT-5.4 entry.");
+            }
+            else if (modelCacheCleanup.warning) {
+                this.log(`- Codex model cache: ${modelCacheCleanup.warning}`);
+            }
+            else {
+                this.log("- Codex model cache: no cleanup needed.");
+            }
             this.log(`- OpenClaw config cleaned: ${updatedOpenClawConfig ? "yes" : "no"}`);
             this.log(`- OpenCode config cleaned: ${updatedOpenCodeConfig ? "yes" : "no"}`);
             this.log("Note: restart terminals/VS Code windows to clear already-loaded shell environment.");

package/dist/commands/setup.js

@@ -10,6 +10,7 @@ const node_child_process_1 = require("node:child_process");
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../lib/base-command");
 const codex_history_migration_1 = require("../lib/codex-history-migration");
+const codex_model_cache_migration_1 = require("../lib/codex-model-cache-migration");
 const paths_1 = require("../lib/config/paths");
 const api_key_1 = require("../lib/managed/api-key");
 const config_1 = require("../lib/managed/config");
@@ -460,6 +461,9 @@ class SetupCommand extends base_command_1.BaseCommand {
                 targetProvider: DEFAULT_PROVIDER_ID,
                 sourceProviders: HISTORY_PROVIDER_DB_MIGRATE_SOURCES,
             });
+            const modelCacheMigration = await (0, codex_model_cache_migration_1.ensureCodexModelCacheHasGpt54)({
+                codexHome: paths_1.codexDir,
+            });
             const hasOpenClaw = hasCommand("openclaw");
             const hasOpenCode = hasCommand("opencode");
             let openClawConfigPath = null;
@@ -509,6 +513,24 @@ class SetupCommand extends base_command_1.BaseCommand {
                 const detail = stateDbMigration.warning ? ` ${stateDbMigration.warning}` : "";
                 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.");
+            }
+            else if (modelCacheMigration.action === "created") {
+                this.log("- Codex model cache: created a local picker cache with GPT-5.4.");
+            }
+            else if (modelCacheMigration.action === "already_seeded") {
+                this.log("- Codex model cache: GPT-5.4 was already seeded locally.");
+            }
+            else if (modelCacheMigration.action === "already_present") {
+                this.log("- Codex model cache: GPT-5.4 already existed locally.");
+            }
+            else if (modelCacheMigration.warning) {
+                this.log(`- Codex model cache: ${modelCacheMigration.warning}`);
+            }
+            else {
+                this.log("- Codex model cache: no change.");
+            }
             this.log(`- API key env: ${ENV_FILE}`);
             this.log(`- Shell profiles updated: ${updatedShellFiles.join(", ")}`);
             this.log(`- VS Code env hooks updated: ${updatedVsCodeEnvFiles.join(", ")}`);

package/dist/lib/codex-model-cache-migration.d.ts

@@ -0,0 +1,14 @@
+export type EnsureCodexModelCacheResult = {
+    action: "seeded" | "created" | "already_present" | "already_seeded" | "skipped";
+    warning?: string;
+};
+export type CleanupCodexModelCacheResult = {
+    action: "removed" | "preserved" | "none";
+    warning?: string;
+};
+export declare function ensureCodexModelCacheHasGpt54(params: {
+    codexHome: string;
+}): Promise<EnsureCodexModelCacheResult>;
+export declare function cleanupSeededCodexModelCache(params: {
+    codexHome: string;
+}): Promise<CleanupCodexModelCacheResult>;

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

@@ -0,0 +1,340 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureCodexModelCacheHasGpt54 = ensureCodexModelCacheHasGpt54;
+exports.cleanupSeededCodexModelCache = cleanupSeededCodexModelCache;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const MODELS_CACHE_FILE = "models_cache.json";
+const MODELS_CACHE_STATE_FILE = "theclawbay.models-cache.json";
+const TARGET_MODEL_ID = "gpt-5.4";
+const SEED_MARKER_KEY = "_theclawbay_seeded";
+const SEED_MARKER_VALUE = "gpt-5.4";
+const TEMPLATE_MODEL_IDS = [
+    "gpt-5.3-codex",
+    "gpt-5.3-codex-spark",
+    "gpt-5.2-codex",
+    "gpt-5.1-codex-max",
+    "gpt-5.1-codex-mini",
+    "gpt-5.1-codex",
+];
+const DEFAULT_REASONING_LEVELS = [
+    { effort: "low", description: "Fast responses with lighter reasoning" },
+    { effort: "medium", description: "Balances speed and reasoning depth for everyday tasks" },
+    { effort: "high", description: "Greater reasoning depth for complex problems" },
+    { effort: "xhigh", description: "Extra high reasoning depth for complex problems" },
+];
+const FALLBACK_BASE_INSTRUCTIONS = `You are Codex, a coding agent based on GPT-5. You and the user share the same workspace and collaborate to achieve the user's goals.
+
+## General
+
+- Prefer rg or rg --files for search when available.
+- Make safe, minimal code changes that preserve user work.
+- Explain what changed and any remaining risk clearly.`;
+function objectRecordOr(value) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+function arrayOfObjects(value) {
+    if (!Array.isArray(value))
+        return null;
+    const output = [];
+    for (const entry of value) {
+        const obj = objectRecordOr(entry);
+        if (!obj)
+            return null;
+        output.push(obj);
+    }
+    return output;
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        const obj = value;
+        const keys = Object.keys(obj).sort();
+        return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function fingerprintModel(model) {
+    return (0, node_crypto_1.createHash)("sha256").update(stableStringify(model)).digest("hex");
+}
+async function readJsonIfExists(filePath) {
+    try {
+        const raw = await promises_1.default.readFile(filePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function removeFileIfExists(filePath) {
+    try {
+        await promises_1.default.unlink(filePath);
+    }
+    catch (error) {
+        const err = error;
+        if (err.code !== "ENOENT")
+            throw error;
+    }
+}
+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,
+    };
+}
+async function writePatchState(statePath, fingerprint) {
+    await promises_1.default.mkdir(node_path_1.default.dirname(statePath), { recursive: true });
+    const contents = JSON.stringify({
+        version: 1,
+        modelId: TARGET_MODEL_ID,
+        fingerprint,
+    }, null, 2);
+    await promises_1.default.writeFile(statePath, `${contents}\n`, "utf8");
+}
+function findModel(models, slug) {
+    return models.find((entry) => entry.slug === slug) ?? null;
+}
+function hasSeedMarker(model) {
+    return model[SEED_MARKER_KEY] === SEED_MARKER_VALUE;
+}
+function applySeedMarker(model) {
+    const next = cloneJson(model);
+    next[SEED_MARKER_KEY] = SEED_MARKER_VALUE;
+    return next;
+}
+function normalizeSeedModel(template) {
+    const seed = applySeedMarker(template ?? {});
+    seed.slug = TARGET_MODEL_ID;
+    seed.display_name = TARGET_MODEL_ID;
+    seed.description = "Latest frontier agentic coding model.";
+    if (typeof seed.default_reasoning_level !== "string") {
+        seed.default_reasoning_level = "medium";
+    }
+    if (!Array.isArray(seed.supported_reasoning_levels) || seed.supported_reasoning_levels.length === 0) {
+        seed.supported_reasoning_levels = cloneJson(DEFAULT_REASONING_LEVELS);
+    }
+    if (typeof seed.shell_type !== "string") {
+        seed.shell_type = "shell_command";
+    }
+    seed.visibility = "list";
+    seed.supported_in_api = true;
+    seed.priority = 0;
+    seed.upgrade = null;
+    if (typeof seed.base_instructions !== "string" || !seed.base_instructions.trim()) {
+        seed.base_instructions = FALLBACK_BASE_INSTRUCTIONS;
+    }
+    if (typeof seed.supports_reasoning_summaries !== "boolean") {
+        seed.supports_reasoning_summaries = true;
+    }
+    if (typeof seed.support_verbosity !== "boolean") {
+        seed.support_verbosity = true;
+    }
+    if (seed.default_verbosity === undefined) {
+        seed.default_verbosity = "low";
+    }
+    if (seed.apply_patch_tool_type === undefined) {
+        seed.apply_patch_tool_type = "freeform";
+    }
+    const truncationPolicy = objectRecordOr(seed.truncation_policy);
+    if (!truncationPolicy || typeof truncationPolicy.mode !== "string" || typeof truncationPolicy.limit !== "number") {
+        seed.truncation_policy = { mode: "tokens", limit: 10000 };
+    }
+    if (typeof seed.supports_parallel_tool_calls !== "boolean") {
+        seed.supports_parallel_tool_calls = true;
+    }
+    if (typeof seed.context_window !== "number") {
+        seed.context_window = 272000;
+    }
+    if (typeof seed.effective_context_window_percent !== "number") {
+        seed.effective_context_window_percent = 95;
+    }
+    if (!Array.isArray(seed.experimental_supported_tools)) {
+        seed.experimental_supported_tools = [];
+    }
+    if (!Array.isArray(seed.input_modalities) || seed.input_modalities.length === 0) {
+        seed.input_modalities = ["text", "image"];
+    }
+    if (typeof seed.prefer_websockets !== "boolean") {
+        seed.prefer_websockets = true;
+    }
+    return seed;
+}
+function buildSeedModel(models) {
+    for (const candidate of TEMPLATE_MODEL_IDS) {
+        const template = findModel(models, candidate);
+        if (template)
+            return normalizeSeedModel(template);
+    }
+    return normalizeSeedModel(null);
+}
+function parseCodexVersion(stdout) {
+    const match = stdout.match(/\b(\d+\.\d+\.\d+)\b/);
+    return match ? match[1] : null;
+}
+function inferCodexClientVersion() {
+    for (const command of ["codex", "codex-cli"]) {
+        const run = (0, node_child_process_1.spawnSync)(command, ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        if (run.status !== 0)
+            continue;
+        const parsed = parseCodexVersion(run.stdout ?? "");
+        if (parsed)
+            return parsed;
+    }
+    return null;
+}
+function normalizeCacheDocument(value) {
+    const doc = objectRecordOr(value);
+    if (!doc)
+        return null;
+    const models = arrayOfObjects(doc.models);
+    if (!models)
+        return null;
+    return { ...doc, models };
+}
+async function ensureCodexModelCacheHasGpt54(params) {
+    const cachePath = node_path_1.default.join(params.codexHome, MODELS_CACHE_FILE);
+    const statePath = node_path_1.default.join(params.codexHome, MODELS_CACHE_STATE_FILE);
+    try {
+        const existingState = await readPatchState(statePath);
+        const parsed = await readJsonIfExists(cachePath);
+        if (parsed === null) {
+            const clientVersion = inferCodexClientVersion();
+            if (!clientVersion) {
+                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.",
+                };
+            }
+            const seed = buildSeedModel([]);
+            const doc = {
+                fetched_at: new Date().toISOString(),
+                client_version: clientVersion,
+                models: [seed],
+            };
+            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));
+            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.",
+            };
+        }
+        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));
+                await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+                await writePatchState(statePath, fingerprintModel(seededModel));
+                return { action: "seeded" };
+            }
+            if (hasSeedMarker(existingModel)) {
+                if (!existingState || existingState.fingerprint !== currentFingerprint) {
+                    await writePatchState(statePath, currentFingerprint);
+                }
+                return { action: "already_seeded" };
+            }
+            if (existingState && existingState.fingerprint !== currentFingerprint) {
+                await removeFileIfExists(statePath);
+            }
+            return {
+                action: existingState && existingState.fingerprint === currentFingerprint ? "already_seeded" : "already_present",
+            };
+        }
+        const seed = buildSeedModel(doc.models);
+        doc.models = [seed, ...doc.models];
+        await promises_1.default.writeFile(cachePath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+        await writePatchState(statePath, fingerprintModel(seed));
+        return { action: "seeded" };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            action: "skipped",
+            warning: `Could not update Codex models cache: ${message}`,
+        };
+    }
+}
+async function cleanupSeededCodexModelCache(params) {
+    const cachePath = node_path_1.default.join(params.codexHome, MODELS_CACHE_FILE);
+    const statePath = node_path_1.default.join(params.codexHome, MODELS_CACHE_STATE_FILE);
+    try {
+        const state = await readPatchState(statePath);
+        if (!state) {
+            return { action: "none" };
+        }
+        const parsed = await readJsonIfExists(cachePath);
+        if (parsed === null) {
+            await removeFileIfExists(statePath);
+            return { action: "none" };
+        }
+        const doc = normalizeCacheDocument(parsed);
+        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.",
+            };
+        }
+        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");
+            await removeFileIfExists(statePath);
+            return { action: "removed" };
+        }
+        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" };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            action: "none",
+            warning: `Could not clean up Codex models cache patch: ${message}`,
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theclawbay",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "The Claw Bay CLI: one-time API-key setup for direct Codex access.",
   "license": "MIT",
   "bin": {