@bitkyc08/opencodex 2.68.0 → 2.69.0

package/src/client/link-relay-transport.ts

@@ -0,0 +1,184 @@
+import { Agent, request, type IncomingMessage } from "node:http";
+import type { Socket } from "node:net";
+import { Readable } from "node:stream";
+import { createBrotliDecompress, createGunzip, createInflate } from "node:zlib";
+import { serviceApiTokenFingerprint } from "../lib/service-secrets";
+import { clearableDeadline } from "../lib/abort";
+import {
+  LINK_RELAY_AUTH_PATH, LINK_RELAY_AUTH_TIMEOUT_MS, LINK_RELAY_AUTH_VERSION,
+  LINK_RELAY_SESSION_HEADER, linkRelayChallenge, linkRelayProofMatches,
+} from "../link/relay-auth";
+
+export interface BoundLinkRelayTarget {
+  tunnelPort: number;
+  admissionKey: string;
+  linkId?: string;
+  apiKeyId?: string;
+}
+
+export class LinkRelayAuthenticationError extends Error {
+  constructor(readonly unrecognized = false) {
+    super(unrecognized ? "link relay authentication unavailable; upgrade the Home and Child or re-link"
+      : "link relay authentication failed");
+    this.name = "LinkRelayAuthenticationError";
+  }
+}
+
+/** One physical connection, ever. A closed keep-alive socket cannot trigger a silent reconnect. */
+class SingleConnectionAgent extends Agent {
+  socket: Socket | undefined;
+  private opened = false;
+  private closeFlight?: Promise<void>;
+  /** Drain the socket close event before the request reports a terminal outcome. */
+  close(): Promise<void> {
+    if (this.closeFlight) return this.closeFlight;
+    const socket = this.socket;
+    this.closeFlight = !socket || socket.closed ? Promise.resolve()
+      : new Promise<void>(resolve => { socket.once("close", () => resolve()); });
+    this.destroy();
+    return this.closeFlight;
+  }
+  override createConnection(...[options, callback]: Parameters<Agent["createConnection"]>): ReturnType<Agent["createConnection"]> {
+    if (this.opened) {
+      if (!callback) throw new LinkRelayAuthenticationError();
+      callback(new LinkRelayAuthenticationError(), this.socket!);
+      return undefined;
+    }
+    this.opened = true;
+    this.socket = super.createConnection(options, callback) as Socket;
+    return this.socket;
+  }
+}
+
+function requestOnConnection(
+  url: URL, init: RequestInit, agent: SingleConnectionAgent, authenticatedSocket?: Socket,
+): Promise<IncomingMessage> {
+  return new Promise((resolve, reject) => {
+    const headers = Object.fromEntries(new Headers(init.headers));
+    // No implicit decompression negotiation; handle an explicitly encoded response below anyway.
+    headers["accept-encoding"] = "identity";
+    const outgoing = request(url, {
+      method: init.method ?? "GET", headers, agent, signal: init.signal ?? undefined,
+      maxHeaderSize: 64 * 1024,
+    }, resolve);
+    outgoing.on("error", reject);
+    outgoing.on("upgrade", (_response, socket) => { socket.destroy(); reject(new LinkRelayAuthenticationError()); });
+    outgoing.on("socket", socket => {
+      if (authenticatedSocket && socket !== authenticatedSocket) outgoing.destroy(new LinkRelayAuthenticationError());
+    });
+    void (async () => {
+      const body = init.body;
+      if (body instanceof ReadableStream) {
+        const reader = body.getReader();
+        const abort = () => { void reader.cancel(init.signal?.reason).catch(() => {}); };
+        init.signal?.addEventListener("abort", abort, { once: true });
+        outgoing.once("close", abort);
+        try {
+          for (;;) {
+            init.signal?.throwIfAborted();
+            const next = await reader.read();
+            if (next.done) break;
+            // Await the write callback: upstream backpressure never buffers the whole upload.
+            await new Promise<void>((done, fail) => outgoing.write(next.value,
+              error => error ? fail(error) : done()));
+          }
+        } finally {
+          init.signal?.removeEventListener("abort", abort);
+          outgoing.removeListener("close", abort);
+          try { await reader.cancel(); } catch { /* preserve the upload outcome */ }
+          reader.releaseLock();
+        }
+      } else if (body != null) {
+        if (typeof body === "string" || body instanceof Uint8Array) outgoing.write(body);
+        else throw new TypeError("unsupported link relay body");
+      }
+      outgoing.end();
+    })().catch(error => { outgoing.destroy(error instanceof Error ? error : new Error("link upload failed")); reject(error); });
+  });
+}
+
+function responseHeaders(incoming: IncomingMessage): Headers {
+  const headers = new Headers();
+  for (let i = 0; i < incoming.rawHeaders.length; i += 2) {
+    headers.append(incoming.rawHeaders[i]!, incoming.rawHeaders[i + 1]!);
+  }
+  return headers;
+}
+
+/** Node HTTP compatibility is confined here; the relay continues to expose a Web Response/stream. */
+async function responseOnConnection(incoming: IncomingMessage, agent: SingleConnectionAgent, method: string): Promise<Response> {
+  const headers = responseHeaders(incoming);
+  const status = incoming.statusCode ?? 502;
+  if (method === "HEAD" || status === 204 || status === 205 || status === 304) {
+    for await (const _chunk of incoming) { /* drain a header-only response */ }
+    await agent.close();
+    return new Response(null, { status, headers });
+  }
+  let source: Readable = incoming;
+  const encoding = headers.get("content-encoding")?.trim().toLowerCase();
+  const decoder = encoding === "gzip" ? createGunzip() : encoding === "deflate" ? createInflate()
+    : encoding === "br" ? createBrotliDecompress() : undefined;
+  if (encoding && encoding !== "identity" && !decoder) {
+    throw new Error("unsupported link response encoding");
+  }
+  if (decoder) {
+    incoming.on("error", error => decoder.destroy(error));
+    source = incoming.pipe(decoder);
+  }
+  const reader = (Readable.toWeb(source) as unknown as ReadableStream<Uint8Array>).getReader();
+  let finished = false;
+  const finish = async () => {
+    if (finished) return agent.close();
+    finished = true;
+    if (source !== incoming) source.destroy();
+    await agent.close();
+    try { reader.releaseLock(); } catch { /* a cancelled read may still be settling */ }
+  };
+  return new Response(new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      try {
+        const next = await reader.read();
+        if (next.done) { await finish(); controller.close(); }
+        else controller.enqueue(next.value);
+      } catch (error) { await finish(); controller.error(error); }
+    },
+    async cancel(reason) {
+      try { await reader.cancel(reason); } finally { await finish(); }
+    },
+  }, { highWaterMark: 0 }), { status, headers });
+}
+
+/** Authenticate and stream one request on the SAME socket; never fall back to an ordinary fetch. */
+export async function fetchBoundLinkRelay(target: BoundLinkRelayTarget, destination: string, init: RequestInit): Promise<Response> {
+  if (!target.linkId || !target.apiKeyId) throw new LinkRelayAuthenticationError();
+  const url = new URL(destination);
+  if (url.origin !== `http://127.0.0.1:${target.tunnelPort}`) throw new LinkRelayAuthenticationError();
+  const challenge = linkRelayChallenge(serviceApiTokenFingerprint(target.admissionKey), target.apiKeyId, target.linkId);
+  const probe = new URL(LINK_RELAY_AUTH_PATH, url);
+  probe.search = new URLSearchParams({ version: LINK_RELAY_AUTH_VERSION, key: target.apiKeyId,
+    link: target.linkId, nonce: challenge.nonce, proof: challenge.caller }).toString();
+  const agent = new SingleConnectionAgent({ keepAlive: true, maxSockets: 1, maxFreeSockets: 1 });
+  const deadline = clearableDeadline(LINK_RELAY_AUTH_TIMEOUT_MS, init.signal ?? undefined);
+  try {
+    const response = await requestOnConnection(probe, { method: "GET", signal: deadline.signal }, agent);
+    const socket = agent.socket;
+    const proof = response.headers["x-opencodex-link-proof"];
+    if (response.statusCode !== 204 || typeof proof !== "string" || !linkRelayProofMatches(proof, challenge.expected)) {
+      throw new LinkRelayAuthenticationError(response.statusCode === 404);
+    }
+    // Drain the credential-free response before the Agent can reuse its socket.
+    for await (const chunk of response) {
+      if (chunk.length) throw new LinkRelayAuthenticationError();
+    }
+    deadline.clear();
+    init.signal?.throwIfAborted();
+    if (!socket || socket.destroyed || socket !== agent.socket) throw new LinkRelayAuthenticationError();
+    const headers = new Headers(init.headers);
+    headers.set(LINK_RELAY_SESSION_HEADER, challenge.nonce);
+    const incoming = await requestOnConnection(url, { ...init, headers }, agent, socket);
+    return await responseOnConnection(incoming, agent, init.method ?? "GET");
+  } catch (error) {
+    await agent.close();
+    throw error;
+  } finally { deadline.clear(); }
+}

package/src/client/link-relay.ts

@@ -1,3 +1,4 @@
+import { fetchBoundLinkRelay, LinkRelayAuthenticationError } from "./link-relay-transport";
 import {
   boundedRelayResponseStream,
   filterRelayHeaders,
@@ -10,6 +11,8 @@ import { resolveInboundBodyLimitBytes } from "../server/request-decompress";
 
 export interface LinkRelayTarget {
   tunnelPort: number;
+  linkId?: string;
+  apiKeyId?: string;
   /**
    * The stored link key. The relay sends it in place of every caller credential, so the Home
    * admits the request as this link and serves it with its own accounts.
@@ -42,8 +45,8 @@ export interface LinkTunnelGate {
 /**
  * The gate for a Home-initiated link. The Home runs `ssh -R` and owns the forward, so the Child
  * has no tunnel supervisor and no local SSH process whose socket it could prove. This gate keeps
- * the 2.67.0 behaviour for that link only: forward to the tunnel port without an ownership proof,
- * never hold, and answer 503 when the connection is refused. Child-initiated links keep their
+ * the absence of local process ownership proof for that link only. The data transport still
+ * authenticates its physical connection; this gate never holds a reconnect. Child-initiated links keep their
  * supervisor, and a relay with no gate at all still refuses every request.
  */
 export const HOME_INITIATED_LINK_TUNNEL: LinkTunnelGate = {
@@ -53,6 +56,7 @@ export const HOME_INITIATED_LINK_TUNNEL: LinkTunnelGate = {
 };
 
 export interface LinkRelayDeps {
+  /** Trusted complete-send test seam. Production always uses the connection-bound transport. */
   fetchImpl?: typeof fetch;
   clock?: LinkRelayClock;
   /** Time allowed for the Home's response headers; a caller abort still ends the wait sooner. */
@@ -93,7 +97,10 @@ const RESPONSE_OMITTED_HEADERS = new Set(["content-encoding", "content-length"])
  * Caller credentials never cross the tunnel. The Child's own ChatGPT or Anthropic credential
  * stays on the Child, and the Home sees exactly one admission: the link key.
  */
-const CALLER_CREDENTIAL_HEADERS = ["authorization", "x-api-key", "x-opencodex-api-key", "chatgpt-account-id", "cookie"] as const;
+const CALLER_CREDENTIAL_HEADERS = [
+  "authorization", "api-key", "x-api-key", "x-goog-api-key", "x-opencodex-api-key",
+  "chatgpt-account-id", "cookie",
+] as const;
 
 function jsonError(status: number, error: string, retry = false): Response {
   const headers = retry ? { "Retry-After": String(LINK_RELAY_RETRY_AFTER_SECONDS) } : undefined;
@@ -376,8 +383,13 @@ export async function relayLinkDataRequest(
         signal: relayAbort.signal,
         ...(body ? { body, duplex: "half" } : {}),
       };
-      upstream = await (deps.fetchImpl ?? fetch)(destination, init);
+      upstream = await (deps.fetchImpl ? deps.fetchImpl(destination, init) : fetchBoundLinkRelay(target, destination, init));
     } catch (error) {
+      if (error instanceof LinkRelayAuthenticationError) {
+        cleanup();
+        try { await body?.cancel(); } catch { /* an upload might already be drained */ }
+        return jsonError(503, error.message, true);
+      }
       if (bodyOverflow) {
         cleanup();
         return jsonError(413, "link relay request body too large");

package/src/client/machine-listener.ts

@@ -116,6 +116,8 @@ export function startMachineListener(
   const linkIngress: LinkIngress | null = linkMode
     ? {
       tunnelPort: connection.link!.tunnelPort,
+      linkId: connection.link!.linkId,
+      apiKeyId: connection.apiKeyId,
       policy: requestPolicyView(config, "127.0.0.1"),
       linkKey: deps.linkKeySource ?? createLinkKeySource(connection.tokenFingerprint, deps.linkKey),
       relay: { fetchImpl: deps.fetchImpl, bodyLimitBytes: inboundBodyLimit, tunnel: deps.linkTunnel, ...deps.linkRelay },

package/src/clients/config-export/constants.ts

@@ -14,6 +14,14 @@ export const OPENCODE_CONFIG_SCHEMA = "https://opencode.ai/config.json";
  */
 export const OPENCODE_API_KEY_ENV = "OPENCODEX_OPENCODE_API_KEY";
 
+/**
+ * Env var carrying the proxy admission key to Kilo. Independent of OpenCode's
+ * so the two clients can keep distinct credentials.
+ */
+export const KILO_API_KEY_ENV = "OPENCODEX_KILO_API_KEY";
+export const KILO_API_KEY_ENV_REF = `{env:${KILO_API_KEY_ENV}}`;
+export const KILO_CONFIG_SCHEMA = "https://app.kilo.ai/config.json";
+
 /** Env reference shared by apiKey and the dedicated proxy admission header. */
 export const OPENCODE_API_KEY_ENV_REF = `{env:${OPENCODE_API_KEY_ENV}}`;
 

package/src/clients/config-export/contracts.ts

@@ -105,7 +105,9 @@ export type ExportClientId =
   | "aside"
   | "raycast"
   | "omo"
-  | "cline";
+  | "cline"
+  | "kilo"
+  | "droid";
 
 export interface ExportClientSpec {
   id: ExportClientId;
@@ -146,6 +148,16 @@ export interface ExportClientSpec {
    * reasoning as the Grok managed block's non-loopback refusal.
    */
   loopbackOnly: boolean;
+  /**
+   * True when the destination file may carry comments and trailing commas
+   * even though `format` is "json" and serialization stays pretty JSON.
+   *
+   * Parse tolerates them by canonicalizing the text before the rewrite-safety
+   * scan (Kilo's kilo.jsonc). A spec flag rather than a client-name branch:
+   * the next OpenCode-family client opts in here instead of growing another
+   * `clientId ===` check at every parse site.
+   */
+  jsonc?: boolean;
 }
 
 export interface PiModelEntry {

package/src/clients/config-export/droid.ts

@@ -0,0 +1,71 @@
+import { win32, join } from "node:path";
+import { homedir } from "node:os";
+import { exportPresentationLabel } from "../model-presentation";
+import type { ExportContext, ManagedContribution, OpencodeLaunchEnv } from "./contracts";
+import { normalizeExportModels } from "./model-metadata";
+import { formatSelectorConjunction } from "../../integrations/merge";
+
+/** Factory personal settings: https://docs.factory.ai/model-independence/byok */
+export interface DroidModelEntry {
+  model: string;
+  displayName: string;
+  baseUrl: string;
+  provider: "generic-chat-completion-api";
+  noImageSupport: boolean;
+}
+
+export interface DroidGeneratedConfig { customModels: DroidModelEntry[] }
+
+const isWindowsHome = (home: string) => /^[A-Za-z]:[\\/]|^\\\\/.test(home);
+
+export function droidHomeDir(_env: OpencodeLaunchEnv = process.env, home: string = homedir()): string {
+  return isWindowsHome(home) ? win32.join(home, ".factory") : join(home, ".factory");
+}
+
+export function droidConfigPath(env: OpencodeLaunchEnv = process.env, home: string = homedir()): string {
+  const root = droidHomeDir(env, home);
+  return isWindowsHome(root) ? win32.join(root, "settings.json") : join(root, "settings.json");
+}
+
+function buildDroidRows(ctx: ExportContext): Array<{ row: DroidModelEntry; selector: string }> {
+  const rows: Array<{ row: DroidModelEntry; selector: string }> = [];
+  for (const model of normalizeExportModels(ctx.models)) {
+    const displayName = `OpenCodex: ${exportPresentationLabel(model)}`;
+    const selector = formatSelectorConjunction([
+      { field: "model", value: model.namespaced },
+      { field: "displayName", value: displayName },
+    ]);
+    // A row we cannot address safely cannot be managed or exported.
+    if (!selector) continue;
+    rows.push({ selector, row: {
+      model: model.namespaced,
+      displayName,
+      baseUrl: ctx.baseUrl,
+      provider: "generic-chat-completion-api",
+      noImageSupport: !model.inputModalities?.includes("image"),
+    } });
+  }
+  return rows;
+}
+
+export function buildDroidClientConfig(ctx: ExportContext): DroidGeneratedConfig {
+  const rows = buildDroidRows(ctx);
+  if (ctx.models.length > 0 && rows.length === 0) {
+    throw new Error("Factory Droid has no addressable models in the selected catalog");
+  }
+  return { customModels: rows.map(({ row }) => row) };
+}
+
+export function summarizeDroid(document: unknown) {
+  const rows = (document as DroidGeneratedConfig | undefined)?.customModels;
+  const count = Array.isArray(rows) ? rows.length : 0;
+  // Droid's personal schema has no context-window field.
+  return { modelCount: count, modelsWithoutLimits: count };
+}
+
+export function buildDroidContribution(ctx: ExportContext): ManagedContribution {
+  return {
+    clientId: "droid",
+    fragments: buildDroidRows(ctx).map(({ row, selector }) => ({ path: ["customModels", selector], value: row })),
+  };
+}

package/src/clients/config-export/kilo.ts

@@ -0,0 +1,116 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, win32 } from "node:path";
+import type { ExportContext, ManagedContribution, OpencodeLaunchEnv } from "./contracts";
+import {
+  KILO_API_KEY_ENV_REF,
+  KILO_CONFIG_SCHEMA,
+  OPENCODE_PROVIDER_BLOCK_DEFAULT_CONFIG,
+  OPENCODE_PROVIDER_ID,
+} from "./constants";
+import {
+  authoritativeContextWindow,
+  exportModelLabel,
+  normalizeExportModels,
+  opencodeModelCapabilities,
+  outputBudgetFor,
+  proxyAdmissionHeaders,
+  singleFragment,
+} from "./model-metadata";
+
+export const KILO_CONFIG_CANDIDATES = [
+  "kilo.jsonc",
+  "kilo.json",
+  "opencode.jsonc",
+  "opencode.json",
+  "config.json",
+] as const;
+
+export interface KiloModelEntry {
+  name: string;
+  limit?: { context: number; output: number };
+  attachment?: boolean;
+  modalities?: { input: string[]; output: string[] };
+}
+
+export interface KiloProviderBlock {
+  npm: string;
+  name: string;
+  options: {
+    baseURL: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+  };
+  models: Record<string, KiloModelEntry>;
+}
+
+export interface KiloGeneratedConfig {
+  $schema: string;
+  provider: Record<string, KiloProviderBlock>;
+}
+
+function windowsPath(path: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(path) || path.startsWith("\\\\");
+}
+
+export function kiloHomeDir(env: OpencodeLaunchEnv = process.env, home: string = homedir()): string {
+  const override = env.XDG_CONFIG_HOME || undefined;
+  const pathJoin = windowsPath(override ?? home) ? win32.join : join;
+  const xdg = override ?? pathJoin(home, ".config");
+  return pathJoin(xdg, "kilo");
+}
+
+export function kiloCandidatePath(dir: string, name: string): string {
+  return (windowsPath(dir) ? win32.join : join)(dir, name);
+}
+
+export function kiloConfigPath(env: OpencodeLaunchEnv = process.env, home: string = homedir()): string {
+  const dir = kiloHomeDir(env, home);
+  for (const name of KILO_CONFIG_CANDIDATES) {
+    const path = kiloCandidatePath(dir, name);
+    if (existsSync(path)) return path;
+  }
+  return kiloCandidatePath(dir, "kilo.jsonc");
+}
+
+function kiloProviderBlock(ctx: ExportContext): KiloProviderBlock {
+  const config = ctx.config ?? OPENCODE_PROVIDER_BLOCK_DEFAULT_CONFIG;
+  const models: Record<string, KiloModelEntry> = {};
+  for (const model of normalizeExportModels(ctx.models)) {
+    const entry: KiloModelEntry = { name: exportModelLabel(model) };
+    const context = authoritativeContextWindow(model.contextWindow);
+    if (context !== undefined) {
+      entry.limit = { context, output: outputBudgetFor(context, model) };
+    }
+    const capabilities = opencodeModelCapabilities(model.inputModalities);
+    if (capabilities) {
+      entry.attachment = capabilities.attachment;
+      entry.modalities = capabilities.modalities;
+    }
+    models[model.namespaced] = entry;
+  }
+  const headers = proxyAdmissionHeaders(config, KILO_API_KEY_ENV_REF);
+  return {
+    npm: "@ai-sdk/openai-compatible",
+    name: "OpenCodex",
+    options: headers ? { baseURL: ctx.baseUrl, headers } : { baseURL: ctx.baseUrl, apiKey: KILO_API_KEY_ENV_REF },
+    models,
+  };
+}
+
+export function buildKiloClientConfig(ctx: ExportContext): KiloGeneratedConfig {
+  return {
+    $schema: KILO_CONFIG_SCHEMA,
+    provider: { [OPENCODE_PROVIDER_ID]: kiloProviderBlock(ctx) },
+  };
+}
+
+export function summarizeKilo(document: unknown): { modelCount: number; modelsWithoutLimits: number } {
+  const models = Object.values((document as KiloGeneratedConfig | undefined)?.provider?.[OPENCODE_PROVIDER_ID]?.models ?? {});
+  return { modelCount: models.length, modelsWithoutLimits: models.filter(model => !model.limit).length };
+}
+
+export function buildKiloContribution(ctx: ExportContext): ManagedContribution {
+  const doc = buildKiloClientConfig(ctx);
+  return singleFragment("kilo", ["provider", OPENCODE_PROVIDER_ID], doc.provider[OPENCODE_PROVIDER_ID]);
+}

package/src/clients/config-export.ts

@@ -31,7 +31,7 @@ import type { OcxConfig } from "../types";
 
 export type { ConfigFormat } from "../integrations/serialize";
 export type { ManagedFragment, ManagedContribution, BuildContribution, OpencodeLaunchEnv, OpencodeCatalogModel, ExportModel, ExportContext, ExportClientId, ExportClientSpec, PiModelEntry } from "./config-export/contracts";
-export { OPENCODE_PROVIDER_ID, OPENCODE_CONFIG_SCHEMA, OPENCODE_API_KEY_ENV, OPENCODE_API_KEY_ENV_REF, HERMES_API_KEY_ENV, HERMES_API_KEY_ENV_REF, OPENCLAW_API_KEY_ENV, OPENCLAW_API_KEY_ENV_REF, LOOPBACK_API_KEY_PLACEHOLDER, GAJAE_API_KEY_ENV, SCHEMA_REQUIRED_OUTPUT_BUDGET, OPENCODE_PROVIDER_BLOCK_DEFAULT_CONFIG } from "./config-export/constants";
+export { OPENCODE_PROVIDER_ID, OPENCODE_CONFIG_SCHEMA, OPENCODE_API_KEY_ENV, OPENCODE_API_KEY_ENV_REF, KILO_API_KEY_ENV, KILO_API_KEY_ENV_REF, KILO_CONFIG_SCHEMA, HERMES_API_KEY_ENV, HERMES_API_KEY_ENV_REF, OPENCLAW_API_KEY_ENV, OPENCLAW_API_KEY_ENV_REF, LOOPBACK_API_KEY_PLACEHOLDER, GAJAE_API_KEY_ENV, SCHEMA_REQUIRED_OUTPUT_BUDGET, OPENCODE_PROVIDER_BLOCK_DEFAULT_CONFIG } from "./config-export/constants";
 export { normalizeExportModels } from "./config-export/model-metadata";
 export type { OmpModelEntry, OmpProviderBlock, OmpGeneratedConfig } from "./config-export/omp";
 export type { ZcodeModelEntry, ZcodeProviderBlock, ZcodeGeneratedConfig } from "./config-export/zcode";
@@ -51,9 +51,11 @@ export type { DshReasoningEffort, DshWireReasoningEffort, DshModelEntry, DshProv
 export type { McodeProviderBlock, McodeModelEntry, McodeGeneratedConfig } from "./config-export/mcode";
 export type { RaycastAbility, RaycastAbilityName, RaycastModelEntry, RaycastProviderEntry, RaycastGeneratedConfig } from "./config-export/raycast";
 export { buildRaycastClientConfig, summarizeRaycast, buildRaycastContribution } from "./config-export/raycast";
+export { droidHomeDir, droidConfigPath, buildDroidClientConfig, summarizeDroid, buildDroidContribution } from "./config-export/droid";
+export type { DroidModelEntry, DroidGeneratedConfig } from "./config-export/droid";
 
 import type { OpencodeLaunchEnv, OpencodeCatalogModel, ExportContext, PiModelEntry, ManagedContribution, ManagedFragment, ExportClientId, ExportClientSpec } from "./config-export/contracts";
-import { OPENCODE_API_KEY_ENV_REF, OPENCODE_PROVIDER_BLOCK_DEFAULT_CONFIG, OPENCODE_CONFIG_SCHEMA, OPENCODE_PROVIDER_ID, PI_API_DIALECT, LOOPBACK_API_KEY_PLACEHOLDER, HERMES_API_KEY_ENV_REF, OPENCLAW_API_KEY_ENV_REF, OPENCODE_API_KEY_ENV, HERMES_API_KEY_ENV, OPENCLAW_API_KEY_ENV } from "./config-export/constants";
+import { OPENCODE_API_KEY_ENV_REF, OPENCODE_PROVIDER_BLOCK_DEFAULT_CONFIG, OPENCODE_CONFIG_SCHEMA, OPENCODE_PROVIDER_ID, PI_API_DIALECT, LOOPBACK_API_KEY_PLACEHOLDER, HERMES_API_KEY_ENV_REF, OPENCLAW_API_KEY_ENV_REF, OPENCODE_API_KEY_ENV, HERMES_API_KEY_ENV, OPENCLAW_API_KEY_ENV, KILO_API_KEY_ENV } from "./config-export/constants";
 import { exportModelLabel, authoritativeContextWindow, outputBudgetFor, normalizeExportModels, inputModalitiesForClient, opencodeModelCapabilities, proxyAdmissionHeaders, singleFragment } from "./config-export/model-metadata";
 import { buildOmpClientConfig, summarizeOmp, buildOmpContribution } from "./config-export/omp";
 import { buildDshClientConfig, summarizeDsh, buildDshContribution } from "./config-export/dsh";
@@ -61,6 +63,10 @@ import { buildMcodeClientConfig, summarizeMcode, buildMcodeContribution } from "
 import { buildZcodeClientConfig, summarizeZcode, buildZcodeContribution } from "./config-export/zcode";
 import { buildClineClientConfig, summarizeCline, buildClineContribution } from "./config-export/cline";
 import { buildRaycastClientConfig, summarizeRaycast, buildRaycastContribution } from "./config-export/raycast";
+import { buildKiloClientConfig, summarizeKilo, buildKiloContribution, kiloConfigPath } from "./config-export/kilo";
+export { kiloConfigPath, kiloHomeDir, kiloCandidatePath, KILO_CONFIG_CANDIDATES } from "./config-export/kilo";
+export type { KiloGeneratedConfig, KiloProviderBlock, KiloModelEntry } from "./config-export/kilo";
+import { droidConfigPath, buildDroidClientConfig, summarizeDroid, buildDroidContribution } from "./config-export/droid";
 
 
 
@@ -1588,6 +1594,31 @@ export const EXPORT_CLIENTS: Record<ExportClientId, ExportClientSpec> = {
     buildContribution: buildClineContribution,
     loopbackOnly: true,
   },
+  kilo: {
+    id: "kilo",
+    filename: "kilo.jsonc",
+    destination: env => kiloConfigPath(env),
+    apiKeyEnv: KILO_API_KEY_ENV,
+    exportHint: `export ${KILO_API_KEY_ENV}=<your key>`,
+    build: buildKiloClientConfig,
+    format: "json",
+    summarize: summarizeKilo,
+    buildContribution: buildKiloContribution,
+    loopbackOnly: false,
+    jsonc: true,
+  },
+  droid: {
+    id: "droid",
+    filename: "factory-settings.json",
+    destination: env => droidConfigPath(env),
+    apiKeyEnv: "",
+    exportHint: "Factory Droid reads keyless loopback custom models from settings.json. Select one with /model.",
+    build: buildDroidClientConfig,
+    format: "json",
+    summarize: summarizeDroid,
+    buildContribution: buildDroidContribution,
+    loopbackOnly: true,
+  },
 };
 
 export const EXPORT_CLIENT_IDS: readonly ExportClientId[] = Object.keys(EXPORT_CLIENTS) as ExportClientId[];

package/src/codex/auth-api/routes.ts

@@ -213,7 +213,7 @@ export async function handleCodexAuthAPI(
     if (body.accountId === MAIN_CODEX_ACCOUNT_ID && hasLegacyMainCodexPoolAccount(runtimeConfig.codexAccounts)) {
       return jsonResponse({ error: "Remove the legacy __main__ pool row before selecting the Desktop account" }, 409);
     }
-    if (isCodexAccountPaused(runtimeConfig, targetAccountId)) {
+    if (body.accountId != null && isCodexAccountPaused(runtimeConfig, targetAccountId)) {
       return jsonResponse({ error: "Account is paused" }, 409);
     }
     if (body.accountId != null && body.accountId !== MAIN_CODEX_ACCOUNT_ID) {

package/src/codex/catalog/access-programs.ts

@@ -6,7 +6,7 @@ import { trustedAccountBoundNativeCatalogSlug } from "./account-models";
 import { isNativeAliasCatalogEntry, SUPPORTED_NATIVE_OPENAI_SLUGS } from "./metadata";
 import type { RawEntry } from "./parsing";
 
-/** Project authenticated account metadata onto native rows only. */
+/** Project access programs per native account, and availability prompts only onto bare main rows. */
 export function applyNativeAccessPrograms(
   entries: RawEntry[],
   snapshot: CodexModelEntitlementSnapshot,
@@ -15,9 +15,13 @@ export function applyNativeAccessPrograms(
   for (const entry of entries) {
     // A combo may deliberately claim a bare native slug. It is still a routed combo row,
     // so the matching native Codex roster must not project its access programs onto it.
-    if (isNativeAliasCatalogEntry(entry)) continue;
+    if (isNativeAliasCatalogEntry(entry)) {
+      delete entry.availability_nux;
+      continue;
+    }
     if (entry.owned_by === COMBO_NAMESPACE) {
       delete entry.available_access_programs;
+      delete entry.availability_nux;
       continue;
     }
     const accountBoundSlug = trustedAccountBoundNativeCatalogSlug(entry);
@@ -25,10 +29,18 @@ export function applyNativeAccessPrograms(
       && SUPPORTED_NATIVE_OPENAI_SLUGS.has(entry.slug) ? entry.slug : undefined;
     const slug = accountBoundSlug ?? bareSlug;
     if (!slug) continue;
+    if (accountBoundSlug) delete entry.availability_nux;
     const selector = accountBoundSlug && typeof entry.slug === "string"
       ? entry.slug.slice(0, entry.slug.indexOf("/")) : undefined;
     const target = selector === undefined ? MAIN_CODEX_ACCOUNT_ID : accountTargets.get(selector);
     const accountId = target && isMainCodexAccountTarget(target) ? MAIN_CODEX_ACCOUNT_ID : target;
+    if (bareSlug) {
+      entry.availability_nux = accountId === MAIN_CODEX_ACCOUNT_ID
+        && snapshot.confirmedAccountIds.has(accountId)
+        && snapshot.modelsByAccount.get(accountId)?.has(slug)
+        ? snapshot.availabilityNuxByAccount?.get(accountId)?.get(slug) ?? null
+        : null;
+    }
     if (!accountId) {
       delete entry.available_access_programs;
       continue;

package/src/codex/catalog/provider-models.ts

@@ -231,7 +231,7 @@ export async function fetchProviderModelsWithAuth(
       // KIRO_OBSERVED_CATALOG_MAX of them. Every observed id still informs routing preference.
       let observedAdded = 0;
       for (const account of getAccountSet("kiro")?.accounts ?? []) {
-        if (account.needsReauth === true) continue;
+        if (account.needsReauth === true || account.paused === true) continue;
         for (const row of readKiroAccountModels(account) ?? []) {
           if (observedAdded >= KIRO_OBSERVED_CATALOG_MAX) break;
           if (!KIRO_PUBLISHABLE_MODEL_ID.test(row.modelId) || ids.includes(row.modelId)) continue;