cartethyia 2.7.4 → 2.7.6

package/src/console/cli-tools/injectors/driver.ts

@@ -1,247 +1,150 @@
-// Declarative file injector driver and lifecycle contracts.
-
-import { dirname } from "node:path";
-import type {
-  ApplyInput,
-  ApplyResult,
-  DownloadResult,
-  InjectorSpec,
-  ToolDef,
-  ToolId,
-  ToolInjector,
-  ToolStatus,
-} from "../contracts";
-import { TOOL_IDS, TOOL_REGISTRY } from "../contracts";
-import { checkBinaryInstalled, ensureDir, ensureV1Suffix, fileExists, keyPrefix } from "../fs-ops";
-import { claudeSpec } from './claude';
-import { clineSpec } from './cline';
-import { codexSpec } from './codex';
-import { copilotSpec } from './copilot';
-import { coworkSpec } from './cowork';
-import { deepseekTuiSpec } from './deepseek-tui';
-import { droidSpec } from './droid';
-import { grokBuildSpec } from './grok-build';
-import { hermesSpec } from './hermes';
-import { jcodeSpec } from './jcode';
-import { kiloSpec } from './kilo';
-import { openclawSpec } from './openclaw';
-import { opencodeSpec } from './opencode';
-
-// ── injectors/driver.ts ──
-/**
- * Generic driver and declarative spec types for CLI tool injectors.
- *
- * Implements the probe -> read -> apply -> write lifecycle for file-based
- * CLI tool injectors, eliminating repetitive boilerplate while allowing
- * tool-specific escape hatches.
- */
-
-/**
- * Create a ToolInjector from a declarative InjectorSpec.
- */
-export function createFileInjector(spec: InjectorSpec): ToolInjector {
-  return {
-    toolId: spec.toolId,
-    async getStatus(): Promise<ToolStatus> {
-      const path = spec.resolvePath();
-      const installed = spec.checkInstalled
-        ? await spec.checkInstalled(path)
-        : spec.binary
-          ? await checkBinaryInstalled(spec.binary)
-          : await fileExists(path);
-
-      const exists = await fileExists(path);
-      if (!installed && !exists) {
-        return {
-          toolId: spec.toolId,
-          installed: false,
-          configured: false,
-          settingsPath: spec.keepSettingsPathOnMissing ? path : null,
-          currentEndpoint: null,
-          currentApiKeyPrefix: null,
-          currentModels: null,
-        };
-      }
-
-      if (!exists) {
-        return {
-          toolId: spec.toolId,
-          installed,
-          configured: false,
-          settingsPath: path,
-          currentEndpoint: null,
-          currentApiKeyPrefix: null,
-          currentModels: null,
-        };
-      }
-
-      const details = await spec.readStatus(path);
-      return {
-        toolId: spec.toolId,
-        installed: true,
-        configured: details.configured,
-        settingsPath: path,
-        currentEndpoint: details.currentEndpoint ?? null,
-        currentApiKeyPrefix: details.currentApiKeyPrefix ?? keyPrefix(details.rawApiKey) ?? null,
-        currentModels: details.currentModels ?? null,
-        ...(details.message ? { message: details.message } : {}),
-      };
-    },
-
-    async apply(input: ApplyInput): Promise<ApplyResult> {
-      const path = spec.resolvePath();
-      const dir = spec.resolveDir ? spec.resolveDir() : dirname(path);
-      await ensureDir(dir);
-      await spec.apply(input, path);
-      return {
-        success: true,
-        settingsPath: path,
-        message: spec.messages?.applied ?? `${spec.displayName ?? spec.toolId} settings applied`,
-      };
-    },
-
-    async reset(): Promise<ApplyResult> {
-      const path = spec.resolvePath();
-      const exists = await fileExists(path);
-      if (!exists && !spec.resetEvenIfMissing) {
-        return {
-          success: true,
-          message: spec.messages?.resetMissing ?? `No settings file to reset`,
-        };
-      }
-      const resetResult = await spec.reset(path);
-      if (resetResult === false) {
-        return {
-          success: true,
-          message: spec.messages?.resetMissing ?? `No settings file to reset`,
-        };
-      }
-      return {
-        success: true,
-        settingsPath: path,
-        message:
-          spec.messages?.reset ??
-          `Cartethyia settings removed from ${spec.displayName ?? spec.toolId}`,
-      };
-    },
-
-    async download(input: ApplyInput): Promise<DownloadResult> {
-      return spec.download(input);
-    },
-  };
-}
-
-/** Create a guide injector for a specific tool definition (any `configType: "guide"` entry). */
-export function guideInjectorFor(def: ToolDef): ToolInjector {
-  return {
-    toolId: def.id,
-
-    async getStatus(): Promise<ToolStatus> {
-      // Guide tools are always "not installed" from an injection standpoint —
-      // we can't detect the binary reliably, and config is manual.
-      return {
-        toolId: def.id,
-        installed: false,
-        configured: false,
-        settingsPath: null,
-        currentEndpoint: null,
-        currentApiKeyPrefix: null,
-        currentModels: null,
-        message: "Guide-only tool — use Download Config to get setup instructions",
-      };
-    },
-
-    async apply(): Promise<ApplyResult> {
-      return { success: false, message: `${def.name} is a guide-only tool — use Download Config` };
-    },
-
-    async reset(): Promise<ApplyResult> {
-      return { success: true, message: `${def.name} has no injected config to reset` };
-    },
-
-    async download(input: ApplyInput): Promise<DownloadResult> {
-      const baseUrl = ensureV1Suffix(input.endpoint);
-      const model = input.activeModel ?? input.modelIds[0] ?? "";
-      const apiKey = input.apiKey;
-      const codeBlock = def.codeBlock;
-
-      if (codeBlock) {
-        const content = codeBlock.code
-          .replace(/\{\{baseUrl\}\}/g, baseUrl)
-          .replace(/\{\{apiKey\}\}/g, apiKey)
-          .replace(/\{\{model\}\}/g, model);
-        const ext =
-          codeBlock.language === "json" ? "json" : codeBlock.language === "bash" ? "sh" : "txt";
-        return {
-          content,
-          filename: `${def.id}-config.${ext}`,
-          mimeType: codeBlock.language === "json" ? "application/json" : "text/plain",
-        };
-      }
-
-      // No code block — generate a simple guide summary.
-      const steps = def.guideSteps ?? [];
-      const lines = [`# ${def.name} — Setup Guide`, ""];
-      for (const step of steps) {
-        lines.push(`## Step ${step.step}: ${step.title}`);
-        if (step.desc) lines.push(step.desc);
-        if (step.value) {
-          lines.push("```");
-          lines.push(
-            step.value
-              .replace(/\{\{baseUrl\}\}/g, baseUrl)
-              .replace(/\{\{apiKey\}\}/g, apiKey)
-              .replace(/\{\{model\}\}/g, model),
-          );
-          lines.push("```");
-        }
-        lines.push("");
-      }
-      lines.push(`Endpoint: ${baseUrl}`);
-      lines.push(`API Key: ${apiKey}`);
-      lines.push(`Model: ${model}`);
-      return { content: lines.join("\n"), filename: `${def.id}-guide.txt`, mimeType: "text/plain" };
-    },
-  };
-}
-
-// ── injectors/index.ts ──
-/**
- * Single dispatch point for CliToolService: given a toolId, look up the
- * injector and call getStatus/apply/reset/download.
- *
- * File-based injectors are driven by a generic driver (createFileInjector)
- * configured via declarative specs. Guide-only tools (registry `configType:
- * "guide"`) are all built from `guideInjectorFor` — no per-tool constant
- * needed; the registry itself is the single source of the list. The map is
- * built exhaustively from that registry so a non-guide tool without an
- * injector fails loudly at import, never silently at lookup time.
- */
-const FILE_INJECTORS: Partial<Record<ToolId, ToolInjector>> = {
-  claude: createFileInjector(claudeSpec),
-  codex: createFileInjector(codexSpec),
-  cline: createFileInjector(clineSpec),
-  opencode: createFileInjector(opencodeSpec),
-  droid: createFileInjector(droidSpec),
-  hermes: createFileInjector(hermesSpec),
-  "grok-build": createFileInjector(grokBuildSpec),
-  copilot: createFileInjector(copilotSpec),
-  "deepseek-tui": createFileInjector(deepseekTuiSpec),
-  jcode: createFileInjector(jcodeSpec),
-  kilo: createFileInjector(kiloSpec),
-  openclaw: createFileInjector(openclawSpec),
-  cowork: createFileInjector(coworkSpec),
-};
-
-export const INJECTORS: Record<ToolId, ToolInjector> = Object.fromEntries(
-  TOOL_IDS.map((id) => {
-    const injector =
-      TOOL_REGISTRY[id].configType === "guide"
-        ? guideInjectorFor(TOOL_REGISTRY[id])
-        : FILE_INJECTORS[id];
-    if (injector === undefined) {
-      throw new Error(`No injector registered for tool: ${id}`);
-    }
-    return [id, injector];
-  }),
-) as Record<ToolId, ToolInjector>;
+// Declarative file injector driver and lifecycle contracts.
+
+import { dirname } from "node:path";
+import type {
+  ApplyInput,
+  ApplyResult,
+  DownloadResult,
+  InjectorSpec,
+  ToolId,
+  ToolInjector,
+  ToolStatus,
+} from "../contracts";
+import { TOOL_IDS } from "../contracts";
+import { checkBinaryInstalled, ensureDir, fileExists, keyPrefix } from "../fs-ops";
+import { claudeSpec } from './claude';
+import { codexSpec } from './codex';
+import { kiloSpec } from './kilo';
+import { opencodeSpec } from './opencode';
+
+// ── injectors/driver.ts ──
+/**
+ * Generic driver and declarative spec types for CLI tool injectors.
+ *
+ * Implements the probe -> read -> apply -> write lifecycle for file-based
+ * CLI tool injectors, eliminating repetitive boilerplate while allowing
+ * tool-specific escape hatches.
+ */
+
+/**
+ * Create a ToolInjector from a declarative InjectorSpec.
+ */
+export function createFileInjector(spec: InjectorSpec): ToolInjector {
+  return {
+    toolId: spec.toolId,
+    async getStatus(): Promise<ToolStatus> {
+      const path = spec.resolvePath();
+      const installed = spec.checkInstalled
+        ? await spec.checkInstalled(path)
+        : spec.binary
+          ? await checkBinaryInstalled(spec.binary)
+          : await fileExists(path);
+
+      const exists = await fileExists(path);
+      if (!installed && !exists) {
+        return {
+          toolId: spec.toolId,
+          installed: false,
+          configured: false,
+          settingsPath: spec.keepSettingsPathOnMissing ? path : null,
+          currentEndpoint: null,
+          currentApiKeyPrefix: null,
+          currentModels: null,
+        };
+      }
+
+      if (!exists) {
+        return {
+          toolId: spec.toolId,
+          installed,
+          configured: false,
+          settingsPath: path,
+          currentEndpoint: null,
+          currentApiKeyPrefix: null,
+          currentModels: null,
+        };
+      }
+
+      const details = await spec.readStatus(path);
+      return {
+        toolId: spec.toolId,
+        installed: true,
+        configured: details.configured,
+        settingsPath: path,
+        currentEndpoint: details.currentEndpoint ?? null,
+        currentApiKeyPrefix: details.currentApiKeyPrefix ?? keyPrefix(details.rawApiKey) ?? null,
+        currentModels: details.currentModels ?? null,
+        ...(details.message ? { message: details.message } : {}),
+      };
+    },
+
+    async apply(input: ApplyInput): Promise<ApplyResult> {
+      const path = spec.resolvePath();
+      const dir = spec.resolveDir ? spec.resolveDir() : dirname(path);
+      await ensureDir(dir);
+      const warnings = await spec.apply(input, path);
+      return {
+        success: true,
+        settingsPath: path,
+        message: spec.messages?.applied ?? `${spec.displayName ?? spec.toolId} settings applied`,
+        ...(Array.isArray(warnings) && warnings.length > 0 ? { warnings } : {}),
+      };
+    },
+
+    async reset(): Promise<ApplyResult> {
+      const path = spec.resolvePath();
+      const exists = await fileExists(path);
+      if (!exists && !spec.resetEvenIfMissing) {
+        return {
+          success: true,
+          message: spec.messages?.resetMissing ?? `No settings file to reset`,
+        };
+      }
+      const resetResult = await spec.reset(path);
+      if (resetResult === false) {
+        return {
+          success: true,
+          message: spec.messages?.resetMissing ?? `No settings file to reset`,
+        };
+      }
+      return {
+        success: true,
+        settingsPath: path,
+        message:
+          spec.messages?.reset ??
+          `Cartethyia settings removed from ${spec.displayName ?? spec.toolId}`,
+      };
+    },
+
+    async download(input: ApplyInput): Promise<DownloadResult> {
+      return spec.download(input);
+    },
+  };
+}
+
+// ── injectors/index.ts ──
+/**
+ * Single dispatch point for CliToolService: given a toolId, look up the
+ * injector and call getStatus/apply/reset/download.
+ *
+ * File-based injectors are driven by a generic driver (createFileInjector)
+ * configured via declarative specs. The map is built exhaustively from that
+ * registry so a tool without an injector fails loudly at import, never
+ * silently at lookup time.
+ */
+const FILE_INJECTORS: Partial<Record<ToolId, ToolInjector>> = {
+  claude: createFileInjector(claudeSpec),
+  codex: createFileInjector(codexSpec),
+  opencode: createFileInjector(opencodeSpec),
+  kilo: createFileInjector(kiloSpec),
+};
+
+export const INJECTORS: Record<ToolId, ToolInjector> = Object.fromEntries(
+  TOOL_IDS.map((id) => {
+    const injector = FILE_INJECTORS[id];
+    if (injector === undefined) {
+      throw new Error(`No injector registered for tool: ${id}`);
+    }
+    return [id, injector];
+  }),
+) as Record<ToolId, ToolInjector>;

package/src/console/cli-tools/injectors/kilo.ts

@@ -1,13 +1,36 @@
 import { platform } from "node:os";
 import type {} from "../contracts";
-import { resolveApplyTarget, jsonDownload } from "../contracts";
-import { homeDir, isLocalEndpoint, join, readJsonFile, writeJsonFile } from "../fs-ops";
+import { jsonDownload } from "../contracts";
+import { homeDir, isLocalEndpoint, join, readJsonFile, writeJsonFileWithBackup } from "../fs-ops";
 import type { InjectorSpec } from "../contracts";
 
 const IS_WIN = platform() === "win32";
 const IS_MAC = platform() === "darwin";
 
 // Kilo Code injector spec.
+//
+// Kilo Code is a fork of OpenCode, but it now reads its own config file —
+// `~/.config/kilo/kilo.jsonc` (Windows: `%USERPROFILE%\.config\kilo\kilo.jsonc`)
+// — with the same provider shape as OpenCode: `provider.<id>.npm/options/models`
+// plus a top-level `model`. Unlike OpenCode, Kilo runs on the AI SDK, so the
+// `npm` value must be an `@ai-sdk/*` package (default `@ai-sdk/openai-compatible`).
+//
+// The older VS Code extension also keeps a credential store at
+// `~/.local/share/kilo/auth.json`; we still write the endpoint there for
+// backward compatibility, but the canonical config is now `kilo.jsonc`.
+
+const KILO_PROVIDER_ID = "cartethyia";
+
+function resolveKiloConfigDirectory(): string {
+  if (IS_WIN) return join(process.env.USERPROFILE ?? homeDir(), ".config", "kilo");
+  if (IS_MAC) return join(homeDir(), ".config", "kilo");
+  return join(homeDir(), ".config", "kilo");
+}
+
+function kiloConfigPath(): string {
+  return join(resolveKiloConfigDirectory(), "kilo.jsonc");
+}
+
 function resolveKiloDataDirectory(): string {
   if (IS_WIN) return join(process.env.LOCALAPPDATA ?? homeDir(), "kilo");
   if (IS_MAC) return join(homeDir(), "Library", "Application Support", "kilo");
@@ -21,15 +44,52 @@ function kiloVscodeSettingsPath(): string {
   return join(homeDir(), ".config", "Code", "User", "settings.json");
 }
 
+function kiloModelDef(model: string): unknown {
+  return {
+    name: model,
+    limit: { context: 128000, output: 64000 },
+  };
+}
+
+function buildKiloModels(models: readonly string[]): Record<string, unknown> {
+  const map: Record<string, unknown> = {};
+  for (const m of models) {
+    if (!m) continue;
+    map[m] = kiloModelDef(m);
+  }
+  return map;
+}
+
 export const kiloSpec: InjectorSpec = {
   toolId: "kilo",
   displayName: "Kilo Code",
   binary: "kilo",
-  resolveDir: resolveKiloDataDirectory,
-  resolvePath: () => join(resolveKiloDataDirectory(), "auth.json"),
+  resolveDir: resolveKiloConfigDirectory,
+  resolvePath: kiloConfigPath,
 
   async readStatus(path) {
-    const auth = (await readJsonFile(path)) as Record<
+    const config = (await readJsonFile(path)) as {
+      provider?: Record<string, { npm?: string; options?: { baseURL?: string; apiKey?: string }; models?: Record<string, unknown> }>;
+      model?: string;
+    } | null;
+    const provider = config?.provider?.[KILO_PROVIDER_ID];
+    const endpoint = provider?.options?.baseURL ?? null;
+    const models = provider?.models ? Object.keys(provider.models) : null;
+    const active =
+      typeof config?.model === "string" && config.model.startsWith(`${KILO_PROVIDER_ID}/`)
+        ? config.model.split("/").slice(1).join("/")
+        : null;
+    if (endpoint) {
+      return {
+        configured: isLocalEndpoint(endpoint),
+        currentEndpoint: endpoint,
+        rawApiKey: provider?.options?.apiKey ?? null,
+        currentModels: active && models ? [active, ...models.filter((m) => m !== active)] : models,
+      };
+    }
+
+    // Fallback to the legacy auth.json store (older VS Code extension).
+    const auth = (await readJsonFile(join(resolveKiloDataDirectory(), "auth.json"))) as Record<
       string,
       { baseUrl?: string; baseURL?: string; apiKey?: string; model?: string }
     > | null;
@@ -47,22 +107,77 @@ export const kiloSpec: InjectorSpec = {
   },
 
   async apply(input, path) {
-    const { model, baseUrl } = resolveApplyTarget(input);
-    const auth = ((await readJsonFile(path)) as Record<string, unknown> | null) ?? {};
-    auth["openai-compatible"] = { baseUrl, apiKey: input.apiKey, model };
-    await writeJsonFile(path, auth);
+    // Canonical config: ~/.config/kilo/kilo.jsonc
+    const existing = (await readJsonFile(path)) as Record<string, unknown> | null;
+    const config: Record<string, unknown> = (existing ?? {}) as Record<string, unknown>;
+    if (!config.provider || typeof config.provider !== "object") config.provider = {};
+    const providers = config.provider as Record<string, unknown>;
+    const prior = (providers[KILO_PROVIDER_ID] as Record<string, unknown> | undefined) ?? {};
+    const priorModels = (prior.models as Record<string, unknown> | undefined) ?? {};
+    const otherProviders = Object.keys(providers).filter((id) => id !== KILO_PROVIDER_ID);
+    providers[KILO_PROVIDER_ID] = {
+      npm: input.sdk ?? (prior as { npm?: string }).npm ?? "@ai-sdk/openai-compatible",
+      options: {
+        ...((prior.options as Record<string, unknown> | undefined) ?? {}),
+        baseURL: input.endpoint,
+        apiKey: input.apiKey,
+      },
+      models: { ...priorModels, ...buildKiloModels(input.modelIds) },
+    };
+    const activeModel = input.activeModel ?? input.modelIds[0] ?? "";
+    config.model = activeModel === "" ? "" : `${KILO_PROVIDER_ID}/${activeModel}`;
+
+    // YOLO mode: auto-approve shell/read/write.
+    if (input.bypassPermissions === true) {
+      config.permissions = [
+        { action: "shell", resource: "*", effect: "allow" },
+        { action: "external_directory", resource: "*", effect: "allow" },
+        { action: "question", resource: "*", effect: "deny" },
+      ];
+    } else if (input.bypassPermissions === false) {
+      delete config.permissions;
+    }
+
+    await writeJsonFileWithBackup(path, config);
+
+    // Legacy credential store for the older VS Code extension.
+    const authPath = join(resolveKiloDataDirectory(), "auth.json");
+    const auth = ((await readJsonFile(authPath)) as Record<string, unknown> | null) ?? {};
+    auth["openai-compatible"] = { baseUrl: input.endpoint, apiKey: input.apiKey, model: activeModel };
+    await writeJsonFileWithBackup(authPath, auth);
 
     const settings =
       ((await readJsonFile(kiloVscodeSettingsPath())) as Record<string, unknown> | null) ?? {};
     settings["kilo.code.authProviderOverride"] = "openai-compatible";
-    await writeJsonFile(kiloVscodeSettingsPath(), settings);
+    await writeJsonFileWithBackup(kiloVscodeSettingsPath(), settings);
+
+    return otherProviders.length > 0
+      ? [
+          `Config already has other provider(s): ${otherProviders.join(", ")}. They were kept as-is — only ${KILO_PROVIDER_ID} was written/updated.`,
+        ]
+      : undefined;
   },
 
   async reset(path) {
-    const auth = (await readJsonFile(path)) as Record<string, unknown> | null;
-    if (!auth) return false;
-    delete auth["openai-compatible"];
-    await writeJsonFile(path, auth);
+    const config = (await readJsonFile(path)) as Record<string, unknown> | null;
+    if (config && config.provider && typeof config.provider === "object") {
+      const providers = config.provider as Record<string, unknown>;
+      delete providers[KILO_PROVIDER_ID];
+      if (Object.keys(providers).length === 0) delete config.provider;
+    }
+    if (typeof config?.model === "string" && config.model.startsWith(`${KILO_PROVIDER_ID}/`)) {
+      delete config.model;
+    }
+    if (config) await writeJsonFileWithBackup(path, config);
+
+    const auth = (await readJsonFile(join(resolveKiloDataDirectory(), "auth.json"))) as Record<
+      string,
+      unknown
+    > | null;
+    if (auth) {
+      delete auth["openai-compatible"];
+      await writeJsonFileWithBackup(join(resolveKiloDataDirectory(), "auth.json"), auth);
+    }
 
     const settings = (await readJsonFile(kiloVscodeSettingsPath())) as Record<
       string,
@@ -70,21 +185,31 @@ export const kiloSpec: InjectorSpec = {
     > | null;
     if (settings && "kilo.code.authProviderOverride" in settings) {
       delete settings["kilo.code.authProviderOverride"];
-      await writeJsonFile(kiloVscodeSettingsPath(), settings);
+      await writeJsonFileWithBackup(kiloVscodeSettingsPath(), settings);
     }
   },
 
   download(input) {
-    const { model, baseUrl } = resolveApplyTarget(input);
-    return jsonDownload({ "openai-compatible": { baseUrl, apiKey: input.apiKey, model } }, {
-      filename: "auth.json",
-    });
+    const activeModel = input.activeModel ?? input.modelIds[0] ?? "";
+    const config: Record<string, unknown> = {
+      provider: {
+        [KILO_PROVIDER_ID]: {
+          npm: input.sdk ?? "@ai-sdk/openai-compatible",
+          options: {
+            baseURL: input.endpoint,
+            apiKey: input.apiKey,
+          },
+          models: buildKiloModels(input.modelIds),
+        },
+      },
+      model: activeModel === "" ? "" : `${KILO_PROVIDER_ID}/${activeModel}`,
+    };
+    return jsonDownload(config, { filename: "kilo.jsonc" });
   },
 
   messages: {
     applied: "Kilo Code settings applied",
     reset: "Cartethyia settings removed from Kilo Code",
-    resetMissing: "No auth file to reset",
+    resetMissing: "No config file to reset",
   },
 };
-