theclawbay 0.3.87 → 0.4.0

package/dist/lib/clients/gsd.d.ts

@@ -0,0 +1,30 @@
+export declare const GSD_AGENT_DIR: string;
+export declare const GSD_MODELS_PATH: string;
+export declare const GSD_AUTH_PATH: string;
+export declare const GSD_SETTINGS_PATH: string;
+export declare const GSD_RESTORE_STATE_PATH: string;
+export type GsdRestoreSnapshot = {
+    version: 1;
+    modelsExisted: boolean;
+    providerConfig: Record<string, unknown> | null;
+    authExisted: boolean;
+    authEntry: Record<string, unknown> | null;
+    settingsExisted: boolean;
+    defaultProvider: string | null;
+    defaultModel: string | null;
+};
+export declare function detectGsdClient(): Promise<boolean>;
+export declare function buildGsdModels(models: Array<{
+    id: string;
+    name: string;
+}>): Array<Record<string, unknown>>;
+export declare function normalizeGsdCredential(value: unknown): Record<string, unknown> | null;
+export declare function writeGsdConfig(params: {
+    backendUrl: string;
+    model: string;
+    models: Array<{
+        id: string;
+        name: string;
+    }>;
+    apiKey: string;
+}): Promise<string[]>;

package/dist/lib/clients/gsd.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GSD_RESTORE_STATE_PATH = exports.GSD_SETTINGS_PATH = exports.GSD_AUTH_PATH = exports.GSD_MODELS_PATH = exports.GSD_AGENT_DIR = void 0;
+exports.detectGsdClient = detectGsdClient;
+exports.buildGsdModels = buildGsdModels;
+exports.normalizeGsdCredential = normalizeGsdCredential;
+exports.writeGsdConfig = writeGsdConfig;
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const paths_1 = require("../config/paths");
+const platform_1 = require("../shared/platform");
+const fsx_1 = require("../shared/fsx");
+const supported_models_1 = require("../supported-models");
+const models_1 = require("../shared/models");
+const providers_1 = require("../shared/providers");
+const urls_1 = require("../shared/urls");
+const env_persist_1 = require("../shared/env-persist");
+// Extracted from src/commands/setup.ts (theclawbay CLI restructure).
+// Code motion only: bodies are verbatim from the original file.
+exports.GSD_AGENT_DIR = node_path_1.default.join(node_os_1.default.homedir(), ".gsd", "agent");
+exports.GSD_MODELS_PATH = node_path_1.default.join(exports.GSD_AGENT_DIR, "models.json");
+exports.GSD_AUTH_PATH = node_path_1.default.join(exports.GSD_AGENT_DIR, "auth.json");
+exports.GSD_SETTINGS_PATH = node_path_1.default.join(exports.GSD_AGENT_DIR, "settings.json");
+exports.GSD_RESTORE_STATE_PATH = node_path_1.default.join(paths_1.theclawbayStateDir, "gsd.restore.json");
+async function detectGsdClient() {
+    if ((0, platform_1.hasCommand)("gsd"))
+        return true;
+    const candidates = [
+        exports.GSD_AGENT_DIR,
+        exports.GSD_MODELS_PATH,
+        exports.GSD_AUTH_PATH,
+        exports.GSD_SETTINGS_PATH,
+    ];
+    for (const candidate of candidates) {
+        if (await (0, fsx_1.pathExists)(candidate))
+            return true;
+    }
+    return false;
+}
+function buildGsdModels(models) {
+    const supportedModelMap = new Map((0, supported_models_1.getSupportedModels)().map((model) => [model.id, model]));
+    return models
+        .filter((model) => Boolean(model.id))
+        .map((model) => {
+        const pricing = supportedModelMap.get(model.id);
+        return {
+            id: model.id,
+            name: model.name || model.id,
+            reasoning: true,
+            input: ["text", "image"],
+            cost: {
+                input: pricing?.inputPer1M ?? 0,
+                output: pricing?.outputPer1M ?? 0,
+                cacheRead: pricing?.cachedInputPer1M ?? 0,
+                cacheWrite: pricing?.inputPer1M ?? 0,
+            },
+            contextWindow: (0, models_1.modelContextLimit)(model.id),
+            maxTokens: (0, models_1.modelOutputLimit)(model.id),
+        };
+    });
+}
+function normalizeGsdCredential(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    return { ...value };
+}
+async function writeGsdConfig(params) {
+    const existingModelsRaw = await (0, fsx_1.readFileIfExists)(exports.GSD_MODELS_PATH);
+    const existingAuthRaw = await (0, fsx_1.readFileIfExists)(exports.GSD_AUTH_PATH);
+    const existingSettingsRaw = await (0, fsx_1.readFileIfExists)(exports.GSD_SETTINGS_PATH);
+    const existingSnapshotRaw = await (0, fsx_1.readFileIfExists)(exports.GSD_RESTORE_STATE_PATH);
+    let modelsDoc = {};
+    if (existingModelsRaw?.trim()) {
+        try {
+            modelsDoc = (0, fsx_1.objectRecordOr)(JSON.parse(existingModelsRaw), {});
+        }
+        catch {
+            throw new Error(`invalid JSON in GSD config: ${exports.GSD_MODELS_PATH}`);
+        }
+    }
+    let authDoc = {};
+    if (existingAuthRaw?.trim()) {
+        try {
+            authDoc = (0, fsx_1.objectRecordOr)(JSON.parse(existingAuthRaw), {});
+        }
+        catch {
+            throw new Error(`invalid JSON in GSD auth: ${exports.GSD_AUTH_PATH}`);
+        }
+    }
+    let settingsDoc = {};
+    if (existingSettingsRaw?.trim()) {
+        try {
+            settingsDoc = (0, fsx_1.objectRecordOr)(JSON.parse(existingSettingsRaw), {});
+        }
+        catch {
+            throw new Error(`invalid JSON in GSD settings: ${exports.GSD_SETTINGS_PATH}`);
+        }
+    }
+    if (!existingSnapshotRaw?.trim()) {
+        const providersRoot = (0, fsx_1.objectRecordOr)(modelsDoc.providers, {});
+        const snapshot = {
+            version: 1,
+            modelsExisted: existingModelsRaw !== null,
+            providerConfig: (0, fsx_1.objectRecordOr)(providersRoot[providers_1.DEFAULT_PROVIDER_ID], {}),
+            authExisted: existingAuthRaw !== null,
+            authEntry: normalizeGsdCredential(authDoc[providers_1.DEFAULT_PROVIDER_ID]),
+            settingsExisted: existingSettingsRaw !== null,
+            defaultProvider: typeof settingsDoc.defaultProvider === "string" ? settingsDoc.defaultProvider : null,
+            defaultModel: typeof settingsDoc.defaultModel === "string" ? settingsDoc.defaultModel : null,
+        };
+        if (Object.keys(snapshot.providerConfig ?? {}).length === 0)
+            snapshot.providerConfig = null;
+        await (0, fsx_1.writeJsonObjectFile)(exports.GSD_RESTORE_STATE_PATH, snapshot, 0o600);
+    }
+    const providersRoot = (0, fsx_1.objectRecordOr)(modelsDoc.providers, {});
+    providersRoot[providers_1.DEFAULT_PROVIDER_ID] = {
+        baseUrl: (0, urls_1.openAiCompatibleProxyUrl)(params.backendUrl),
+        apiKey: env_persist_1.ENV_KEY_NAME,
+        api: "openai-responses",
+        models: buildGsdModels(params.models),
+    };
+    modelsDoc.providers = providersRoot;
+    authDoc[providers_1.DEFAULT_PROVIDER_ID] = {
+        type: "api_key",
+        key: params.apiKey,
+    };
+    settingsDoc.defaultProvider = providers_1.DEFAULT_PROVIDER_ID;
+    settingsDoc.defaultModel = params.model.trim() || models_1.DEFAULT_CODEX_MODEL;
+    await (0, fsx_1.writeJsonObjectFile)(exports.GSD_MODELS_PATH, modelsDoc);
+    await (0, fsx_1.writeJsonObjectFile)(exports.GSD_AUTH_PATH, authDoc, 0o600);
+    await (0, fsx_1.writeJsonObjectFile)(exports.GSD_SETTINGS_PATH, settingsDoc);
+    return [exports.GSD_MODELS_PATH, exports.GSD_AUTH_PATH, exports.GSD_SETTINGS_PATH];
+}

package/dist/lib/clients/hermes-cleanup.d.ts

@@ -0,0 +1,2 @@
+export declare function removeDotEnvValue(filePath: string, key: string): Promise<boolean>;
+export declare function cleanupHermesConfig(): Promise<boolean>;

package/dist/lib/clients/hermes-cleanup.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeDotEnvValue = removeDotEnvValue;
+exports.cleanupHermesConfig = cleanupHermesConfig;
+const fsx_1 = require("../shared/fsx");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const hermes_1 = require("./hermes");
+const yaml_1 = require("yaml");
+const urls_1 = require("../shared/urls");
+// Extracted from src/commands/logout.ts (theclawbay CLI restructure).
+// Code motion only: bodies are verbatim from the original file.
+async function removeDotEnvValue(filePath, key) {
+    const existing = await (0, fsx_1.readFileIfExists)(filePath);
+    if (existing === null)
+        return false;
+    const nextLines = existing
+        .split(/\r?\n/)
+        .filter((line) => !new RegExp(`^\\s*${key}\\s*=`).test(line));
+    const next = `${nextLines.join("\n").trimEnd()}\n`;
+    const normalizedExisting = `${existing.trimEnd()}\n`;
+    if (next === normalizedExisting)
+        return false;
+    if (!next.trim()) {
+        return (0, fsx_1.removeFileIfExists)(filePath);
+    }
+    await promises_1.default.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
+    await promises_1.default.writeFile(filePath, next, "utf8");
+    return true;
+}
+async function cleanupHermesConfig() {
+    const configPath = (0, hermes_1.hermesConfigPath)();
+    const envPath = (0, hermes_1.hermesEnvPath)();
+    const existingRaw = await (0, fsx_1.readFileIfExists)(configPath);
+    let configChanged = false;
+    let removedManagedProvider = false;
+    const removedProviderBaseUrls = new Set();
+    if (existingRaw !== null && existingRaw.trim()) {
+        try {
+            const existingConfig = (0, fsx_1.objectRecordOr)((0, yaml_1.parseDocument)(existingRaw).toJS(), {});
+            const nextConfig = { ...existingConfig };
+            const rawCustomProviders = Array.isArray(existingConfig.custom_providers)
+                ? existingConfig.custom_providers
+                : [];
+            const nextCustomProviders = rawCustomProviders.filter((entry) => {
+                if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+                    return true;
+                const record = entry;
+                const name = typeof record.name === "string" ? record.name.trim() : "";
+                const providerBaseUrl = typeof record.base_url === "string" ? record.base_url.trim().replace(/\/+$/g, "") : "";
+                const keyEnv = typeof record.key_env === "string" ? record.key_env.trim() : "";
+                if (keyEnv === hermes_1.HERMES_KEY_ENV_NAME) {
+                    removedManagedProvider = true;
+                    if (providerBaseUrl)
+                        removedProviderBaseUrls.add(providerBaseUrl);
+                    return false;
+                }
+                if (name === hermes_1.HERMES_PROVIDER_NAME && (0, urls_1.isTheClawBayOpenAiCompatibleBaseUrl)(providerBaseUrl)) {
+                    removedManagedProvider = true;
+                    if (providerBaseUrl)
+                        removedProviderBaseUrls.add(providerBaseUrl);
+                    return false;
+                }
+                return true;
+            });
+            if (nextCustomProviders.length !== rawCustomProviders.length) {
+                configChanged = true;
+            }
+            if (nextCustomProviders.length > 0) {
+                nextConfig.custom_providers = nextCustomProviders;
+            }
+            else if ("custom_providers" in nextConfig) {
+                delete nextConfig.custom_providers;
+                configChanged = true;
+            }
+            const modelConfig = (0, fsx_1.objectRecordOr)(existingConfig.model, {});
+            const provider = typeof modelConfig.provider === "string" ? modelConfig.provider.trim() : "";
+            const baseUrl = typeof modelConfig.base_url === "string" ? modelConfig.base_url.trim().replace(/\/+$/g, "") : "";
+            const apiMode = typeof modelConfig.api_mode === "string" ? modelConfig.api_mode.trim() : "";
+            const shouldRemoveManagedModel = provider === "custom" &&
+                ((0, urls_1.isTheClawBayOpenAiCompatibleBaseUrl)(baseUrl) ||
+                    (removedManagedProvider && apiMode === "codex_responses" && removedProviderBaseUrls.has(baseUrl)));
+            if (shouldRemoveManagedModel) {
+                for (const key of ["provider", "default", "base_url", "api_mode", "api_key", "context_length"]) {
+                    if (key in modelConfig) {
+                        delete modelConfig[key];
+                        configChanged = true;
+                    }
+                }
+                if (Object.keys(modelConfig).length > 0) {
+                    nextConfig.model = modelConfig;
+                }
+                else if ("model" in nextConfig) {
+                    delete nextConfig.model;
+                    configChanged = true;
+                }
+            }
+            if (configChanged) {
+                await promises_1.default.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
+                await promises_1.default.writeFile(configPath, (0, yaml_1.stringify)(nextConfig), "utf8");
+            }
+        }
+        catch {
+            // Leave invalid user config untouched; still remove our dedicated env key below.
+        }
+    }
+    const envChanged = await removeDotEnvValue(envPath, hermes_1.HERMES_KEY_ENV_NAME);
+    return configChanged || envChanged;
+}

package/dist/lib/clients/hermes.d.ts

@@ -0,0 +1,18 @@
+export declare const DEFAULT_HERMES_MODEL: string;
+export declare const HERMES_PROVIDER_NAME = "The Claw Bay";
+export declare const HERMES_KEY_ENV_NAME = "HERMES_THECLAWBAY_API_KEY";
+export declare function hermesHomeDir(): string;
+export declare function hermesConfigPath(): string;
+export declare function hermesEnvPath(): string;
+export declare function detectHermesClient(): Promise<boolean>;
+export declare function formatDotEnvValue(value: string): string;
+export declare function upsertDotEnvValue(filePath: string, key: string, value: string): Promise<boolean>;
+export declare function writeHermesConfig(params: {
+    backendUrl: string;
+    model: string;
+    models?: Array<{
+        id: string;
+        name: string;
+    }>;
+    apiKey: string;
+}): Promise<string[]>;

package/dist/lib/clients/hermes.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HERMES_KEY_ENV_NAME = exports.HERMES_PROVIDER_NAME = exports.DEFAULT_HERMES_MODEL = void 0;
+exports.hermesHomeDir = hermesHomeDir;
+exports.hermesConfigPath = hermesConfigPath;
+exports.hermesEnvPath = hermesEnvPath;
+exports.detectHermesClient = detectHermesClient;
+exports.formatDotEnvValue = formatDotEnvValue;
+exports.upsertDotEnvValue = upsertDotEnvValue;
+exports.writeHermesConfig = writeHermesConfig;
+const models_1 = require("../shared/models");
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const platform_1 = require("../shared/platform");
+const fsx_1 = require("../shared/fsx");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const urls_1 = require("../shared/urls");
+const yaml_1 = require("yaml");
+// Extracted from src/commands/setup.ts (theclawbay CLI restructure).
+// Code motion only: bodies are verbatim from the original file.
+exports.DEFAULT_HERMES_MODEL = models_1.DEFAULT_CODEX_MODEL;
+exports.HERMES_PROVIDER_NAME = "The Claw Bay";
+exports.HERMES_KEY_ENV_NAME = "HERMES_THECLAWBAY_API_KEY";
+function hermesHomeDir() {
+    const raw = process.env.HERMES_HOME?.trim();
+    if (raw)
+        return raw;
+    return node_path_1.default.join(node_os_1.default.homedir(), ".hermes");
+}
+function hermesConfigPath() {
+    return node_path_1.default.join(hermesHomeDir(), "config.yaml");
+}
+function hermesEnvPath() {
+    return node_path_1.default.join(hermesHomeDir(), ".env");
+}
+async function detectHermesClient() {
+    if ((0, platform_1.hasCommand)("hermes"))
+        return true;
+    const candidates = [
+        hermesHomeDir(),
+        hermesConfigPath(),
+        hermesEnvPath(),
+    ];
+    for (const candidate of candidates) {
+        if (await (0, fsx_1.pathExists)(candidate))
+            return true;
+    }
+    return false;
+}
+function formatDotEnvValue(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+async function upsertDotEnvValue(filePath, key, value) {
+    const existing = (await (0, fsx_1.readFileIfExists)(filePath)) ?? "";
+    const lines = existing ? existing.split(/\r?\n/) : [];
+    const assignment = `${key}=${formatDotEnvValue(value)}`;
+    let changed = false;
+    let replaced = false;
+    const nextLines = lines.map((line) => {
+        if (new RegExp(`^\\s*${key}\\s*=`).test(line)) {
+            replaced = true;
+            if (line === assignment)
+                return line;
+            changed = true;
+            return assignment;
+        }
+        return line;
+    });
+    if (!replaced) {
+        if (nextLines.length > 0 && nextLines[nextLines.length - 1]?.trim()) {
+            nextLines.push("");
+        }
+        nextLines.push(assignment);
+        changed = true;
+    }
+    if (!changed)
+        return false;
+    await promises_1.default.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
+    await promises_1.default.writeFile(filePath, `${nextLines.join("\n").trimEnd()}\n`, "utf8");
+    return true;
+}
+async function writeHermesConfig(params) {
+    const configPath = hermesConfigPath();
+    const envPath = hermesEnvPath();
+    const baseUrl = (0, urls_1.openAiCompatibleProxyUrl)(params.backendUrl);
+    const selectedModel = params.model.trim() || exports.DEFAULT_HERMES_MODEL;
+    const existingRaw = await (0, fsx_1.readFileIfExists)(configPath);
+    const existingConfig = existingRaw?.trim()
+        ? (0, fsx_1.objectRecordOr)((0, yaml_1.parseDocument)(existingRaw).toJS(), {})
+        : {};
+    const nextConfig = { ...existingConfig };
+    const modelConfig = (0, fsx_1.objectRecordOr)(existingConfig.model, {});
+    modelConfig.provider = "custom";
+    modelConfig.default = selectedModel;
+    modelConfig.base_url = baseUrl;
+    modelConfig.api_mode = "codex_responses";
+    delete modelConfig.api_key;
+    delete modelConfig.context_length;
+    nextConfig.model = modelConfig;
+    const rawCustomProviders = Array.isArray(existingConfig.custom_providers)
+        ? existingConfig.custom_providers
+        : [];
+    const nextCustomProviders = rawCustomProviders.filter((entry) => {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+            return true;
+        const record = entry;
+        const name = typeof record.name === "string" ? record.name.trim() : "";
+        const providerBaseUrl = typeof record.base_url === "string" ? record.base_url.trim() : "";
+        const keyEnv = typeof record.key_env === "string" ? record.key_env.trim() : "";
+        if (keyEnv === exports.HERMES_KEY_ENV_NAME)
+            return false;
+        if (name === exports.HERMES_PROVIDER_NAME && providerBaseUrl === baseUrl)
+            return false;
+        return true;
+    });
+    nextCustomProviders.push({
+        name: exports.HERMES_PROVIDER_NAME,
+        base_url: baseUrl,
+        key_env: exports.HERMES_KEY_ENV_NAME,
+        model: selectedModel,
+        api_mode: "codex_responses",
+    });
+    // One named provider per additional selected model so Hermes can switch
+    // models without editing config. All share the same key env, so re-runs
+    // and logout (which filter on key_env) clean every managed entry.
+    for (const model of params.models ?? []) {
+        if (!model.id || model.id === selectedModel)
+            continue;
+        nextCustomProviders.push({
+            name: `${exports.HERMES_PROVIDER_NAME} · ${model.name || model.id}`,
+            base_url: baseUrl,
+            key_env: exports.HERMES_KEY_ENV_NAME,
+            model: model.id,
+            api_mode: "codex_responses",
+        });
+    }
+    nextConfig.custom_providers = nextCustomProviders;
+    await promises_1.default.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
+    await promises_1.default.writeFile(configPath, (0, yaml_1.stringify)(nextConfig), "utf8");
+    await upsertDotEnvValue(envPath, exports.HERMES_KEY_ENV_NAME, params.apiKey);
+    return [configPath, envPath];
+}

package/dist/lib/clients/openclaw-cleanup.d.ts

@@ -0,0 +1 @@
+export declare function cleanupOpenClawConfig(): Promise<boolean>;

package/dist/lib/clients/openclaw-cleanup.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupOpenClawConfig = cleanupOpenClawConfig;
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const fsx_1 = require("../shared/fsx");
+const providers_1 = require("../shared/providers");
+const promises_1 = __importDefault(require("node:fs/promises"));
+// Extracted from src/commands/logout.ts (theclawbay CLI restructure).
+// Code motion only: bodies are verbatim from the original file.
+async function cleanupOpenClawConfig() {
+    const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".openclaw", "openclaw.json");
+    const existingRaw = await (0, fsx_1.readFileIfExists)(configPath);
+    if (existingRaw === null || !existingRaw.trim())
+        return false;
+    let doc;
+    try {
+        doc = (0, fsx_1.objectRecordOr)(JSON.parse(existingRaw), {});
+    }
+    catch {
+        return false;
+    }
+    let changed = false;
+    const modelsRoot = (0, fsx_1.objectRecordOr)(doc.models, {});
+    const providersRoot = (0, fsx_1.objectRecordOr)(modelsRoot.providers, {});
+    for (const id of [providers_1.DEFAULT_PROVIDER_ID]) {
+        if (id in providersRoot) {
+            delete providersRoot[id];
+            changed = true;
+        }
+    }
+    modelsRoot.providers = providersRoot;
+    doc.models = modelsRoot;
+    const agentsRoot = (0, fsx_1.objectRecordOr)(doc.agents, {});
+    const defaultsRoot = (0, fsx_1.objectRecordOr)(agentsRoot.defaults, {});
+    const modelRoot = (0, fsx_1.objectRecordOr)(defaultsRoot.model, {});
+    const primary = modelRoot.primary;
+    if (typeof primary === "string" && primary.startsWith(`${providers_1.DEFAULT_PROVIDER_ID}/`)) {
+        delete modelRoot.primary;
+        changed = true;
+    }
+    defaultsRoot.model = modelRoot;
+    agentsRoot.defaults = defaultsRoot;
+    doc.agents = agentsRoot;
+    if (!changed)
+        return false;
+    await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    return true;
+}

package/dist/lib/clients/openclaw.d.ts

@@ -0,0 +1,34 @@
+export declare const DEFAULT_OPENCLAW_MODEL: string;
+export declare const OPENCLAW_PROVIDER_ID: string;
+export declare function resolveOpenClawPrimaryModel(params: {
+    model: string;
+    models: Array<{
+        id: string;
+        name: string;
+    }>;
+}): string;
+export declare function patchOpenClawConfigFile(params: {
+    backendUrl: string;
+    model: string;
+    models: Array<{
+        id: string;
+        name: string;
+    }>;
+    apiKey: string;
+}): Promise<string>;
+export declare function setupOpenClaw(params: {
+    backendUrl: string;
+    model: string;
+    models: Array<{
+        id: string;
+        name: string;
+    }>;
+    apiKey: string;
+}): Promise<{
+    configPath: string;
+    cliWarning?: string;
+}>;
+export declare function buildOpenClawModels(models: Array<{
+    id: string;
+    name: string;
+}>): Array<Record<string, unknown>>;

package/dist/lib/clients/openclaw.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPENCLAW_PROVIDER_ID = exports.DEFAULT_OPENCLAW_MODEL = void 0;
+exports.resolveOpenClawPrimaryModel = resolveOpenClawPrimaryModel;
+exports.patchOpenClawConfigFile = patchOpenClawConfigFile;
+exports.setupOpenClaw = setupOpenClaw;
+exports.buildOpenClawModels = buildOpenClawModels;
+const models_1 = require("../shared/models");
+const providers_1 = require("../shared/providers");
+const urls_1 = require("../shared/urls");
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const fsx_1 = require("../shared/fsx");
+const supported_models_1 = require("../supported-models");
+// Extracted from src/commands/setup.ts (theclawbay CLI restructure).
+// Code motion only: bodies are verbatim from the original file.
+exports.DEFAULT_OPENCLAW_MODEL = models_1.DEFAULT_CODEX_MODEL;
+exports.OPENCLAW_PROVIDER_ID = providers_1.DEFAULT_PROVIDER_ID;
+function resolveOpenClawPrimaryModel(params) {
+    const hasStableDefault = params.models.some((entry) => entry.id === exports.DEFAULT_OPENCLAW_MODEL);
+    const modelId = hasStableDefault ? exports.DEFAULT_OPENCLAW_MODEL : params.model.trim() || models_1.DEFAULT_CODEX_MODEL;
+    return `${exports.OPENCLAW_PROVIDER_ID}/${modelId}`;
+}
+async function patchOpenClawConfigFile(params) {
+    const provider = {
+        baseUrl: (0, urls_1.openAiCompatibleProxyUrl)(params.backendUrl),
+        apiKey: params.apiKey,
+        api: "openai-responses",
+        models: buildOpenClawModels(params.models),
+    };
+    const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".openclaw", "openclaw.json");
+    await promises_1.default.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
+    let existingRaw = "";
+    try {
+        existingRaw = await promises_1.default.readFile(configPath, "utf8");
+    }
+    catch (error) {
+        const err = error;
+        if (err.code !== "ENOENT")
+            throw error;
+    }
+    let doc = {};
+    if (existingRaw.trim()) {
+        try {
+            doc = (0, fsx_1.objectRecordOr)(JSON.parse(existingRaw), {});
+        }
+        catch {
+            throw new Error(`invalid JSON in OpenClaw config: ${configPath}`);
+        }
+    }
+    const modelsRoot = (0, fsx_1.objectRecordOr)(doc.models, {});
+    modelsRoot.mode = "merge";
+    const providersRoot = (0, fsx_1.objectRecordOr)(modelsRoot.providers, {});
+    providersRoot[exports.OPENCLAW_PROVIDER_ID] = provider;
+    modelsRoot.providers = providersRoot;
+    doc.models = modelsRoot;
+    const agentsRoot = (0, fsx_1.objectRecordOr)(doc.agents, {});
+    const defaultsRoot = (0, fsx_1.objectRecordOr)(agentsRoot.defaults, {});
+    const modelRoot = (0, fsx_1.objectRecordOr)(defaultsRoot.model, {});
+    modelRoot.primary = resolveOpenClawPrimaryModel(params);
+    if (typeof defaultsRoot.thinkingDefault !== "string") {
+        defaultsRoot.thinkingDefault = "medium";
+    }
+    defaultsRoot.model = modelRoot;
+    agentsRoot.defaults = defaultsRoot;
+    doc.agents = agentsRoot;
+    await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    return configPath;
+}
+async function setupOpenClaw(params) {
+    const configPath = await patchOpenClawConfigFile(params);
+    return { configPath };
+}
+function buildOpenClawModels(models) {
+    const supportedModelMap = new Map((0, supported_models_1.getSupportedModels)().map((model) => [model.id, model]));
+    return models
+        .filter((model) => Boolean(model.id))
+        .map((model) => {
+        const pricing = supportedModelMap.get(model.id);
+        return {
+            id: model.id,
+            name: model.name || model.id,
+            api: "openai-responses",
+            reasoning: true,
+            input: ["text", "image"],
+            cost: {
+                input: pricing?.inputPer1M ?? 0,
+                output: pricing?.outputPer1M ?? 0,
+                cacheRead: pricing?.cachedInputPer1M ?? 0,
+                cacheWrite: pricing?.inputPer1M ?? 0,
+            },
+            contextWindow: (0, models_1.modelContextLimit)(model.id),
+            maxTokens: (0, models_1.modelOutputLimit)(model.id),
+        };
+    });
+}

package/dist/lib/clients/opencode-family-cleanup.d.ts

@@ -0,0 +1,12 @@
+export declare const SUPPORTED_MODEL_IDS: Set<string>;
+export declare function openCodeConfigCleanupTargets(): string[];
+export declare function kiloConfigCleanupTargets(): string[];
+export declare function isManagedOpenCodeModel(value: unknown): boolean;
+export declare function isManagedOpenCodeProvider(value: unknown): boolean;
+export declare function isManagedOpenCodeAnthropicProvider(value: unknown): boolean;
+export declare function cleanupOpenCodeFamilyConfigs(params: {
+    configPaths: string[];
+    restoreStatePath: string;
+}): Promise<boolean>;
+export declare function cleanupOpenCodeConfig(): Promise<boolean>;
+export declare function cleanupKiloConfig(): Promise<boolean>;