@koreanhole/opencodex 3.0.0 → 3.2.0

package/src/adapters/cli-agent/cline/settings.ts

@@ -6,8 +6,10 @@ import { baseScopedEnv } from "../env";
 /** Built-in, subagent, and team tools that a model-only Cline turn must never enable. */
 export const CLINE_DISABLED_TOOL_IDS = Object.freeze([
   "read_files",
+  "list_files",
   "search_codebase",
   "run_commands",
+  "run_terminal_command",
   "fetch_web_content",
   "apply_patch",
   "editor",
@@ -68,6 +70,10 @@ export interface ClineSelection {
   model?: string;
 }
 
+export type ClineMcpLaunch =
+  | { kind: "module"; modulePath: string }
+  | { kind: "entrypoint"; entrypoint: string };
+
 interface ClineSelectionCandidate {
   providerId: string;
   model?: string;
@@ -261,12 +267,13 @@ export async function assertClineSelectionSafe(providerSettingsPath: string): Pr
  * The vendor store is advisory: absence or another schema is Cline's business.
  * Only an explicit route back through this proxy remains a hard refusal.
  */
-export async function assertClineAdvisoryDestinationSafe(providerSettingsPath: string): Promise<void> {
+export async function assertClineAdvisoryDestinationSafe(providerSettingsPath: string): Promise<ClineSelection | undefined> {
   try {
-    await assertClineSelectionSafe(providerSettingsPath);
+    return await assertClineSelectionSafe(providerSettingsPath);
   } catch (error) {
     if (error instanceof ClineSettingsError && error.code === "cli_provider_recursion") throw error;
     if (!(error instanceof ClineSettingsError)) throw error;
+    return undefined;
   }
 }
 
@@ -285,8 +292,25 @@ function clineGlobalSettings(): Record<string, unknown> {
   };
 }
 
-function clineMcpSettings(): Record<string, unknown> {
-  return { mcpServers: {} };
+function clineMcpArgs(launch: ClineMcpLaunch, catalogPath: string): string[] {
+  return launch.kind === "module"
+    ? [launch.modulePath, catalogPath]
+    : [launch.entrypoint, catalogPath];
+}
+
+function clineMcpSettings(launch: ClineMcpLaunch | undefined, catalogPath: string): Record<string, unknown> {
+  if (!launch) return { mcpServers: {} };
+  return {
+    mcpServers: {
+      opencodex: {
+        transport: {
+          type: "stdio",
+          command: process.execPath,
+          args: clineMcpArgs(launch, catalogPath),
+        },
+      },
+    },
+  };
 }
 
 /** Share a staged file at a vendor-default path. */
@@ -346,6 +370,7 @@ async function linkClineSettings(input: {
 export async function stageClineTurn(options: {
   providerSettingsPath: string;
   catalog: readonly Record<string, unknown>[];
+  mcpLaunch?: ClineMcpLaunch;
 }): Promise<ClineStagedTurn> {
   const root = await mkdtemp(join(tmpdir(), "ocx-cline-cli-"));
   const configDir = join(root, "config");
@@ -378,7 +403,7 @@ export async function stageClineTurn(options: {
     ]);
     await Promise.all([
       writeFile(globalSettingsPath, `${JSON.stringify(clineGlobalSettings(), null, 2)}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" }),
-      writeFile(mcpSettingsPath, `${JSON.stringify(clineMcpSettings(), null, 2)}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" }),
+      writeFile(mcpSettingsPath, `${JSON.stringify(clineMcpSettings(options.mcpLaunch, catalogPath), null, 2)}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" }),
       writeFile(catalogPath, JSON.stringify(options.catalog), { encoding: "utf8", mode: 0o600, flag: "wx" }),
     ]);
     const copiedProviderStore = await copyClineProviderSettings(options.providerSettingsPath, providerSettingsPath);
@@ -409,6 +434,40 @@ export async function stageClineTurn(options: {
   }
 }
 
+/** Merge newly discovered built-in IDs into the private staged disable list. */
+export async function mergeClineDisabledTools(
+  staged: Pick<ClineStagedTurn, "globalSettingsPath">,
+  ids: readonly string[],
+): Promise<void> {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(await readFile(staged.globalSettingsPath, "utf8"));
+  } catch {
+    throw new ClineSettingsError(
+      "Cline global settings are malformed; the tool preflight cannot be repaired.",
+      500,
+      "cline_cli_setup_failed",
+    );
+  }
+  const settings = asRecord(parsed);
+  if (!settings) {
+    throw new ClineSettingsError(
+      "Cline global settings are malformed; the tool preflight cannot be repaired.",
+      500,
+      "cline_cli_setup_failed",
+    );
+  }
+  const current = Array.isArray(settings.disabledTools)
+    ? settings.disabledTools.filter((value): value is string => typeof value === "string")
+    : [];
+  const merged = [...new Set([...current, ...ids])];
+  await writeFile(
+    staged.globalSettingsPath,
+    `${JSON.stringify({ ...settings, disabledTools: merged }, null, 2)}\n`,
+    { encoding: "utf8", mode: 0o600 },
+  );
+}
+
 export function buildClineChildEnv(staged: ClineStagedTurn, sourceEnv: NodeJS.ProcessEnv = process.env): Record<string, string> {
   const env = baseScopedEnv();
   env.HOME = staged.homeDir;

package/src/adapters/cli-agent/cline/stream.ts

@@ -1,6 +1,9 @@
-import type { AdapterEvent } from "../../../types";
+import type { AdapterEvent, OcxUsage } from "../../../types";
 import type { CliAgentStreamState } from "../types";
 import { mapToolIntent, ToolIntentError } from "../tool-intent";
+import { redactSecretString } from "../../../lib/redact";
+
+const MAX_ERROR_CHARS = 2_048;
 
 export class ClineStreamProtocolError extends Error {
   readonly code = "cli_protocol_error";
@@ -42,3 +45,200 @@ export function mapClineToolIntent(
     throw error;
   }
 }
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
+function asString(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}
+
+function safeMessage(value: unknown): string {
+  const raw = typeof value === "string"
+    ? value
+    : value instanceof Error
+      ? value.message
+      : value === undefined
+        ? "Cline reported an error."
+        : JSON.stringify(value) ?? String(value);
+  return redactSecretString(raw).slice(0, MAX_ERROR_CHARS);
+}
+
+function classifyError(message: string): { status: number; errorType: string; code: string; retryable: boolean } {
+  if (/not logged in|please (?:run )?\/?login|sign in|authentication (?:failed|required)|unauthorized|invalid (?:api )?key/i.test(message)) {
+    return { status: 401, errorType: "authentication_error", code: "cline_cli_not_logged_in", retryable: false };
+  }
+  if (/rate limit|too many requests|quota|credit|usage limit|daily limit/i.test(message)) {
+    return { status: 429, errorType: "rate_limit_error", code: "rate_limit_exceeded", retryable: true };
+  }
+  if (/model (?:is )?(?:not found|unavailable|unsupported)|invalid model/i.test(message)) {
+    return { status: 400, errorType: "invalid_request_error", code: "model_not_found", retryable: false };
+  }
+  return { status: 502, errorType: "upstream_error", code: "cli_protocol_error", retryable: false };
+}
+
+function usageFrom(value: unknown): OcxUsage | undefined {
+  const record = asRecord(value);
+  if (!record) return undefined;
+  const count = (input: unknown): number =>
+    typeof input === "number" && Number.isFinite(input) && input >= 0 ? Math.floor(input) : 0;
+  const inputTokens = count(record.inputTokens);
+  const outputTokens = count(record.outputTokens);
+  const cacheRead = count(record.cacheReadTokens);
+  const cacheWrite = count(record.cacheWriteTokens);
+  if (inputTokens === 0 && outputTokens === 0 && cacheRead === 0 && cacheWrite === 0) return undefined;
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: inputTokens + outputTokens,
+    ...(cacheRead > 0 ? { cachedInputTokens: cacheRead, cacheReadInputTokens: cacheRead } : {}),
+    ...(cacheWrite > 0 ? { cacheCreationInputTokens: cacheWrite } : {}),
+  };
+}
+
+function mapAgentEvent(
+  event: Record<string, unknown>,
+  state: CliAgentStreamState,
+  options: ClineStreamOptions,
+): AdapterEvent[] {
+  const type = asString(event.type);
+  if (type === "content_start") {
+    const contentType = asString(event.contentType);
+    if (contentType === "text") {
+      const text = asString(event.text);
+      if (!text) return [];
+      state.sawText = true;
+      return [{ type: "text_delta", text }];
+    }
+    if (contentType === "reasoning") {
+      const thinking = asString(event.reasoning);
+      if (!thinking) return [];
+      state.sawThinking = true;
+      return [{ type: "thinking_delta", thinking }];
+    }
+    if (contentType === "tool") {
+      const vendorName = asString(event.toolName);
+      if (!vendorName) throw new ClineStreamProtocolError("Cline returned a tool call without a name.");
+      return mapClineToolIntent(vendorName, asString(event.toolCallId), event.input, state, options);
+    }
+    return [];
+  }
+
+  if (type === "content_end") {
+    const contentType = asString(event.contentType);
+    if (contentType === "text" && !state.sawText) {
+      const text = asString(event.text);
+      if (text) {
+        state.sawText = true;
+        return [{ type: "text_delta", text }];
+      }
+    }
+    if (contentType === "reasoning" && !state.sawThinking) {
+      const thinking = asString(event.reasoning);
+      if (thinking) {
+        state.sawThinking = true;
+        return [{ type: "thinking_delta", thinking }];
+      }
+    }
+    return [];
+  }
+
+  if (type === "usage") {
+    const usage = usageFrom(event);
+    if (usage) state.usage = usage;
+    return [];
+  }
+
+  if (type === "error") {
+    if (event.recoverable === true) return [];
+    const message = safeMessage(asRecord(event.error)?.message ?? event.error ?? "Cline reported an error.");
+    state.lastError = message;
+    state.terminal = true;
+    return [{ type: "error", message, ...classifyError(message) }];
+  }
+
+  if (type === "done") {
+    state.terminal = true;
+    if (state.toolCalls > 0) return [];
+    const events: AdapterEvent[] = [];
+    if (!state.sawText) {
+      const text = asString(event.text);
+      if (text) {
+        state.sawText = true;
+        events.push({ type: "text_delta", text });
+      }
+    }
+    const usage = usageFrom(event.usage) ?? state.usage;
+    events.push({ type: "done", stopReason: "stop", ...(usage ? { usage } : {}) });
+    return events;
+  }
+
+  return [];
+}
+
+/** Map one bounded Cline JSON frame to provider-neutral events. */
+export function mapClineMessage(
+  message: Record<string, unknown>,
+  state: CliAgentStreamState,
+  options: ClineStreamOptions,
+): AdapterEvent[] {
+  if (state.terminal) return [];
+  const type = asString(message.type);
+  if (type === "agent_event") {
+    const event = asRecord(message.event);
+    return event ? mapAgentEvent(event, state, options) : [];
+  }
+
+  if (type === "run_result") {
+    if (state.toolCalls > 0) return [];
+    const usage = usageFrom(message.usage) ?? state.usage;
+    if (usage) state.usage = usage;
+    const finishReason = asString(message.finishReason);
+    if (finishReason && finishReason !== "completed" && finishReason !== "stop") {
+      const messageText = safeMessage(message.text ?? `Cline finished with ${finishReason}.`);
+      state.terminal = true;
+      return [{ type: "error", message: messageText, ...classifyError(messageText) }];
+    }
+    state.terminal = true;
+    const events: AdapterEvent[] = [];
+    if (!state.sawText) {
+      const text = asString(message.text);
+      if (text) {
+        state.sawText = true;
+        events.push({ type: "text_delta", text });
+      }
+    }
+    events.push({ type: "done", stopReason: "stop", ...(usage ? { usage } : {}) });
+    return events;
+  }
+
+  if (type === "run_aborted") {
+    state.terminal = true;
+    return [{
+      type: "error",
+      message: safeMessage(message.message ?? "Cline aborted the turn."),
+      status: 499,
+      errorType: "invalid_request_error",
+      code: "client_cancelled",
+      retryable: false,
+    }];
+  }
+
+  if (type === "error") {
+    const detail = safeMessage(message.message ?? "Cline reported an error.");
+    state.lastError = detail;
+    state.terminal = true;
+    return [{ type: "error", message: detail, ...classifyError(detail) }];
+  }
+
+  return [];
+}
+
+/** Convert a nonzero process exit into a stable terminal error. */
+export function classifyClineFailure(exitCode: number, stderr: string): Extract<AdapterEvent, { type: "error" }> {
+  const detail = safeMessage(stderr.trim() || `Cline exited with code ${exitCode}.`);
+  return { type: "error", message: detail, ...classifyError(detail) };
+}

package/src/adapters/cli-agent/env.ts

@@ -5,10 +5,10 @@ const INHERITED_ENV_KEYS = [
 ] as const;
 
 /** A deterministic child environment with no inherited vendor credentials. */
-export function baseScopedEnv(): Record<string, string> {
+export function baseScopedEnv(sourceEnv: NodeJS.ProcessEnv = process.env): Record<string, string> {
   const env: Record<string, string> = {};
   for (const key of INHERITED_ENV_KEYS) {
-    const value = process.env[key];
+    const value = sourceEnv[key];
     if (typeof value === "string" && value.length > 0) env[key] = value;
   }
   return env;