theclawbay 0.3.87 → 0.4.0

package/dist/lib/clients/opencode-family-cleanup.js

@@ -0,0 +1,201 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_MODEL_IDS = void 0;
+exports.openCodeConfigCleanupTargets = openCodeConfigCleanupTargets;
+exports.kiloConfigCleanupTargets = kiloConfigCleanupTargets;
+exports.isManagedOpenCodeModel = isManagedOpenCodeModel;
+exports.isManagedOpenCodeProvider = isManagedOpenCodeProvider;
+exports.isManagedOpenCodeAnthropicProvider = isManagedOpenCodeAnthropicProvider;
+exports.cleanupOpenCodeFamilyConfigs = cleanupOpenCodeFamilyConfigs;
+exports.cleanupOpenCodeConfig = cleanupOpenCodeConfig;
+exports.cleanupKiloConfig = cleanupKiloConfig;
+const supported_models_1 = require("../supported-models");
+const node_os_1 = __importDefault(require("node:os"));
+const opencode_family_1 = require("./opencode-family");
+const node_path_1 = __importDefault(require("node:path"));
+const fsx_1 = require("../shared/fsx");
+const providers_1 = require("../shared/providers");
+const urls_1 = require("../shared/urls");
+const platform_1 = require("../shared/platform");
+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.
+exports.SUPPORTED_MODEL_IDS = new Set((0, supported_models_1.getSupportedModelIds)());
+function openCodeConfigCleanupTargets() {
+    const home = node_os_1.default.homedir();
+    const dirs = (0, opencode_family_1.configDirCandidates)("opencode");
+    const candidates = [];
+    for (const dir of dirs) {
+        candidates.push(node_path_1.default.join(dir, "opencode.json"));
+        candidates.push(node_path_1.default.join(dir, ".opencode.json"));
+        candidates.push(node_path_1.default.join(dir, "config.json"));
+    }
+    candidates.push(node_path_1.default.join(home, ".opencode.json"));
+    return (0, fsx_1.uniqueStrings)(candidates);
+}
+function kiloConfigCleanupTargets() {
+    const home = node_os_1.default.homedir();
+    const dirs = (0, fsx_1.uniqueStrings)([...(0, opencode_family_1.configDirCandidates)("kilo"), node_path_1.default.join(home, ".kilo")]);
+    const candidates = [];
+    for (const dir of dirs) {
+        candidates.push(node_path_1.default.join(dir, "opencode.json"));
+        candidates.push(node_path_1.default.join(dir, "config.json"));
+    }
+    return (0, fsx_1.uniqueStrings)(candidates);
+}
+function isManagedOpenCodeModel(value) {
+    if (typeof value !== "string")
+        return false;
+    if (!value.startsWith(`${providers_1.OPENAI_PROVIDER_ID}/`))
+        return false;
+    return exports.SUPPORTED_MODEL_IDS.has(value.slice(`${providers_1.OPENAI_PROVIDER_ID}/`.length));
+}
+function isManagedOpenCodeProvider(value) {
+    const provider = (0, fsx_1.objectRecordOr)(value, {});
+    const options = (0, fsx_1.objectRecordOr)(provider.options, {});
+    return (0, urls_1.isTheClawBayOpenAiCompatibleBaseUrl)(options.baseURL);
+}
+function isManagedOpenCodeAnthropicProvider(value) {
+    const provider = (0, fsx_1.objectRecordOr)(value, {});
+    const options = (0, fsx_1.objectRecordOr)(provider.options, {});
+    return (0, urls_1.isTheClawBayAnthropicCompatibleBaseUrl)(options.baseURL);
+}
+async function cleanupOpenCodeFamilyConfigs(params) {
+    const configPaths = (0, fsx_1.uniqueStrings)(params.configPaths);
+    const fallbackConfigPath = configPaths[0] ?? node_path_1.default.join((0, platform_1.xdgConfigHomeDir)(), "opencode", "opencode.json");
+    const snapshot = await (0, opencode_family_1.readOpenCodeRestoreSnapshot)(params.restoreStatePath, fallbackConfigPath);
+    const snapshotTargets = snapshot?.targets ?? [];
+    let changed = false;
+    const restoreConfig = async (target) => {
+        if (!target.existed) {
+            changed = (await (0, fsx_1.removeFileIfExists)(target.configPath)) || changed;
+            return;
+        }
+        const existingRaw = await (0, fsx_1.readFileIfExists)(target.configPath);
+        if (existingRaw === null || !existingRaw.trim()) {
+            return;
+        }
+        let doc;
+        try {
+            doc = (0, fsx_1.objectRecordOr)(JSON.parse(existingRaw), {});
+        }
+        catch {
+            return;
+        }
+        const providerRoot = (0, fsx_1.objectRecordOr)(doc.provider, {});
+        if (providers_1.DEFAULT_PROVIDER_ID in providerRoot) {
+            delete providerRoot[providers_1.DEFAULT_PROVIDER_ID];
+            changed = true;
+        }
+        if (Object.prototype.hasOwnProperty.call(target, "plugin")) {
+            if (target.plugin === null) {
+                if ("plugin" in doc) {
+                    delete doc.plugin;
+                    changed = true;
+                }
+            }
+            else {
+                doc.plugin = target.plugin;
+                changed = true;
+            }
+        }
+        if (target.openAiProvider) {
+            providerRoot[providers_1.OPENAI_PROVIDER_ID] = target.openAiProvider;
+        }
+        else if (providers_1.OPENAI_PROVIDER_ID in providerRoot) {
+            delete providerRoot[providers_1.OPENAI_PROVIDER_ID];
+            changed = true;
+        }
+        if (target.anthropicProvider) {
+            providerRoot[providers_1.ANTHROPIC_PROVIDER_ID] = target.anthropicProvider;
+            changed = true;
+        }
+        else if (providers_1.ANTHROPIC_PROVIDER_ID in providerRoot) {
+            delete providerRoot[providers_1.ANTHROPIC_PROVIDER_ID];
+            changed = true;
+        }
+        doc.provider = providerRoot;
+        if (target.model === null) {
+            if (isManagedOpenCodeModel(doc.model) || (typeof doc.model === "string" && doc.model.startsWith(`${providers_1.DEFAULT_PROVIDER_ID}/`))) {
+                delete doc.model;
+                changed = true;
+            }
+        }
+        else {
+            doc.model = target.model;
+            changed = true;
+        }
+        if (target.schema === null) {
+            if (typeof doc.$schema === "string") {
+                delete doc.$schema;
+                changed = true;
+            }
+        }
+        else {
+            doc.$schema = target.schema;
+            changed = true;
+        }
+        await promises_1.default.writeFile(target.configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    };
+    if (snapshotTargets.length > 0) {
+        for (const target of snapshotTargets) {
+            await restoreConfig(target);
+        }
+        await (0, fsx_1.removeFileIfExists)(params.restoreStatePath);
+        return changed;
+    }
+    for (const configPath of configPaths) {
+        const existingRaw = await (0, fsx_1.readFileIfExists)(configPath);
+        if (existingRaw === null || !existingRaw.trim())
+            continue;
+        let doc;
+        try {
+            doc = (0, fsx_1.objectRecordOr)(JSON.parse(existingRaw), {});
+        }
+        catch {
+            continue;
+        }
+        let fileChanged = false;
+        const providerRoot = (0, fsx_1.objectRecordOr)(doc.provider, {});
+        if (providers_1.DEFAULT_PROVIDER_ID in providerRoot) {
+            delete providerRoot[providers_1.DEFAULT_PROVIDER_ID];
+            fileChanged = true;
+        }
+        const model = doc.model;
+        if (typeof model === "string" &&
+            (model.startsWith(`${providers_1.DEFAULT_PROVIDER_ID}/`) || isManagedOpenCodeModel(model))) {
+            delete doc.model;
+            fileChanged = true;
+        }
+        if (isManagedOpenCodeProvider(providerRoot[providers_1.OPENAI_PROVIDER_ID])) {
+            delete providerRoot[providers_1.OPENAI_PROVIDER_ID];
+            fileChanged = true;
+        }
+        if (isManagedOpenCodeAnthropicProvider(providerRoot[providers_1.ANTHROPIC_PROVIDER_ID])) {
+            delete providerRoot[providers_1.ANTHROPIC_PROVIDER_ID];
+            fileChanged = true;
+        }
+        if (!fileChanged)
+            continue;
+        changed = true;
+        doc.provider = providerRoot;
+        await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    }
+    await (0, fsx_1.removeFileIfExists)(params.restoreStatePath);
+    return changed;
+}
+async function cleanupOpenCodeConfig() {
+    return cleanupOpenCodeFamilyConfigs({
+        configPaths: openCodeConfigCleanupTargets(),
+        restoreStatePath: opencode_family_1.OPENCODE_RESTORE_STATE_PATH,
+    });
+}
+async function cleanupKiloConfig() {
+    return cleanupOpenCodeFamilyConfigs({
+        configPaths: kiloConfigCleanupTargets(),
+        restoreStatePath: opencode_family_1.KILO_RESTORE_STATE_PATH,
+    });
+}

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

@@ -0,0 +1,86 @@
+export declare const OPENCODE_RESTORE_STATE_PATH: string;
+export declare const KILO_RESTORE_STATE_PATH: string;
+export declare const OPENCODE_CONFIG_SCHEMA_URL = "https://opencode.ai/config.json";
+export declare const KILO_CONFIG_SCHEMA_URL = "https://kilo.ai/config.json";
+export type OpenCodeRestoreSnapshotTarget = {
+    configPath: string;
+    existed: boolean;
+    openAiProvider: Record<string, unknown> | null;
+    anthropicProvider?: Record<string, unknown> | null;
+    model: string | null;
+    schema: string | null;
+    plugin?: unknown[] | null;
+};
+export type OpenCodeRestoreSnapshot = {
+    version: 3;
+    targets: OpenCodeRestoreSnapshotTarget[];
+};
+export declare function configFileCandidatesForDir(dir: string, basenames: string[]): string[];
+export declare function findProjectConfigFile(params: {
+    startDir: string;
+    basenames: string[];
+}): string | null;
+export declare function configDirCandidates(appName: string): string[];
+export declare function kiloStorageCandidates(): string[];
+export declare function detectOpenCodeClient(): Promise<boolean>;
+export declare function detectKiloClient(): Promise<boolean>;
+export declare function buildOpenCodeModelConfig(model: {
+    id: string;
+    name: string;
+}): Record<string, unknown>;
+export declare function buildOpenCodeModelsObject(models: Array<{
+    id: string;
+    name: string;
+}>): Record<string, Record<string, unknown>>;
+export declare function buildClaudeModelSelections(modelIds: string[]): Array<{
+    id: string;
+    name: string;
+}>;
+export declare function normalizeOpenCodeRestoreSnapshot(snapshot: unknown, fallbackConfigPath: string): OpenCodeRestoreSnapshot | null;
+export declare function readOpenCodeRestoreSnapshot(restoreStatePath: string, fallbackConfigPath: string): Promise<OpenCodeRestoreSnapshot | null>;
+export declare function openCodeConfigFileCandidates(): string[];
+export declare function findOpenCodeProjectConfigFile(): string | null;
+export declare function isOpenCodeAuthPlugin(value: unknown): boolean;
+export declare function filteredOpenCodePlugins(value: unknown): {
+    next: unknown;
+    changed: boolean;
+};
+export declare function kiloConfigFileCandidates(): string[];
+export declare function resolveOpenCodeConfigTargets(): string[];
+export declare function resolveKiloConfigTargets(): string[];
+export declare function isManagedOpenCodeProvider(provider: Record<string, unknown>, backendUrl: string): boolean;
+export declare function isManagedOpenCodeAnthropicProvider(provider: Record<string, unknown>, backendUrl: string): boolean;
+export declare function isManagedOpenCodeModel(value: unknown, supportedModelIds: Set<string>): boolean;
+export declare function writeOpenCodeFamilyConfig(params: {
+    backendUrl: string;
+    model: string;
+    models: Array<{
+        id: string;
+        name: string;
+    }>;
+    claudeModels?: string[];
+    apiKey: string;
+    configPaths: string[];
+    restoreStatePath: string;
+    schemaUrl: string;
+}): Promise<string[]>;
+export declare function writeOpenCodeConfig(params: {
+    backendUrl: string;
+    model: string;
+    models: Array<{
+        id: string;
+        name: string;
+    }>;
+    claudeModels?: string[];
+    apiKey: string;
+}): Promise<string[]>;
+export declare function writeKiloConfig(params: {
+    backendUrl: string;
+    model: string;
+    models: Array<{
+        id: string;
+        name: string;
+    }>;
+    claudeModels?: string[];
+    apiKey: string;
+}): Promise<string[]>;