@iislee/opencodex 2.31.0 → 2.35.0

package/src/lib/package-tree-integrity.ts

@@ -0,0 +1,101 @@
+import { statSync } from "node:fs";
+
+export interface PackageTreeObservation {
+  readonly device: bigint;
+  readonly inode: bigint;
+  readonly contentTimeNs: bigint;
+  readonly size: bigint;
+}
+
+export type PackageTreeIntegrityStatus =
+  | { readonly ok: true }
+  | { readonly ok: false; readonly reason: "package_tree_replaced" | "package_tree_unreadable" };
+
+export interface PackageTreeIntegrityGuard {
+  status(): PackageTreeIntegrityStatus;
+}
+
+type ObservePackageTree = () => PackageTreeObservation | null;
+type PackageTreeRuntimeInstall = "bun" | "npm" | "source";
+
+const packageManifestUrl = new URL("../../package.json", import.meta.url);
+
+function observePackageManifest(): PackageTreeObservation | null {
+  try {
+    const stat = statSync(packageManifestUrl, { bigint: true });
+    return {
+      device: stat.dev,
+      inode: stat.ino,
+      // mtimeNs, NOT ctimeNs. An inode-change time moves for METADATA writes that
+      // replace nothing: chmod, chown, touch, an editor normalizing permissions, a
+      // backup tool restoring modes. Each of those left device, inode and size
+      // identical, so the comparison below called the manifest "replaced" and every
+      // /v1/* request answered 503 until the process was restarted. Measured on
+      // macOS: chmod alone moved ctimeNs and left mtimeNs untouched.
+      //
+      // mtimeNs still catches every real replacement. An in-place rewrite of the
+      // same byte length moves mtimeNs while inode and size hold; an atomic
+      // install (write-then-rename, which is what a package manager does) changes
+      // the inode as well. Both were measured before this change was made.
+      contentTimeNs: stat.mtimeNs,
+      size: stat.size,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function sameObservation(left: PackageTreeObservation, right: PackageTreeObservation): boolean {
+  return left.device === right.device
+    && left.inode === right.inode
+    && left.contentTimeNs === right.contentTimeNs
+    && left.size === right.size;
+}
+
+/**
+ * How long an `ok` observation is reused before the manifest is stat'd again.
+ *
+ * `status()` runs on `/healthz`, `/readyz` and every `/v1/*` request, so an unthrottled guard
+ * adds a filesystem syscall to the proxy's hot path to detect an event that happens at most
+ * once per install. A replaced tree is not time-critical either: the process is already
+ * serving broken imports, and one more second of that is not worse than a syscall per turn
+ * forever.
+ *
+ * A NEGATIVE result is never cached — once the tree looks wrong, every later request re-checks,
+ * so a repaired install recovers on its own instead of staying refused for a window.
+ */
+const PACKAGE_TREE_RECHECK_MS = 1_000;
+
+export function createPackageTreeIntegrityGuard(
+  observe: ObservePackageTree = observePackageManifest,
+  now: () => number = Date.now,
+): PackageTreeIntegrityGuard {
+  const boot = observe();
+  let lastOkAt: number | null = null;
+  return {
+    status(): PackageTreeIntegrityStatus {
+      const at = now();
+      if (lastOkAt !== null && at - lastOkAt < PACKAGE_TREE_RECHECK_MS) return { ok: true };
+      const current = observe();
+      if (boot === null || current === null) return { ok: false, reason: "package_tree_unreadable" };
+      if (!sameObservation(boot, current)) return { ok: false, reason: "package_tree_replaced" };
+      lastOkAt = at;
+      return { ok: true };
+    },
+  };
+}
+
+/**
+ * Installed packages fail closed when their manifest is replaced under a live process.
+ * A source checkout is different: editing package.json is ordinary development work, and
+ * Bun keeps serving the module snapshot already loaded by this process until the operator
+ * chooses to restart. Fencing every request there makes running dev directly impossible.
+ */
+export function createRuntimePackageTreeIntegrityGuard(
+  installer: PackageTreeRuntimeInstall,
+  observe: ObservePackageTree = observePackageManifest,
+  now: () => number = Date.now,
+): PackageTreeIntegrityGuard {
+  if (installer === "source") return { status: () => ({ ok: true }) };
+  return createPackageTreeIntegrityGuard(observe, now);
+}

package/src/lib/process-control.ts

@@ -1,5 +1,6 @@
 import { execFileSync } from "node:child_process";
-import { loadConfig, readRuntimePort } from "../config";
+import { loadConfig } from "../config";
+import { readRuntimePort } from "../config/process-state";
 import { configuredAdminToken } from "./admin-secrets";
 
 export function isProcessAlive(pid: number): boolean {

package/src/lib/service-secrets.ts

@@ -23,3 +23,18 @@ export function loadServiceTokenFromFile(env: Record<string, string | undefined>
     return null;
   }
 }
+
+/**
+ * Contents of the installed service token file. The launch wrapper always re-exports
+ * this file as OPENCODEX_API_AUTH_TOKEN, so doctor and start must inspect it even
+ * when the calling shell has no data-plane env var.
+ * Returns the token or null — never throws, never logs the value.
+ */
+export function readInstalledServiceToken(): string | null {
+  try {
+    const token = readFileSync(serviceApiTokenFilePath(), "utf8").trim();
+    return token || null;
+  } catch {
+    return null;
+  }
+}

package/src/lib/tool-argument-integers.ts

@@ -59,6 +59,35 @@ function declaresString(schema: SchemaNode): boolean {
   return Array.isArray(type) && type.includes("string");
 }
 
+// Issue #2316: Codex advertises `multi_agent_v1__wait_agent`'s `timeout_ms` as a JSON
+// Schema `number`, but its Rust runtime deserializes the field as `u64` and rejects
+// `120000.0` with "invalid type: floating point `120000.0`, expected u64" before the
+// tool ever runs. The schema lookup is not the problem — the error text comes from
+// Codex's own deserializer, so the call reached it — the problem is that `number`
+// alone never authorizes the integral-float repair below.
+//
+// This allowlist is deliberately one field wide. It names only what has a live
+// reproduction against a real `u64`, because the repair is only unambiguous for a
+// field that cannot legitimately hold a fraction. Generic names (`start`, `end`,
+// `priority`, `port`) would silently rewrite a third-party tool's fractional value,
+// so a new entry needs its own evidence, not a plausible-sounding name.
+//
+// Cursor's sibling `yield_time_ms` (src/adapters/cursor/tool-definitions.ts) is also
+// declared `number`; it is NOT included here because no rejection has been captured
+// against it. It gets its own change when it gets its own reproduction.
+const U64_NUMBER_FIELDS = new Set(["timeout_ms"]);
+
+// Issue #2443 / #2451: Codex Desktop's bare `wait` tool has the same schema/runtime
+// split for `yield_time_ms` and `max_tokens`. Scope these names to that bare tool so a
+// third-party or namespaced tool can still use fractional values legitimately.
+// #2448 allowlisted the hyphenated `yield-time_ms`; live Grok 4.6 calls and the
+// advertised wait schema both use the underscore form, so that name is the one
+// with a captured u64 rejection. Cursor still uses the same underscore name on a
+// namespaced tool; the wait-only map keeps that path byte-identical.
+const U64_NUMBER_FIELDS_BY_TOOL = new Map<string, ReadonlySet<string>>([
+  ["wait", new Set(["yield_time_ms", "max_tokens"])],
+]);
+
 /** True when the node accepts a JSON number (`integer` or `number`), so a numeric
  * value is already schema-valid and must not be rewritten into a string. */
 function declaresNumeric(schema: SchemaNode): boolean {
@@ -118,7 +147,14 @@ interface CoerceResult {
   changed: boolean;
 }
 
-function coerceValue(value: unknown, schema: SchemaNode | undefined, root: SchemaNode, depth: number): CoerceResult {
+function coerceValue(
+  value: unknown,
+  schema: SchemaNode | undefined,
+  root: SchemaNode,
+  depth: number,
+  toolName?: string,
+  propertyName?: string,
+): CoerceResult {
   // A hostile or deeply nested schema must not blow the stack.
   if (depth > 64) return { value, changed: false };
   const resolved = schema ? resolveRef(schema, root, new Set()) : undefined;
@@ -126,7 +162,19 @@ function coerceValue(value: unknown, schema: SchemaNode | undefined, root: Schem
   if (typeof value === "number") {
     if (!resolved) return { value, changed: false };
     const branches = compositionBranches(resolved);
-    const integerDeclared = declaresInteger(resolved) || branches.some(declaresInteger);
+    // #2316: a known Codex-native u64 field counts as integer-declared even when the
+    // advertised schema says `number`, but only when the field really is numeric —
+    // an allowlisted name over a string-typed field is a disagreement, not a repair.
+    const nativeU64Field = propertyName !== undefined
+      && (
+        U64_NUMBER_FIELDS.has(propertyName)
+        || U64_NUMBER_FIELDS_BY_TOOL.get(toolName ?? "")?.has(propertyName) === true
+      );
+    const nativeU64Declared = nativeU64Field
+      && (declaresNumeric(resolved) || branches.some(declaresNumeric));
+    const integerDeclared = declaresInteger(resolved)
+      || branches.some(declaresInteger)
+      || nativeU64Declared;
     if (!integerDeclared && safelyIntegral(value)) {
       // Issue #1938: a bare integer in a string-only field has exactly one faithful
       // string reading. A field that also accepts a numeric type keeps the number.
@@ -148,7 +196,9 @@ function coerceValue(value: unknown, schema: SchemaNode | undefined, root: Schem
     const itemSchema = resolved ? asSchema(resolved.items) : undefined;
     let changed = false;
     const next = value.map(entry => {
-      const result = coerceValue(entry, itemSchema, root, depth + 1);
+      // Array items have no property name of their own; passing the array's key would
+      // let `timeout_ms: [1.5]` inherit the allowlist. Items are judged by schema only.
+      const result = coerceValue(entry, itemSchema, root, depth + 1, toolName);
       if (result.changed) changed = true;
       return result.value;
     });
@@ -164,7 +214,7 @@ function coerceValue(value: unknown, schema: SchemaNode | undefined, root: Schem
   const next: Record<string, unknown> = {};
   for (const [key, entry] of Object.entries(object)) {
     const childSchema = asSchema(properties?.[key]) ?? additional;
-    const result = coerceValue(entry, childSchema, root, depth + 1);
+    const result = coerceValue(entry, childSchema, root, depth + 1, toolName, key);
     if (result.changed) changed = true;
     next[key] = result.value;
   }
@@ -182,6 +232,7 @@ function coerceValue(value: unknown, schema: SchemaNode | undefined, root: Schem
 export function coerceIntegerToolArguments(
   args: string,
   parameters: Record<string, unknown> | undefined,
+  toolName?: string,
 ): string {
   if (!parameters || !args) return args;
   // Cheap reject: a payload with no digit cannot need either repair (integral-float
@@ -196,7 +247,7 @@ export function coerceIntegerToolArguments(
     return args;
   }
   const root = parameters as SchemaNode;
-  const result = coerceValue(parsed, root, root, 0);
+  const result = coerceValue(parsed, root, root, 0, toolName);
   if (!result.changed) return args;
   return JSON.stringify(result.value);
 }

package/src/oauth/callback-server.ts

@@ -276,10 +276,30 @@ export function parseCallbackInput(input: string): { kind: "url" | "query" | "ra
 
   try {
     const url = new URL(value);
+    // Also read the fragment. No provider configured here returns one — every
+    // OAuthCallbackFlow asks for response_type=code without response_mode, so
+    // the parameters land in the query — but a full URL whose parameters sit in
+    // the hash parses as a valid URL with no code, and reading only the query
+    // rejects it as "no authorization code found in input". This is the one
+    // place a fragment-returning provider would land, and the raw branch below
+    // already understands `code#state`.
+    //
+    // The query wins as a WHOLE when it carries the response, and the two
+    // fields are never mixed across collections. Reading `code` and `state`
+    // independently would accept `?state=<expected>#code=<other>` — one
+    // response assembled from two sources — which is exactly the confusion a
+    // state check exists to prevent. An authorization response arrives in one
+    // place; treat it that way.
+    //
+    // Only `code` and `state` are read — never a token. This repo does not
+    // implement the implicit grant and a paste field must not become the place
+    // it appears.
+    const fragment = new URLSearchParams(url.hash.replace(/^#/, ""));
+    const source = url.searchParams.has("code") ? url.searchParams : fragment;
     return {
       kind: "url",
-      code: url.searchParams.get("code") ?? undefined,
-      state: url.searchParams.get("state") ?? undefined,
+      code: source.get("code") ?? undefined,
+      state: source.get("state") ?? undefined,
     };
   } catch {
     // Not a URL - check for query string format

package/src/oauth/cline.ts

@@ -0,0 +1,203 @@
+/**
+ * Cline OAuth — automatic session import from local Cline CLI / VS Code extension
+ * and background WorkOS token refresh.
+ *
+ * Security: tokens are read securely from local config files and refreshed directly
+ * against WorkOS API (api.workos.com). Tokens and credentials are never logged.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { clineConfigPath } from "../clients/config-export";
+import type { OAuthController, OAuthCredentials } from "./types";
+
+export const WORKOS_CLIENT_ID = "client_01K3A541FN8TA3EPPHTD2325AR";
+export const WORKOS_AUTH_URL = "https://api.workos.com/user_management/authenticate";
+const WORKOS_TOKEN_PREFIX = "workos:";
+
+export interface ClineLoginOptions {
+  importLocal?: "fallback" | "off";
+  forceLogin?: boolean;
+}
+
+interface ClineProvidersJson {
+  providers?: {
+    cline?: {
+      settings?: {
+        provider?: string;
+        auth?: {
+          accessToken?: unknown;
+          refreshToken?: unknown;
+          expiresAt?: unknown;
+          accountId?: unknown;
+          metadata?: {
+            userInfo?: {
+              email?: unknown;
+              name?: unknown;
+              subject?: unknown;
+              clineUserId?: unknown;
+            };
+          };
+        };
+      };
+    };
+  };
+}
+
+interface WorkOSAuthResponse {
+  access_token?: unknown;
+  refresh_token?: unknown;
+  user?: {
+    id?: unknown;
+    external_id?: unknown;
+    email?: unknown;
+    first_name?: unknown;
+    last_name?: unknown;
+  };
+  error?: unknown;
+  error_description?: unknown;
+}
+
+function decodeJwtExpiry(token: string): number {
+  try {
+    const rawJwt = token.startsWith(WORKOS_TOKEN_PREFIX) ? token.slice(WORKOS_TOKEN_PREFIX.length) : token;
+    const parts = rawJwt.split(".");
+    if (parts.length === 3 && parts[1]) {
+      const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf-8")) as { exp?: unknown };
+      if (typeof payload.exp === "number" && Number.isFinite(payload.exp)) {
+        return payload.exp * 1000;
+      }
+    }
+  } catch {
+    // fallback below
+  }
+  return Date.now() + 3600_000;
+}
+
+export function formatClineAccessToken(token: string): string {
+  return token.startsWith(WORKOS_TOKEN_PREFIX) ? token : `${WORKOS_TOKEN_PREFIX}${token}`;
+}
+
+export function detectLocalClineToken(): OAuthCredentials | null {
+  const configPath = clineConfigPath();
+  if (!existsSync(configPath)) return null;
+
+  try {
+    const raw = JSON.parse(readFileSync(configPath, "utf8")) as ClineProvidersJson;
+    const auth = raw.providers?.cline?.settings?.auth;
+    if (!auth || typeof auth.accessToken !== "string" || typeof auth.refreshToken !== "string") {
+      return null;
+    }
+
+    const accessToken = auth.accessToken.trim();
+    const refreshToken = auth.refreshToken.trim();
+    if (!accessToken || !refreshToken) return null;
+
+    const expiresAt = typeof auth.expiresAt === "number" && Number.isFinite(auth.expiresAt)
+      ? auth.expiresAt
+      : decodeJwtExpiry(accessToken);
+
+    const userInfo = auth.metadata?.userInfo;
+    const accountId = typeof auth.accountId === "string" && auth.accountId.length > 0
+      ? auth.accountId
+      : typeof userInfo?.clineUserId === "string" && userInfo.clineUserId.length > 0
+        ? userInfo.clineUserId
+        : typeof userInfo?.subject === "string" && userInfo.subject.length > 0
+          ? userInfo.subject
+          : undefined;
+
+    const email = typeof userInfo?.email === "string" && userInfo.email.length > 0
+      ? userInfo.email
+      : undefined;
+
+    return {
+      access: formatClineAccessToken(accessToken),
+      refresh: refreshToken,
+      expires: expiresAt,
+      ...(accountId ? { accountId } : {}),
+      ...(email ? { email } : {}),
+      source: "local-cli",
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function refreshClineToken(
+  refreshToken: string,
+  signal?: AbortSignal,
+  credential?: OAuthCredentials,
+): Promise<OAuthCredentials> {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException("Cline token refresh aborted", "AbortError");
+  }
+
+  const response = await fetch(WORKOS_AUTH_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    },
+    body: JSON.stringify({
+      client_id: WORKOS_CLIENT_ID,
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+    }),
+    signal,
+  });
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`Cline WorkOS token refresh failed (HTTP ${response.status}): ${body || response.statusText}`);
+  }
+
+  const data = (await response.json()) as WorkOSAuthResponse;
+  if (typeof data.access_token !== "string" || !data.access_token) {
+    throw new Error(`Cline token refresh returned no access_token: ${JSON.stringify(data)}`);
+  }
+
+  const nextRefreshToken = typeof data.refresh_token === "string" && data.refresh_token
+    ? data.refresh_token
+    : refreshToken;
+
+  const access = formatClineAccessToken(data.access_token);
+  const expires = decodeJwtExpiry(data.access_token);
+
+  const accountId = typeof data.user?.external_id === "string" && data.user.external_id
+    ? data.user.external_id
+    : typeof data.user?.id === "string" && data.user.id
+      ? data.user.id
+      : credential?.accountId;
+
+  const email = typeof data.user?.email === "string" && data.user.email
+    ? data.user.email
+    : credential?.email;
+
+  return {
+    access,
+    refresh: nextRefreshToken,
+    expires,
+    ...(accountId ? { accountId } : {}),
+    ...(email ? { email } : {}),
+  };
+}
+
+export async function loginCline(
+  ctrl?: OAuthController,
+  options: ClineLoginOptions = {},
+): Promise<OAuthCredentials> {
+  if (options.importLocal !== "off") {
+    ctrl?.onProgress?.("Checking local Cline CLI and VS Code installation for active session...");
+    const local = detectLocalClineToken();
+    if (local) {
+      if (local.expires <= Date.now() + 60_000) {
+        ctrl?.onProgress?.("Local Cline session token expired; refreshing via WorkOS...");
+        return await refreshClineToken(local.refresh, ctrl?.signal, local);
+      }
+      ctrl?.onProgress?.("Imported active Cline session successfully.");
+      return local;
+    }
+  }
+
+  throw new Error(
+    "No local Cline session found. Please log in to Cline via the VS Code extension or Cline CLI (`cline`), then re-run `ocx login cline` to import your account.",
+  );
+}