@semanticist14/clco 0.1.0

package/src/config.ts

@@ -0,0 +1,164 @@
+// Durable auth storage: ~/.config/clco/auth.json (mode 600).
+// Writes go through a temp file + rename so a crash or a pre-existing
+// symlink/permission can never leave the token readable or half-written.
+
+import {
+  chmod,
+  mkdir,
+  readFile,
+  rename,
+  rm,
+  unlink,
+  writeFile,
+} from "node:fs/promises"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+export interface AuthStore {
+  github_token: string
+  login?: string
+}
+
+// Overridable so tests can exercise the real read/merge/write path without
+// writing into the user's live install.
+let configDir: string | null = null
+
+export function setConfigDir(dir: string | null): void {
+  configDir = dir
+}
+
+function authDir(): string {
+  return configDir ?? join(homedir(), ".config", "clco")
+}
+
+function authPath(): string {
+  return join(authDir(), "auth.json")
+}
+
+// One-time migration from the pre-rename config directory.
+let migrated = false
+async function migrateFromClcopilot(): Promise<void> {
+  if (migrated) return
+  migrated = true
+  const legacyDir = join(homedir(), ".config", "clcopilot")
+  await mkdir(authDir(), { recursive: true, mode: 0o700 }).catch(() => {})
+  await chmod(authDir(), 0o700).catch(() => {})
+  for (const name of ["auth.json", "prefs.json"]) {
+    const target = join(authDir(), name)
+    try {
+      await readFile(target, "utf8")
+      continue // already present in the new location
+    } catch {
+      // not migrated yet
+    }
+    try {
+      const data = await readFile(join(legacyDir, name), "utf8")
+      await writeFile(target, data, { mode: 0o600 })
+    } catch {
+      // nothing to migrate
+    }
+  }
+}
+
+export async function loadAuth(): Promise<AuthStore | null> {
+  await migrateFromClcopilot()
+  try {
+    return JSON.parse(await readFile(authPath(), "utf8")) as AuthStore
+  } catch {
+    return null
+  }
+}
+
+export async function saveAuth(auth: AuthStore): Promise<void> {
+  await mkdir(authDir(), { recursive: true })
+  await chmod(authDir(), 0o700).catch(() => {})
+  const tmp = join(authDir(), `.auth.${process.pid}.tmp`)
+  const handle = await openExclusive(tmp)
+  try {
+    await handle.writeFile(JSON.stringify(auth, null, 2) + "\n")
+    await handle.close()
+    await rename(tmp, authPath())
+    await chmod(authPath(), 0o600).catch(() => {})
+  } catch (err) {
+    await handle.close().catch(() => {})
+    await unlink(tmp).catch(() => {})
+    throw err
+  }
+}
+
+// "wx": fail if the temp file already exists (never truncate through a
+// symlink); creation mode 0600.
+async function openExclusive(path: string) {
+  const { open } = await import("node:fs/promises")
+  return open(path, "wx", 0o600)
+}
+
+/** Startup options answered once, changed with `clco setup`. */
+export interface SetupPrefs {
+  version: number
+  bypass: boolean
+  select: boolean
+  /** Register the Playwright MCP server for clco sessions. Added in v2. */
+  browser?: boolean
+  /**
+   * Playwright MCP's extension token. Skips the connect dialog every session.
+   * Kept here because prefs.json is already written 0600, alongside no other
+   * secret — the GitHub token lives in auth.json.
+   */
+  browserToken?: string
+}
+
+export interface Prefs {
+  last_model?: string
+  setup?: SetupPrefs
+}
+
+function prefsPath(): string {
+  return join(authDir(), "prefs.json")
+}
+
+export async function loadPrefs(): Promise<Prefs> {
+  await migrateFromClcopilot()
+  try {
+    return JSON.parse(await readFile(prefsPath(), "utf8")) as Prefs
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * Merge into the stored preferences.
+ *
+ * Every caller holds one concern — the model prompt writes `last_model`, setup
+ * writes `setup` — and a plain write let whichever ran last erase the other.
+ * Picking a model really did discard the setup answers.
+ */
+async function writeSecret(path: string, data: string): Promise<void> {
+  const tmp = `${path}.tmp.${process.pid}`
+  await rm(tmp, { force: true }).catch(() => {})
+  const handle = await openExclusive(tmp)
+  try {
+    await handle.writeFile(data)
+  } finally {
+    await handle.close()
+  }
+  await chmod(tmp, 0o600).catch(() => {})
+  await rename(tmp, path)
+}
+
+export async function savePrefs(prefs: Prefs): Promise<void> {
+  await migrateFromClcopilot()
+  await mkdir(authDir(), { recursive: true })
+  const merged = { ...(await loadPrefs()), ...prefs }
+  // prefs now holds the Playwright extension token, so it gets the same
+  // treatment as auth.json: exclusive create, explicit mode, atomic rename.
+  // A plain write leaves an existing 0644 file at 0644 and can truncate.
+  await writeSecret(prefsPath(), JSON.stringify(merged, null, 2) + "\n")
+}
+
+export async function clearAuth(): Promise<void> {
+  // Also remove the legacy copy — otherwise migrateFromClcopilot resurrects
+  // the old token on the next run (logout would be a no-op).
+  await rm(authPath()).catch(() => {})
+  await rm(join(homedir(), ".config", "clcopilot", "auth.json")).catch(() => {})
+}

package/src/responses.ts

@@ -0,0 +1,435 @@
+// GitHub Copilot serves newer models (GPT-5.x "luna" family, codex) through
+// the OpenAI Responses API (POST /responses) instead of /chat/completions.
+// This module translates Anthropic requests into Responses requests, and
+// Responses SSE events into OpenAI-style chunks so the existing
+// StreamTranslator can render Anthropic events unchanged.
+
+import { effortFor, normalizeModel } from "./translate"
+import type { AnthropicRequest, OpenAIResponse } from "./wire"
+import { classifyContent } from "./blocks"
+
+// ---------------------------------------------------------------------------
+// Request direction: Anthropic -> Responses
+// ---------------------------------------------------------------------------
+
+interface ResponsesTool {
+  type: "function"
+  name: string
+  description?: string
+  parameters: Record<string, unknown>
+}
+
+interface ResponsesRequest {
+  model: string
+  instructions?: string
+  input: Array<Record<string, unknown>>
+  stream?: boolean
+  max_output_tokens?: number
+  temperature?: number
+  top_p?: number
+  tools?: ResponsesTool[]
+  tool_choice?: "auto" | "none" | "required" | { type: "function"; name: string }
+  reasoning?: { effort: string }
+}
+
+export function toResponsesRequest(
+  payload: AnthropicRequest,
+  allowedEfforts?: string[] | null,
+): ResponsesRequest {
+  const input: Array<Record<string, unknown>> = []
+
+  for (const message of payload.messages) {
+    if (typeof message.content === "string") {
+      input.push({
+        role: message.role,
+        content: [
+          {
+            type: message.role === "assistant" ? "output_text" : "input_text",
+            text: message.content,
+          },
+        ],
+      })
+      continue
+    }
+
+    // Tool results must land in the same order as the conversation.
+    const rest: Array<Record<string, unknown>> = []
+    const pendingImages: Array<Record<string, unknown>> = []
+    for (const view of classifyContent(message.content)) {
+      if (view.kind === "tool_result") {
+        const block = view.block
+        // Flush pending user content before the tool output to preserve
+        // ordering (results come first in Anthropic user messages anyway).
+        if (rest.length > 0) {
+          input.push({ role: "user", content: [...rest] })
+          rest.length = 0
+        }
+        let text: string
+        const images: Array<Record<string, unknown>> = []
+        if (typeof block.content === "string") {
+          text = block.content
+        } else if (Array.isArray(block.content)) {
+          const texts: string[] = []
+          for (const child of classifyContent(block.content)) {
+            if (child.kind === "text" || child.kind === "unsupported") texts.push(child.text)
+            else if (child.kind === "image")
+              images.push({
+                type: "input_image",
+                image_url: `data:${child.block.source.media_type};base64,${child.block.source.data}`,
+              })
+          }
+          text = texts.join("\n\n")
+        } else {
+          text = ""
+        }
+        if (block.is_error) text = `[error] ${text}`
+        if (images.length > 0) {
+          text =
+            (text ? `${text}\n\n` : "") +
+            `[${images.length} image(s) - attached to the next user message]`
+          pendingImages.push(...images)
+        }
+        input.push({
+          type: "function_call_output",
+          call_id: block.tool_use_id,
+          output: text,
+        })
+        continue
+      }
+      if (view.kind === "text" || view.kind === "unsupported") {
+        rest.push({
+          type: message.role === "assistant" ? "output_text" : "input_text",
+          text: view.text,
+        })
+      } else if (view.kind === "image") {
+        const block = view.block
+        rest.push({
+          type: "input_image",
+          image_url: `data:${block.source.media_type};base64,${block.source.data}`,
+        })
+      } else if (view.kind === "tool_use") {
+        const block = view.block
+        if (rest.length > 0) {
+          input.push({ role: message.role, content: [...rest] })
+          rest.length = 0
+        }
+        input.push({
+          type: "function_call",
+          call_id: block.id,
+          name: block.name,
+          arguments: JSON.stringify(block.input),
+        })
+      } else {
+        const exhaustive: never = view
+        throw new Error(`unhandled content: ${exhaustive}`)
+      }
+    }
+    if (pendingImages.length > 0 || rest.length > 0) {
+      // Merge pending tool-result images with trailing text into ONE user
+      // message (mirrors the chat dialect's adjacent-user-message layout).
+      input.push({
+        role: message.role,
+        content: [...pendingImages, ...rest],
+      })
+      pendingImages.length = 0
+    }
+  }
+
+  const instructions = Array.isArray(payload.system)
+    ? payload.system.map((b) => b.text).join("\n\n")
+    : payload.system
+
+  const effort = effortFor(payload, allowedEfforts)
+
+  return {
+    model: normalizeModel(payload.model),
+    ...(instructions && { instructions }),
+    ...(effort && { reasoning: { effort } }),
+    input,
+    stream: payload.stream,
+    max_output_tokens: payload.max_tokens,
+    temperature: payload.temperature,
+    top_p: payload.top_p,
+    tools: payload.tools?.map((t) => ({
+      type: "function" as const,
+      name: t.name,
+      description: t.description,
+      parameters: t.input_schema,
+    })),
+    tool_choice:
+      payload.tool_choice?.type === "auto"
+        ? "auto"
+        : payload.tool_choice?.type === "none"
+          ? "none"
+          : payload.tool_choice?.type === "any"
+            ? "required"
+            : payload.tool_choice?.name
+              ? { type: "function", name: payload.tool_choice.name }
+              : undefined,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Event direction: Responses SSE -> OpenAI-style chunks (for StreamTranslator)
+// ---------------------------------------------------------------------------
+
+function incompleteError(response: Record<string, unknown> | undefined): OpenAIResponse | null {
+  const details = response?.incomplete_details as { reason?: string } | undefined
+  const reason = details?.reason
+  // Only token exhaustion (or missing detail) maps to max_tokens. Other
+  // incomplete causes must not masquerade as successful text or tool calls.
+  if (!reason || reason === "max_output_tokens") return null
+  return { id: "r", model: "", error: { code: "response_incomplete", message: `upstream response incomplete: ${reason}` } }
+}
+
+export class ResponsesEventAdapter {
+  private toolIndexes = new Map<string, number>()
+  private argsAccum = new Map<string, string>()
+  private textAccum = new Map<string, string>()
+  private nextIndex = 0
+  private sawToolCall = false
+
+  /** Convert one Responses stream event into OpenAI-chunk shape (or null). */
+  pushEvent(event: Record<string, unknown>): OpenAIResponse | null {
+    const type = event.type as string | undefined
+    if (!type) return null
+
+    if (type === "response.output_text.delta") {
+      const delta = event.delta as string | undefined
+      if (!delta) return null
+      const key = String(event.item_id ?? "r")
+      this.textAccum.set(key, (this.textAccum.get(key) ?? "") + delta)
+      return {
+        id: key,
+        model: "",
+        choices: [{ index: 0, finish_reason: null, delta: { content: delta } }],
+      }
+    }
+
+    if (type === "response.output_text.done") {
+      // Authoritative fallback: if no delta arrived for this item, emit the
+      // full text so a lost stream cannot silently become an empty message.
+      const key = String(event.item_id ?? "r")
+      const full = (event.text as string | undefined) ?? ""
+      if (full && !(this.textAccum.get(key) ?? "")) {
+        return {
+          id: key,
+          model: "",
+          choices: [{ index: 0, finish_reason: null, delta: { content: full } }],
+        }
+      }
+      return null
+    }
+
+    if (type === "response.output_item.added") {
+      const item = event.item as
+        | { type?: string; call_id?: string; id?: string; name?: string }
+        | undefined
+      if (item?.type !== "function_call") return null
+      this.sawToolCall = true
+      const index = this.nextIndex++
+      const key = String(item.call_id ?? item.id ?? index)
+      this.toolIndexes.set(key, index)
+      // Arguments deltas are keyed by item_id; remember that too.
+      if (item.id) this.toolIndexes.set(String(item.id), index)
+      return {
+        id: String(item.call_id ?? item.id ?? "r"),
+        model: "",
+        choices: [
+          {
+            index: 0,
+            finish_reason: null,
+            delta: {
+              tool_calls: [
+                {
+                  index,
+                  id: item.call_id ?? item.id,
+                  function: { name: item.name ?? "", arguments: "" },
+                },
+              ],
+            },
+          },
+        ],
+      }
+    }
+
+    if (type === "response.function_call_arguments.delta") {
+      const delta = event.delta as string | undefined
+      if (!delta) return null
+      const key = String(event.item_id ?? "")
+      const index = this.toolIndexes.get(key)
+      if (index === undefined) return null
+      this.argsAccum.set(key, (this.argsAccum.get(key) ?? "") + delta)
+      return {
+        id: key,
+        model: "",
+        choices: [
+          {
+            index: 0,
+            finish_reason: null,
+            delta: {
+              tool_calls: [{ index, function: { arguments: delta } }],
+            },
+          },
+        ],
+      }
+    }
+
+    if (type === "response.function_call_arguments.done") {
+      const key = String(event.item_id ?? "")
+      const index = this.toolIndexes.get(key)
+      if (index === undefined) return null
+      const full = (event.arguments as string | undefined) ?? ""
+      if (full && !(this.argsAccum.get(key) ?? "")) {
+        return {
+          id: key,
+          model: "",
+          choices: [
+            {
+              index: 0,
+              finish_reason: null,
+              delta: {
+                tool_calls: [{ index, function: { arguments: full } }],
+              },
+            },
+          ],
+        }
+      }
+      return null
+    }
+
+    if (type === "response.completed" || type === "response.incomplete") {
+      if (type === "response.incomplete") {
+        const error = incompleteError(event.response as Record<string, unknown> | undefined)
+        if (error) return error
+      }
+      const response = event.response as
+        | {
+            usage?: {
+              input_tokens?: number
+              output_tokens?: number
+              input_tokens_details?: { cached_tokens?: number }
+            }
+          }
+        | undefined
+      const usage = response?.usage
+      const cached = usage?.input_tokens_details?.cached_tokens
+      return {
+        id: "r",
+        model: "",
+        choices: [
+          {
+            index: 0,
+            finish_reason: type === "response.incomplete" ? "length" : this.sawToolCall ? "tool_calls" : "stop",
+            delta: {},
+          },
+        ],
+        usage: usage
+          ? {
+              prompt_tokens: usage.input_tokens,
+              completion_tokens: usage.output_tokens,
+              ...(cached !== undefined && {
+                prompt_tokens_details: { cached_tokens: cached },
+              }),
+            }
+          : undefined,
+      }
+    }
+
+    if (type === "response.failed") {
+      const response = event.response as
+        | { error?: { message?: string; code?: string } }
+        | undefined
+      return {
+        id: "r",
+        model: "",
+        error: {
+          message: response?.error?.message ?? "upstream response failed",
+          code: response?.error?.code,
+        },
+      } as OpenAIResponse
+    }
+
+    if (type === "error") {
+      return {
+        id: "r",
+        model: "",
+        error: {
+          message: (event.message as string | undefined) ?? "upstream stream error",
+        },
+      } as OpenAIResponse
+    }
+
+    return null
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Non-streaming: Responses response JSON -> OpenAI response shape
+// ---------------------------------------------------------------------------
+
+export function responsesToOpenAIResponse(
+  body: Record<string, unknown>,
+): OpenAIResponse {
+  if (body.status === "incomplete") {
+    const error = incompleteError(body)
+    if (error) return error
+  }
+  const output = (body.output as Array<Record<string, unknown>> | undefined) ?? []
+  let text = ""
+  const toolCalls: Array<{
+    id: string
+    type: "function"
+    function: { name: string; arguments: string }
+  }> = []
+  for (const item of output) {
+    if (item.type === "message") {
+      const content = (item.content as Array<{ type?: string; text?: string }> | undefined) ?? []
+      for (const part of content) {
+        if (part.type === "output_text") text += part.text ?? ""
+      }
+    } else if (item.type === "function_call") {
+      toolCalls.push({
+        id: String(item.call_id ?? item.id ?? ""),
+        type: "function",
+        function: {
+          name: String(item.name ?? ""),
+          arguments: String(item.arguments ?? "{}"),
+        },
+      })
+    }
+  }
+  const usage = body.usage as
+    | {
+        input_tokens?: number
+        output_tokens?: number
+        input_tokens_details?: { cached_tokens?: number }
+      }
+    | undefined
+  return {
+    id: String(body.id ?? "r"),
+    model: String(body.model ?? ""),
+    choices: [
+      {
+        index: 0,
+        finish_reason: body.status === "incomplete" ? "length" : toolCalls.length > 0 ? "tool_calls" : "stop",
+        message: {
+          role: "assistant",
+          content: text || null,
+          ...(toolCalls.length > 0 && { tool_calls: toolCalls }),
+        },
+      },
+    ],
+    usage: usage
+      ? {
+          prompt_tokens: usage.input_tokens,
+          completion_tokens: usage.output_tokens,
+          ...(usage.input_tokens_details?.cached_tokens !== undefined && {
+            prompt_tokens_details: {
+              cached_tokens: usage.input_tokens_details.cached_tokens,
+            },
+          }),
+        }
+      : undefined,
+  }
+}

package/src/route.ts

@@ -0,0 +1,52 @@
+import type { UpstreamModel } from "./token"
+
+export type Dialect = "native" | "chat" | "responses"
+
+/** Evidence of an unsupported route/model, not merely a bad request. */
+export function nativeModelRejected(status: number, body: string): boolean {
+  if (status === 404) return true
+  if (![400, 415, 422].includes(status)) return false
+  let message = body.trim()
+  let code: unknown
+  try {
+    const parsed = JSON.parse(body)
+    message = String(parsed?.error?.message ?? parsed?.message ?? "").trim()
+    code = parsed?.error?.code ?? parsed?.code
+  } catch {
+    // Copilot may return a plain-text rejection.
+  }
+  if (typeof code === "string" && /^(?:model|endpoint)_(?:not_supported|unsupported|not_found)$/.test(code)) return true
+  // Anchor on the rejected subject. "model X: unsupported parameter" must
+  // not accidentally become a process-lifetime model demotion.
+  if (/\b(?:parameter|argument|temperature|thinking|schema|moderation|content[_ -]filter)\b/i.test(message)) return false
+  return /^(?:the\s+)?(?:requested\s+)?(?:model|endpoint)(?:\s+(?:["'][^"']+["']|[^\s:]+))?\s+(?:is\s+)?(?:not supported|unsupported|not found|not accessible via)(?:\b|$)/i.test(message) ||
+    /^(?:unsupported|unknown)\s+(?:model|endpoint)(?:\s|:|$)/i.test(message)
+}
+
+/** Learned routes live for the adapter process. Callers pass the already
+ * normalized upstream slug; normalizing twice can strip a real dated id. */
+export class DialectRouter {
+  private nativeRejectedModels = new Set<string>()
+  private responsesOnlyModels = new Set<string>()
+
+  select(model: string, info: UpstreamModel | undefined, nativeAvailable: boolean): Dialect {
+    if (nativeAvailable && info?.endpoints.includes("/v1/messages") && !this.nativeRejectedModels.has(model)) return "native"
+    return this.translated(model, info)
+  }
+
+  translated(model: string, info: UpstreamModel | undefined): "chat" | "responses" {
+    if (this.responsesOnlyModels.has(model) ||
+      (info?.endpoints.includes("/responses") && !info.endpoints.includes("/chat/completions"))) return "responses"
+    return "chat"
+  }
+
+  rejectNative(model: string, status: number, body: string): boolean {
+    if (!nativeModelRejected(status, body) || this.nativeRejectedModels.has(model)) return false
+    this.nativeRejectedModels.add(model)
+    return true
+  }
+
+  requireResponses(model: string): void {
+    this.responsesOnlyModels.add(model)
+  }
+}