@spacek33z/autoauto 0.0.1

package/src/lib/agent/claude-provider.ts

@@ -0,0 +1,277 @@
+import {
+  query,
+  type AccountInfo,
+  type SDKMessage,
+  type SDKUserMessage,
+  type SDKAssistantMessage,
+  type SDKPartialAssistantMessage,
+  type SDKResultMessage,
+  type Query,
+} from "@anthropic-ai/claude-agent-sdk"
+import { createPushStream } from "../push-stream.ts"
+import type {
+  AgentProvider,
+  AgentSession,
+  AgentSessionConfig,
+  AgentEvent,
+  AgentCost,
+  AuthResult,
+  AgentModelOption,
+} from "./types.ts"
+
+// --- SDK message helpers (formerly in sdk-helpers.ts) ---
+
+function getAssistantText(message: SDKAssistantMessage): string {
+  return message.message.content
+    .flatMap((block) => (block.type === "text" ? [block.text] : []))
+    .join("")
+}
+
+function getTextDelta(message: SDKPartialAssistantMessage): string | null {
+  const event = message.event
+  if (event.type !== "content_block_delta" || event.delta.type !== "text_delta") {
+    return null
+  }
+  return event.delta.text
+}
+
+/** Tracks an in-progress tool_use block while input JSON is being streamed. */
+interface PendingToolUse {
+  tool: string
+  inputJson: string
+}
+
+/**
+ * Processes stream events for tool_use blocks. Returns the tool call only
+ * at content_block_stop, after all input_json_delta chunks have arrived,
+ * so formatToolEvent can produce descriptive messages (file paths, commands).
+ */
+function processToolUseEvent(
+  event: unknown,
+  pending: PendingToolUse | null,
+): { pending: PendingToolUse | null; result: { tool: string; input?: Record<string, unknown> } | null } {
+  const ev = event as { type?: string; content_block?: { type?: string; name?: string }; delta?: { type?: string; partial_json?: string } }
+  const type = ev.type
+
+  if (type === "content_block_start") {
+    const block = ev.content_block
+    if (block?.type === "tool_use" && block.name) {
+      return { pending: { tool: block.name, inputJson: "" }, result: null }
+    }
+    return { pending, result: null }
+  }
+
+  if (type === "content_block_delta" && pending) {
+    const delta = ev.delta
+    if (delta?.type === "input_json_delta" && typeof delta.partial_json === "string") {
+      return { pending: { ...pending, inputJson: pending.inputJson + delta.partial_json }, result: null }
+    }
+    return { pending, result: null }
+  }
+
+  if (type === "content_block_stop" && pending) {
+    let input: Record<string, unknown> | undefined
+    try {
+      const parsed = JSON.parse(pending.inputJson)
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        input = parsed as Record<string, unknown>
+      }
+    } catch {
+      // Malformed JSON — emit without input
+    }
+    return { pending: null, result: { tool: pending.tool, input } }
+  }
+
+  return { pending, result: null }
+}
+
+function extractCost(message: SDKResultMessage): AgentCost {
+  return {
+    total_cost_usd: message.total_cost_usd ?? 0,
+    duration_ms: message.duration_ms ?? 0,
+    duration_api_ms: message.duration_api_ms ?? 0,
+    num_turns: message.num_turns ?? 0,
+    input_tokens: message.usage?.input_tokens ?? 0,
+    output_tokens: message.usage?.output_tokens ?? 0,
+  }
+}
+
+// --- ClaudeSession ---
+
+class ClaudeSession implements AgentSession {
+  private inputStream = createPushStream<SDKUserMessage>()
+  private abortController = new AbortController()
+  private queryIterable: Query
+  private externalSignal?: AbortSignal
+  private signalHandler?: () => void
+
+  constructor(config: AgentSessionConfig) {
+    // Link external signal to our abort controller
+    if (config.signal) {
+      if (config.signal.aborted) {
+        this.abortController.abort()
+      } else {
+        this.externalSignal = config.signal
+        this.signalHandler = () => this.abortController.abort()
+        config.signal.addEventListener("abort", this.signalHandler, { once: true })
+      }
+    }
+
+    this.queryIterable = query({
+      prompt: this.inputStream,
+      options: {
+        systemPrompt: config.systemPrompt,
+        tools: config.tools ?? [],
+        allowedTools: config.allowedTools,
+        maxTurns: config.maxTurns,
+        cwd: config.cwd,
+        model: config.model,
+        effort: config.effort as "low" | "medium" | "high" | "max" | undefined,
+        permissionMode: "bypassPermissions",
+        allowDangerouslySkipPermissions: true,
+        persistSession: false,
+        includePartialMessages: true,
+        abortController: this.abortController,
+      },
+    })
+  }
+
+  pushMessage(content: string): void {
+    this.inputStream.push({
+      type: "user",
+      message: { role: "user", content },
+      parent_tool_use_id: null,
+    })
+  }
+
+  endInput(): void {
+    this.inputStream.end()
+  }
+
+  close(): void {
+    if (this.externalSignal && this.signalHandler) {
+      this.externalSignal.removeEventListener("abort", this.signalHandler)
+    }
+    this.abortController.abort()
+    this.inputStream.end()
+  }
+
+  async *[Symbol.asyncIterator](): AsyncIterator<AgentEvent> {
+    let pendingTool: PendingToolUse | null = null
+
+    try {
+      for await (const message of this.queryIterable as AsyncIterable<SDKMessage>) {
+        if (this.abortController.signal.aborted) break
+
+        if (message.type === "stream_event") {
+          const partial = message as unknown as SDKPartialAssistantMessage
+          const text = getTextDelta(partial)
+          if (text) {
+            yield { type: "text_delta", text }
+          }
+
+          // Accumulate tool input across stream events, emit at content_block_stop
+          const { pending, result } = processToolUseEvent(partial.event, pendingTool)
+          pendingTool = pending
+          if (result) {
+            yield { type: "tool_use", tool: result.tool, input: result.input }
+          }
+        } else if (message.type === "assistant") {
+          const text = getAssistantText(message as unknown as SDKAssistantMessage)
+          yield { type: "assistant_complete", text }
+        } else if (message.type === "result") {
+          const resultMsg = message as unknown as SDKResultMessage
+          const cost = extractCost(resultMsg)
+          const success = resultMsg.subtype === "success"
+          const error = success
+            ? undefined
+            : resultMsg.errors.join(", ") || resultMsg.subtype
+          yield { type: "result", success, error, cost }
+        }
+        // Skip "user" and "system" message types
+      }
+    } catch (err: unknown) {
+      if (!this.abortController.signal.aborted) {
+        yield {
+          type: "error",
+          error: err instanceof Error ? err.message : String(err),
+          retriable: false,
+        }
+      }
+    }
+  }
+}
+
+// --- ClaudeProvider ---
+
+export class ClaudeProvider implements AgentProvider {
+  readonly name = "claude"
+
+  async listModels(): Promise<AgentModelOption[]> {
+    return [
+      {
+        provider: "claude",
+        model: "sonnet",
+        label: "Claude / Sonnet",
+        description: "Claude Sonnet via Claude Agent SDK",
+        isDefault: true,
+      },
+      {
+        provider: "claude",
+        model: "opus",
+        label: "Claude / Opus",
+        description: "Claude Opus via Claude Agent SDK",
+      },
+    ]
+  }
+
+  async getDefaultModel(): Promise<string> {
+    return "sonnet"
+  }
+
+  createSession(config: AgentSessionConfig): AgentSession {
+    return new ClaudeSession(config)
+  }
+
+  runOnce(prompt: string, config: AgentSessionConfig): AgentSession {
+    const session = this.createSession(config)
+    session.pushMessage(prompt)
+    session.endInput()
+    return session
+  }
+
+  async checkAuth(): Promise<AuthResult> {
+    const abortController = new AbortController()
+    const timeout = setTimeout(() => abortController.abort(), 10_000)
+
+    try {
+      const idleStream = createPushStream<SDKUserMessage>()
+
+      const q = query({
+        prompt: idleStream,
+        options: {
+          tools: [],
+          persistSession: false,
+          abortController,
+        },
+      })
+
+      const account: AccountInfo = await q.accountInfo()
+      q.close()
+      idleStream.end()
+      clearTimeout(timeout)
+
+      return {
+        authenticated: true,
+        account: { ...account } as Record<string, unknown> & { email?: string },
+      }
+    } catch (err) {
+      clearTimeout(timeout)
+      abortController.abort()
+      return {
+        authenticated: false,
+        error: err instanceof Error ? err.message : String(err),
+      }
+    }
+  }
+}

package/src/lib/agent/codex-provider.ts

@@ -0,0 +1,413 @@
+import { $ } from "bun"
+import { createRequire } from "node:module"
+import { dirname, join } from "node:path"
+import {
+  Codex,
+  type ModelReasoningEffort,
+  type Thread,
+  type ThreadEvent,
+  type ThreadItem,
+  type ThreadOptions,
+  type Usage,
+} from "@openai/codex-sdk"
+import { createPushStream } from "../push-stream.ts"
+import type {
+  AgentCost,
+  AgentEvent,
+  AgentModelOption,
+  AgentProvider,
+  AgentSession,
+  AgentSessionConfig,
+  AuthResult,
+} from "./types.ts"
+
+const CODEX_DEFAULT_MODEL = "default"
+const PLATFORM_PACKAGE_BY_TARGET: Record<string, string> = {
+  "x86_64-unknown-linux-musl": "@openai/codex-linux-x64",
+  "aarch64-unknown-linux-musl": "@openai/codex-linux-arm64",
+  "x86_64-apple-darwin": "@openai/codex-darwin-x64",
+  "aarch64-apple-darwin": "@openai/codex-darwin-arm64",
+  "x86_64-pc-windows-msvc": "@openai/codex-win32-x64",
+  "aarch64-pc-windows-msvc": "@openai/codex-win32-arm64",
+}
+const require = createRequire(import.meta.url)
+
+function getCodexBinPath(): string {
+  const targetTriple = getCodexTargetTriple()
+  const platformPackage = PLATFORM_PACKAGE_BY_TARGET[targetTriple]
+  if (!platformPackage) throw new Error(`Unsupported Codex target triple: ${targetTriple}`)
+
+  const packageJsonPath = require.resolve(`${platformPackage}/package.json`)
+  const vendorRoot = join(dirname(packageJsonPath), "vendor")
+  const binaryName = process.platform === "win32" ? "codex.exe" : "codex"
+  return join(vendorRoot, targetTriple, "codex", binaryName)
+}
+
+function getCodexTargetTriple(): string {
+  switch (process.platform) {
+    case "darwin":
+      if (process.arch === "arm64") return "aarch64-apple-darwin"
+      if (process.arch === "x64") return "x86_64-apple-darwin"
+      break
+    case "linux":
+    case "android":
+      if (process.arch === "arm64") return "aarch64-unknown-linux-musl"
+      if (process.arch === "x64") return "x86_64-unknown-linux-musl"
+      break
+    case "win32":
+      if (process.arch === "arm64") return "aarch64-pc-windows-msvc"
+      if (process.arch === "x64") return "x86_64-pc-windows-msvc"
+      break
+  }
+
+  throw new Error(`Unsupported Codex platform: ${process.platform} (${process.arch})`)
+}
+
+function normalizeModel(model: string | undefined): string | undefined {
+  if (!model || model === CODEX_DEFAULT_MODEL) return undefined
+  return model
+}
+
+function mapEffort(effort: string | undefined): ModelReasoningEffort | undefined {
+  switch (effort) {
+    case "low":
+    case "medium":
+    case "high":
+      return effort
+    case "max":
+      return "xhigh"
+    default:
+      return undefined
+  }
+}
+
+function stringProviderOption<T extends string>(
+  config: AgentSessionConfig,
+  key: string,
+  allowed: readonly T[],
+): T | undefined {
+  const value = config.providerOptions?.[key]
+  return typeof value === "string" && (allowed as readonly string[]).includes(value)
+    ? value as T
+    : undefined
+}
+
+function booleanProviderOption(config: AgentSessionConfig, key: string): boolean | undefined {
+  const value = config.providerOptions?.[key]
+  return typeof value === "boolean" ? value : undefined
+}
+
+function hasWriteTools(config: AgentSessionConfig): boolean {
+  const tools = config.allowedTools ?? config.tools ?? []
+  return tools.some((tool) => {
+    const normalized = tool.toLowerCase()
+    return normalized === "write" || normalized === "edit"
+  })
+}
+
+function buildThreadOptions(config: AgentSessionConfig): ThreadOptions {
+  const sandboxMode =
+    stringProviderOption(config, "sandboxMode", ["read-only", "workspace-write", "danger-full-access"] as const)
+    ?? (hasWriteTools(config) ? "danger-full-access" : "read-only")
+
+  return {
+    model: normalizeModel(config.model),
+    modelReasoningEffort: mapEffort(config.effort),
+    workingDirectory: config.cwd,
+    approvalPolicy: stringProviderOption(config, "approvalPolicy", ["never", "on-request", "on-failure", "untrusted"] as const) ?? "never",
+    sandboxMode,
+    networkAccessEnabled: booleanProviderOption(config, "networkAccessEnabled") ?? true,
+    skipGitRepoCheck: booleanProviderOption(config, "skipGitRepoCheck"),
+  }
+}
+
+function buildPrompt(config: AgentSessionConfig, prompt: string, isFirstTurn: boolean): string {
+  const systemPrompt = config.systemPrompt?.trim()
+  if (!systemPrompt || !isFirstTurn) return prompt
+
+  return [
+    "System instructions:",
+    systemPrompt,
+    "",
+    "User request:",
+    prompt,
+  ].join("\n")
+}
+
+function getItemText(item: ThreadItem): string | null {
+  return item.type === "agent_message" ? item.text : null
+}
+
+function getToolUse(item: ThreadItem): { tool: string; input?: Record<string, unknown> } | null {
+  switch (item.type) {
+    case "command_execution":
+      return {
+        tool: "Bash",
+        input: {
+          command: item.command,
+          status: item.status,
+          exit_code: item.exit_code,
+        },
+      }
+    case "file_change":
+      return {
+        tool: "Edit",
+        input: {
+          file_path: item.changes[0]?.path,
+          changes: item.changes,
+          status: item.status,
+        },
+      }
+    case "mcp_tool_call":
+      return {
+        tool: `${item.server}.${item.tool}`,
+        input: {
+          arguments: item.arguments,
+          status: item.status,
+        },
+      }
+    case "web_search":
+      return {
+        tool: "WebSearch",
+        input: { query: item.query },
+      }
+    default:
+      return null
+  }
+}
+
+function extractCost(usage: Usage, startedAt: number, numTurns: number): AgentCost {
+  return {
+    total_cost_usd: 0,
+    duration_ms: Date.now() - startedAt,
+    duration_api_ms: 0,
+    num_turns: numTurns,
+    input_tokens: usage.input_tokens,
+    output_tokens: usage.output_tokens,
+  }
+}
+
+class CodexSession implements AgentSession {
+  private input = createPushStream<string>()
+  private events = createPushStream<AgentEvent>()
+  private abortController = new AbortController()
+  private externalSignal?: AbortSignal
+  private signalHandler?: () => void
+  private closed = false
+  private thread: Thread
+  private turnCount = 0
+
+  constructor(
+    codex: Codex,
+    private config: AgentSessionConfig,
+  ) {
+    this.thread = codex.startThread(buildThreadOptions(config))
+
+    if (config.signal) {
+      if (config.signal.aborted) {
+        this.abortController.abort()
+      } else {
+        this.externalSignal = config.signal
+        this.signalHandler = () => this.close()
+        config.signal.addEventListener("abort", this.signalHandler, { once: true })
+      }
+    }
+
+    this.run().catch((err: unknown) => {
+      if (!this.closed) {
+        const error = err instanceof Error ? err.message : String(err)
+        this.events.push({ type: "error", error, retriable: false })
+        this.events.push({ type: "result", success: false, error })
+      }
+      this.events.end()
+    })
+  }
+
+  pushMessage(content: string): void {
+    if (this.closed) return
+    this.input.push(content)
+  }
+
+  endInput(): void {
+    this.input.end()
+  }
+
+  close(): void {
+    if (this.closed) return
+    this.closed = true
+    if (this.externalSignal && this.signalHandler) {
+      this.externalSignal.removeEventListener("abort", this.signalHandler)
+    }
+    this.abortController.abort()
+    this.input.end()
+    this.events.end()
+  }
+
+  async *[Symbol.asyncIterator](): AsyncIterator<AgentEvent> {
+    yield* this.events
+  }
+
+  private async run(): Promise<void> {
+    for await (const rawPrompt of this.input) {
+      if (this.closed || this.abortController.signal.aborted) break
+
+      if (this.config.maxTurns != null && this.turnCount >= this.config.maxTurns) {
+        const error = `Codex session exceeded maxTurns (${this.config.maxTurns})`
+        this.events.push({ type: "error", error, retriable: false })
+        this.events.push({ type: "result", success: false, error })
+        break
+      }
+
+      const prompt = buildPrompt(this.config, rawPrompt, this.turnCount === 0)
+      await this.runTurn(prompt)
+    }
+
+    this.events.end()
+  }
+
+  private async runTurn(prompt: string): Promise<void> {
+    const startedAt = Date.now()
+    this.turnCount += 1
+    const textByItemID = new Map<string, string>()
+    const emittedTools = new Set<string>()
+
+    try {
+      const { events } = await this.thread.runStreamed(prompt, {
+        signal: this.abortController.signal,
+      })
+
+      for await (const event of events) {
+        if (this.closed || this.abortController.signal.aborted) break
+        this.handleEvent(event, textByItemID, emittedTools, startedAt)
+      }
+    } catch (err: unknown) {
+      if (!this.closed && !this.abortController.signal.aborted) {
+        const error = err instanceof Error ? err.message : String(err)
+        this.events.push({ type: "error", error, retriable: false })
+        this.events.push({ type: "result", success: false, error })
+      }
+    }
+  }
+
+  private handleEvent(
+    event: ThreadEvent,
+    textByItemID: Map<string, string>,
+    emittedTools: Set<string>,
+    startedAt: number,
+  ): void {
+    switch (event.type) {
+      case "item.started":
+      case "item.updated":
+      case "item.completed":
+        this.handleItem(event.item, event.type, textByItemID, emittedTools)
+        break
+      case "turn.completed":
+        this.events.push({
+          type: "result",
+          success: true,
+          cost: extractCost(event.usage, startedAt, this.turnCount),
+        })
+        break
+      case "turn.failed":
+        this.events.push({ type: "error", error: event.error.message, retriable: false })
+        this.events.push({ type: "result", success: false, error: event.error.message })
+        break
+      case "error":
+        this.events.push({ type: "error", error: event.message, retriable: false })
+        this.events.push({ type: "result", success: false, error: event.message })
+        break
+    }
+  }
+
+  private handleItem(
+    item: ThreadItem,
+    eventType: "item.started" | "item.updated" | "item.completed",
+    textByItemID: Map<string, string>,
+    emittedTools: Set<string>,
+  ): void {
+    const text = getItemText(item)
+    if (text != null) {
+      const previous = textByItemID.get(item.id) ?? ""
+      const delta = text.startsWith(previous) ? text.slice(previous.length) : text
+      textByItemID.set(item.id, text)
+      if (delta) this.events.push({ type: "text_delta", text: delta })
+      if (eventType === "item.completed" && text.trim()) {
+        this.events.push({ type: "assistant_complete", text })
+      }
+      return
+    }
+
+    if (item.type === "error") {
+      this.events.push({ type: "error", error: item.message, retriable: false })
+      return
+    }
+
+    const toolUse = getToolUse(item)
+    if (!toolUse) return
+
+    const status = "status" in item ? item.status : eventType
+    const key = `${item.id}:${item.type}:${status}`
+    if (emittedTools.has(key)) return
+    emittedTools.add(key)
+    this.events.push({ type: "tool_use", ...toolUse })
+  }
+}
+
+export class CodexProvider implements AgentProvider {
+  readonly name = "codex"
+  private codex = new Codex()
+
+  async listModels(): Promise<AgentModelOption[]> {
+    return [
+      {
+        provider: "codex",
+        model: CODEX_DEFAULT_MODEL,
+        label: "Codex / Default",
+        description: "Configured Codex CLI default model",
+        isDefault: true,
+      },
+    ]
+  }
+
+  async getDefaultModel(): Promise<string> {
+    return CODEX_DEFAULT_MODEL
+  }
+
+  createSession(config: AgentSessionConfig): AgentSession {
+    return new CodexSession(this.codex, config)
+  }
+
+  runOnce(prompt: string, config: AgentSessionConfig): AgentSession {
+    const session = this.createSession(config)
+    session.pushMessage(prompt)
+    session.endInput()
+    return session
+  }
+
+  async checkAuth(): Promise<AuthResult> {
+    const codexBinPath = getCodexBinPath()
+    const [statusResult, versionResult] = await Promise.all([
+      $`${codexBinPath} login status`.nothrow().quiet(),
+      $`${codexBinPath} --version`.nothrow().quiet(),
+    ])
+
+    const status = `${statusResult.stdout.toString()}${statusResult.stderr.toString()}`.trim()
+    const version = `${versionResult.stdout.toString()}${versionResult.stderr.toString()}`.trim()
+
+    if (statusResult.exitCode === 0) {
+      return {
+        authenticated: true,
+        account: {
+          provider: "codex",
+          status,
+          version,
+        },
+      }
+    }
+
+    return {
+      authenticated: false,
+      error: status || `Codex login status exited with code ${statusResult.exitCode}`,
+    }
+  }
+}

package/src/lib/agent/default-providers.ts

@@ -0,0 +1,10 @@
+import { setProvider } from "./index.ts"
+import { ClaudeProvider } from "./claude-provider.ts"
+import { OpenCodeProvider } from "./opencode-provider.ts"
+import { CodexProvider } from "./codex-provider.ts"
+
+export function registerDefaultProviders(): void {
+  setProvider("claude", new ClaudeProvider())
+  setProvider("opencode", new OpenCodeProvider())
+  setProvider("codex", new CodexProvider())
+}