@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/features/hook-message-injector/injector.ts

@@ -1,437 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs"
-import { randomBytes } from "node:crypto"
-import { join } from "node:path"
-import type { PluginInput } from "@opencode-ai/plugin"
-import { MESSAGE_STORAGE, PART_STORAGE } from "./constants"
-import type { MessageMeta, OriginalMessageContext, TextPart, ToolPermission } from "./types"
-import { log } from "../../shared/logger"
-import { isSqliteBackend } from "../../shared/opencode-storage-detection"
-import { createInternalAgentTextPart, normalizeSDKResponse } from "../../shared"
-import { hasCompactionPartInStorage, isCompactionMessage } from "../../shared/compaction-marker"
-
-export interface StoredMessage {
-  agent?: string
-  model?: { providerID?: string; modelID?: string; variant?: string }
-  tools?: Record<string, ToolPermission>
-}
-
-type OpencodeClient = PluginInput["client"]
-
-interface SDKMessage {
-  id?: string
-  info?: {
-    agent?: string
-    model?: {
-      providerID?: string
-      modelID?: string
-      variant?: string
-    }
-    providerID?: string
-    modelID?: string
-    tools?: Record<string, ToolPermission>
-    time?: {
-      created?: number
-    }
-  }
-  parts?: Array<{ type?: string }>
-}
-
-const processPrefix = randomBytes(4).toString("hex")
-let messageCounter = 0
-let partCounter = 0
-
-function convertSDKMessageToStoredMessage(msg: SDKMessage): StoredMessage | null {
-  if (isCompactionMessage(msg)) {
-    return null
-  }
-
-  const info = msg.info
-  if (!info) return null
-
-  const providerID = info.model?.providerID ?? info.providerID
-  const modelID = info.model?.modelID ?? info.modelID
-  const variant = info.model?.variant
-
-  if (!info.agent && !providerID && !modelID) {
-    return null
-  }
-
-  return {
-    agent: info.agent,
-    model: providerID && modelID
-      ? { providerID, modelID, ...(variant ? { variant } : {}) }
-      : undefined,
-    tools: info.tools,
-  }
-}
-
-// TODO: These SDK-based functions are exported for future use when hooks migrate to async.
-// Currently, callers still use the sync JSON-based functions which return null on beta.
-// Migration requires making callers async, which is a larger refactoring.
-// See: https://github.com/code-yeongyu/hiai-opencode/pull/1837
-
-/**
- * Finds the nearest message with required fields using SDK (for beta/SQLite backend).
- * Uses client.session.messages() to fetch message data from SQLite.
- */
-export async function findNearestMessageWithFieldsFromSDK(
-  client: OpencodeClient,
-  sessionID: string
-): Promise<StoredMessage | null> {
-  try {
-    const response = await client.session.messages({ path: { id: sessionID } })
-    const messages = normalizeSDKResponse(response, [] as SDKMessage[], { preferResponseOnMissingData: true })
-      .map((message) => ({
-        stored: convertSDKMessageToStoredMessage(message),
-        createdAt: message.info?.time?.created ?? Number.NEGATIVE_INFINITY,
-        id: typeof message.id === "string" ? message.id : "",
-      }))
-      .sort((left, right) => right.createdAt - left.createdAt || right.id.localeCompare(left.id))
-
-    for (const message of messages) {
-      const stored = message.stored
-      if (stored?.agent && stored.model?.providerID && stored.model?.modelID) {
-        return stored
-      }
-    }
-
-    for (const message of messages) {
-      const stored = message.stored
-      if (stored?.agent || (stored?.model?.providerID && stored?.model?.modelID)) {
-        return stored
-      }
-    }
-  } catch (error) {
-    log("[hook-message-injector] SDK message fetch failed", {
-      sessionID,
-      error: String(error),
-    })
-  }
-  return null
-}
-
-/**
- * Finds the FIRST (oldest) message with agent field using SDK (for beta/SQLite backend).
- */
-export async function findFirstMessageWithAgentFromSDK(
-  client: OpencodeClient,
-  sessionID: string
-): Promise<string | null> {
-  try {
-    const response = await client.session.messages({ path: { id: sessionID } })
-    const messages = normalizeSDKResponse(response, [] as SDKMessage[], { preferResponseOnMissingData: true })
-      .sort((left, right) => {
-        const leftTime = left.info?.time?.created ?? Number.POSITIVE_INFINITY
-        const rightTime = right.info?.time?.created ?? Number.POSITIVE_INFINITY
-        if (leftTime !== rightTime) return leftTime - rightTime
-        const leftId = typeof left.id === "string" ? left.id : ""
-        const rightId = typeof right.id === "string" ? right.id : ""
-        return leftId.localeCompare(rightId)
-      })
-
-    for (const msg of messages) {
-      const stored = convertSDKMessageToStoredMessage(msg)
-      if (stored?.agent) {
-        return stored.agent
-      }
-    }
-  } catch (error) {
-    log("[hook-message-injector] SDK agent fetch failed", {
-      sessionID,
-      error: String(error),
-    })
-  }
-  return null
-}
-
-/**
- * Finds the nearest message with required fields (agent, model.providerID, model.modelID).
- * Reads from JSON files - for stable (JSON) backend.
- *
- * **Version-gated behavior:**
- * - On beta (SQLite backend): Returns null immediately (no JSON storage)
- * - On stable (JSON backend): Reads from JSON files in messageDir
- *
- * @deprecated Use findNearestMessageWithFieldsFromSDK for beta/SQLite backend
- */
-export function findNearestMessageWithFields(messageDir: string): StoredMessage | null {
-  // On beta SQLite backend, skip JSON file reads entirely
-  if (isSqliteBackend()) {
-    return null
-  }
-
-  try {
-    const messages = readdirSync(messageDir)
-      .filter((f) => f.endsWith(".json"))
-      .map((fileName) => {
-        try {
-          const content = readFileSync(join(messageDir, fileName), "utf-8")
-          const msg = JSON.parse(content) as StoredMessage & { time?: { created?: number } }
-          return {
-            fileName,
-            msg,
-            hasCompactionMarker: hasCompactionPartInStorage(
-              typeof (msg as { id?: unknown }).id === "string" ? (msg as { id?: string }).id : undefined,
-            ),
-            createdAt: typeof msg.time?.created === "number" ? msg.time.created : Number.NEGATIVE_INFINITY,
-          }
-        } catch {
-          return null
-        }
-      })
-      .filter((entry): entry is {
-        fileName: string
-        msg: StoredMessage & { time?: { created?: number } }
-        hasCompactionMarker: boolean
-        createdAt: number
-      } => entry !== null)
-      .sort((left, right) => right.createdAt - left.createdAt || right.fileName.localeCompare(left.fileName))
-
-    for (const entry of messages) {
-      if (entry.hasCompactionMarker || isCompactionMessage({ agent: entry.msg.agent })) {
-        continue
-      }
-
-      if (entry.msg.agent && entry.msg.model?.providerID && entry.msg.model?.modelID) {
-        return entry.msg
-      }
-    }
-
-    for (const entry of messages) {
-      if (entry.hasCompactionMarker || isCompactionMessage({ agent: entry.msg.agent })) {
-        continue
-      }
-
-      if (entry.msg.agent || (entry.msg.model?.providerID && entry.msg.model?.modelID)) {
-        return entry.msg
-      }
-    }
-  } catch {
-    return null
-  }
-  return null
-}
-
-/**
- * Finds the FIRST (oldest) message in the session with agent field.
- * Reads from JSON files - for stable (JSON) backend.
- *
- * **Version-gated behavior:**
- * - On beta (SQLite backend): Returns null immediately (no JSON storage)
- * - On stable (JSON backend): Reads from JSON files in messageDir
- *
- * @deprecated Use findFirstMessageWithAgentFromSDK for beta/SQLite backend
- */
-export function findFirstMessageWithAgent(messageDir: string): string | null {
-  // On beta SQLite backend, skip JSON file reads entirely
-  if (isSqliteBackend()) {
-    return null
-  }
-
-  try {
-    const messages = readdirSync(messageDir)
-      .filter((f) => f.endsWith(".json"))
-      .map((fileName) => {
-        try {
-          const content = readFileSync(join(messageDir, fileName), "utf-8")
-          const msg = JSON.parse(content) as StoredMessage & { time?: { created?: number } }
-          return {
-            fileName,
-            msg,
-            hasCompactionMarker: hasCompactionPartInStorage(
-              typeof (msg as { id?: unknown }).id === "string" ? (msg as { id?: string }).id : undefined,
-            ),
-            createdAt: typeof msg.time?.created === "number" ? msg.time.created : Number.POSITIVE_INFINITY,
-          }
-        } catch {
-          return null
-        }
-      })
-      .filter((entry): entry is {
-        fileName: string
-        msg: StoredMessage & { time?: { created?: number } }
-        hasCompactionMarker: boolean
-        createdAt: number
-      } => entry !== null)
-      .sort((left, right) => left.createdAt - right.createdAt || left.fileName.localeCompare(right.fileName))
-
-    for (const entry of messages) {
-      if (entry.hasCompactionMarker || isCompactionMessage({ agent: entry.msg.agent })) {
-        continue
-      }
-
-      if (entry.msg.agent) {
-        return entry.msg.agent
-      }
-    }
-  } catch {
-    return null
-  }
-  return null
-}
-
-export function generateMessageId(): string {
-  return `msg_${processPrefix}_${String(++messageCounter).padStart(6, "0")}`
-}
-
-export function generatePartId(): string {
-  return `prt_${processPrefix}_${String(++partCounter).padStart(6, "0")}`
-}
-
-function getOrCreateMessageDir(sessionID: string): string {
-  if (!existsSync(MESSAGE_STORAGE)) {
-    mkdirSync(MESSAGE_STORAGE, { recursive: true })
-  }
-
-  const directPath = join(MESSAGE_STORAGE, sessionID)
-  if (existsSync(directPath)) {
-    return directPath
-  }
-
-  for (const dir of readdirSync(MESSAGE_STORAGE)) {
-    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
-    if (existsSync(sessionPath)) {
-      return sessionPath
-    }
-  }
-
-  mkdirSync(directPath, { recursive: true })
-  return directPath
-}
-
-/**
- * Injects a hook message into the session storage.
- *
- * **Version-gated behavior:**
- * - On beta (SQLite backend): Logs warning and skips injection (writes are invisible to SQLite)
- * - On stable (JSON backend): Writes message and part JSON files
- *
- * Features degraded on beta:
- * - Hook message injection (e.g., continuation prompts, context injection) won't persist
- * - Guard hook's injected messages won't be visible in SQLite backend
- * - Todo continuation enforcer's injected prompts won't persist
- * - Ralph loop's continuation prompts won't persist
- *
- * @param sessionID - Target session ID
- * @param hookContent - Content to inject
- * @param originalMessage - Context from the original message
- * @returns true if injection succeeded, false otherwise
- */
-export function injectHookMessage(
-  sessionID: string,
-  hookContent: string,
-  originalMessage: OriginalMessageContext
-): boolean {
-  if (!hookContent || hookContent.trim().length === 0) {
-    log("[hook-message-injector] Attempted to inject empty hook content, skipping injection", {
-      sessionID,
-      hasAgent: !!originalMessage.agent,
-      hasModel: !!(originalMessage.model?.providerID && originalMessage.model?.modelID)
-    })
-    return false
-  }
-
-  if (isSqliteBackend()) {
-    log("[hook-message-injector] Skipping JSON message injection on SQLite backend. " +
-        "In-flight injection is handled via experimental.chat.messages.transform hook. " +
-        "JSON write path is not needed when SQLite is the storage backend.", {
-      sessionID,
-      agent: originalMessage.agent,
-    })
-    return false
-  }
-
-  const messageDir = getOrCreateMessageDir(sessionID)
-
-  const needsFallback =
-    !originalMessage.agent ||
-    !originalMessage.model?.providerID ||
-    !originalMessage.model?.modelID
-
-  const fallback = needsFallback ? findNearestMessageWithFields(messageDir) : null
-
-  const now = Date.now()
-  const messageID = generateMessageId()
-  const partID = generatePartId()
-
-  const resolvedAgent = originalMessage.agent ?? fallback?.agent ?? "general"
-  const resolvedModel =
-    originalMessage.model?.providerID && originalMessage.model?.modelID
-      ? { 
-          providerID: originalMessage.model.providerID, 
-          modelID: originalMessage.model.modelID,
-          ...(originalMessage.model.variant ? { variant: originalMessage.model.variant } : {})
-        }
-      : fallback?.model?.providerID && fallback?.model?.modelID
-        ? { 
-            providerID: fallback.model.providerID, 
-            modelID: fallback.model.modelID,
-            ...(fallback.model.variant ? { variant: fallback.model.variant } : {})
-          }
-        : undefined
-  const resolvedTools = originalMessage.tools ?? fallback?.tools
-
-  const messageMeta: MessageMeta = {
-    id: messageID,
-    sessionID,
-    role: "user",
-    time: {
-      created: now,
-    },
-    agent: resolvedAgent,
-    model: resolvedModel,
-    path:
-      originalMessage.path?.cwd
-        ? {
-            cwd: originalMessage.path.cwd,
-            root: originalMessage.path.root ?? "/",
-          }
-        : undefined,
-    tools: resolvedTools,
-  }
-
-  const textPart: TextPart = {
-    id: partID,
-    type: "text",
-    text: createInternalAgentTextPart(hookContent).text,
-    synthetic: true,
-    time: {
-      start: now,
-      end: now,
-    },
-    messageID,
-    sessionID,
-  }
-
-  try {
-    writeFileSync(join(messageDir, `${messageID}.json`), JSON.stringify(messageMeta, null, 2))
-
-    const partDir = join(PART_STORAGE, messageID)
-    if (!existsSync(partDir)) {
-      mkdirSync(partDir, { recursive: true })
-    }
-    writeFileSync(join(partDir, `${partID}.json`), JSON.stringify(textPart, null, 2))
-
-    return true
-  } catch {
-    return false
-  }
-}
-
-export async function resolveMessageContext(
-  sessionID: string,
-  client: OpencodeClient,
-  messageDir: string | null
-): Promise<{ prevMessage: StoredMessage | null; firstMessageAgent: string | null }> {
-  const [prevMessage, firstMessageAgent] = isSqliteBackend()
-    ? await Promise.all([
-        findNearestMessageWithFieldsFromSDK(client, sessionID),
-        findFirstMessageWithAgentFromSDK(client, sessionID),
-      ])
-    : [
-        messageDir ? findNearestMessageWithFields(messageDir) : null,
-        messageDir ? findFirstMessageWithAgent(messageDir) : null,
-      ]
-
-  return { prevMessage, firstMessageAgent }
-}

package/src/features/hook-message-injector/types.ts

@@ -1,49 +0,0 @@
-export type ToolPermission = boolean | "allow" | "deny" | "ask"
-
-export interface MessageMeta {
-  id: string
-  sessionID: string
-  role: "user" | "assistant"
-  time: {
-    created: number
-    completed?: number
-  }
-  agent?: string
-  model?: {
-    providerID: string
-    modelID: string
-    variant?: string
-  }
-  path?: {
-    cwd: string
-    root: string
-  }
-  tools?: Record<string, ToolPermission>
-}
-
-export interface OriginalMessageContext {
-  agent?: string
-  model?: {
-    providerID?: string
-    modelID?: string
-    variant?: string
-  }
-  path?: {
-    cwd?: string
-    root?: string
-  }
-  tools?: Record<string, ToolPermission>
-}
-
-export interface TextPart {
-  id: string
-  type: "text"
-  text: string
-  synthetic: boolean
-  time: {
-    start: number
-    end: number
-  }
-  messageID: string
-  sessionID: string
-}

package/src/features/mcp-oauth/AGENTS.md

@@ -1,54 +0,0 @@
-# src/features/mcp-oauth/ — OAuth 2.0 + PKCE + DCR for MCP Servers
-
-**Generated:** 2026-04-11
-
-## OVERVIEW
-
-18 files. Full OAuth 2.0 authorization flow for MCP servers requiring authentication. Implements PKCE (RFC 7636), Dynamic Client Registration (DCR, RFC 7591), and resource indicators (RFC 8707). Used by `bunx oh-my-opencode mcp-oauth login`.
-
-## AUTHORIZATION FLOW
-
-```
-1. discovery.ts → fetch /.well-known/oauth-authorization-server
-2. dcr.ts → Dynamic Client Registration (if server supports it)
-3. oauth-authorization-flow.ts → generate PKCE verifier/challenge
-4. callback-server.ts → local HTTP server on random port for redirect
-5. Open browser → authorization URL
-6. callback-server.ts → receive code + state
-7. provider.ts → exchange code for token (with PKCE verifier)
-8. storage.ts → persist token to ~/.config/opencode/mcp-oauth/
-9. step-up.ts → handle step-up auth if initial token insufficient
-```
-
-## KEY FILES
-
-| File | Purpose |
-|------|---------|
-| `oauth-authorization-flow.ts` | PKCE helpers: `generateCodeVerifier()`, `generateCodeChallenge()`, `buildAuthorizationUrl()` |
-| `callback-server.ts` | Local HTTP redirect server — listens for OAuth callback |
-| `provider.ts` | `OAuthProvider` — token exchange, refresh, revoke |
-| `discovery.ts` | Fetch + parse OAuth server metadata from well-known endpoint |
-| `dcr.ts` | Dynamic Client Registration — register this app with OAuth server |
-| `resource-indicator.ts` | RFC 8707 resource indicator handling |
-| `step-up.ts` | Handle step-up authentication challenges |
-| `storage.ts` | Persist tokens to `~/.config/opencode/mcp-oauth/{server-hash}.json` |
-| `schema.ts` | Zod schemas for OAuth server metadata, token response, DCR |
-
-## PKCE IMPLEMENTATION
-
-- Code verifier: 32 random bytes → base64url (no padding)
-- Code challenge: SHA-256(verifier) → base64url
-- Method: `S256`
-
-## TOKEN STORAGE
-
-Location: `~/.config/opencode/mcp-oauth/` — one JSON file per MCP server (keyed by server URL hash).
-Fields: `access_token`, `refresh_token`, `expires_at`, `client_id`.
-
-## CLI COMMANDS
-
-```bash
-bunx oh-my-opencode mcp-oauth login <server-url>   # Full PKCE flow
-bunx oh-my-opencode mcp-oauth logout <server-url>  # Revoke + delete token
-bunx oh-my-opencode mcp-oauth status               # List stored tokens
-```

package/src/features/mcp-oauth/callback-server.ts

@@ -1,106 +0,0 @@
-import { findAvailablePort as findAvailablePortShared } from "../../shared/port-utils"
-
-const DEFAULT_PORT = 19877
-const TIMEOUT_MS = 5 * 60 * 1000
-
-export type OAuthCallbackResult = {
-  code: string
-  state: string
-}
-
-export type CallbackServer = {
-  port: number
-  waitForCallback: () => Promise<OAuthCallbackResult>
-  close: () => void
-}
-
-const SUCCESS_HTML = `<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="utf-8">
-  <title>OAuth Authorized</title>
-  <style>
-    body { font-family: -apple-system, BlinkMacSystemFont, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #0a0a0a; color: #fafafa; }
-    .container { text-align: center; }
-    h1 { font-size: 1.5rem; margin-bottom: 0.5rem; }
-    p { color: #888; }
-  </style>
-</head>
-<body>
-  <div class="container">
-    <h1>Authorization successful</h1>
-    <p>You can close this window and return to your terminal.</p>
-  </div>
-</body>
-</html>`
-
-export async function findAvailablePort(startPort: number = DEFAULT_PORT): Promise<number> {
-  return findAvailablePortShared(startPort)
-}
-
-export async function startCallbackServer(startPort: number = DEFAULT_PORT): Promise<CallbackServer> {
-  const requestedPort = await findAvailablePort(startPort).catch(() => 0)
-
-  let resolveCallback: ((result: OAuthCallbackResult) => void) | null = null
-  let rejectCallback: ((error: Error) => void) | null = null
-
-  const callbackPromise = new Promise<OAuthCallbackResult>((resolve, reject) => {
-    resolveCallback = resolve
-    rejectCallback = reject
-  })
-
-  const timeoutId = setTimeout(() => {
-    rejectCallback?.(new Error("OAuth callback timed out after 5 minutes"))
-    server.stop(true)
-  }, TIMEOUT_MS)
-
-  const server = Bun.serve({
-    port: requestedPort,
-    hostname: "127.0.0.1",
-    fetch(request: Request): Response {
-      const url = new URL(request.url)
-
-      if (url.pathname !== "/oauth/callback") {
-        return new Response("Not Found", { status: 404 })
-      }
-
-      const oauthError = url.searchParams.get("error")
-      if (oauthError) {
-        const description = url.searchParams.get("error_description") ?? oauthError
-        clearTimeout(timeoutId)
-        rejectCallback?.(new Error(`OAuth authorization failed: ${description}`))
-        setTimeout(() => server.stop(true), 100)
-        return new Response(`Authorization failed: ${description}`, { status: 400 })
-      }
-
-      const code = url.searchParams.get("code")
-      const state = url.searchParams.get("state")
-
-      if (!code || !state) {
-        clearTimeout(timeoutId)
-        rejectCallback?.(new Error("OAuth callback missing code or state parameter"))
-        setTimeout(() => server.stop(true), 100)
-        return new Response("Missing code or state parameter", { status: 400 })
-      }
-
-      resolveCallback?.({ code, state })
-      clearTimeout(timeoutId)
-
-      setTimeout(() => server.stop(true), 100)
-
-      return new Response(SUCCESS_HTML, {
-        headers: { "content-type": "text/html; charset=utf-8" },
-      })
-    },
-  })
-  const activePort = server.port ?? requestedPort
-
-  return {
-    port: activePort,
-    waitForCallback: () => callbackPromise,
-    close: () => {
-      clearTimeout(timeoutId)
-      server.stop(true)
-    },
-  }
-}