@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/features/context-injector/types.ts

@@ -1,91 +0,0 @@
-/**
- * Source identifier for context injection
- * Each source registers context that will be merged and injected together
- */
-export type ContextSourceType =
-  | "keyword-detector"
-  | "rules-injector"
-  | "directory-agents"
-  | "directory-readme"
-  | "custom"
-
-/**
- * Priority levels for context ordering
- * Higher priority contexts appear first in the merged output
- */
-export type ContextPriority = "critical" | "high" | "normal" | "low"
-
-/**
- * A single context entry registered by a source
- */
-export interface ContextEntry {
-  /** Unique identifier for this entry within the source */
-  id: string
-  /** The source that registered this context */
-  source: ContextSourceType
-  /** The actual context content to inject */
-  content: string
-  /** Priority for ordering (default: normal) */
-  priority: ContextPriority
-  /** Monotonic order when registered */
-  registrationOrder: number
-  /** Optional metadata for debugging/logging */
-  metadata?: Record<string, unknown>
-}
-
-/**
- * Options for registering context
- */
-export interface RegisterContextOptions {
-  /** Unique ID for this context entry (used for deduplication) */
-  id: string
-  /** Source identifier */
-  source: ContextSourceType
-  /** The content to inject */
-  content: string
-  /** Priority for ordering (default: normal) */
-  priority?: ContextPriority
-  /** Optional metadata */
-  metadata?: Record<string, unknown>
-}
-
-/**
- * Result of getting pending context for a session
- */
-export interface PendingContext {
-  /** Merged context string, ready for injection */
-  merged: string
-  /** Individual entries that were merged */
-  entries: ContextEntry[]
-  /** Whether there's any content to inject */
-  hasContent: boolean
-}
-
-/**
- * Message context from the original user message
- * Used when injecting to match the message format
- */
-export interface MessageContext {
-  agent?: string
-  model?: {
-    providerID?: string
-    modelID?: string
-  }
-  path?: {
-    cwd?: string
-    root?: string
-  }
-  tools?: Record<string, boolean>
-}
-
-/**
- * Output parts from chat.message hook
- */
-export interface OutputParts {
-  parts: Array<{ type: string; text?: string; [key: string]: unknown }>
-}
-
-/**
- * Injection strategy
- */
-export type InjectionStrategy = "prepend-parts" | "storage" | "auto"

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

@@ -1 +0,0 @@
-export { OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE } from "../../shared"

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

@@ -1,11 +0,0 @@
-export {
-  injectHookMessage,
-  findNearestMessageWithFields,
-  findFirstMessageWithAgent,
-  findNearestMessageWithFieldsFromSDK,
-  findFirstMessageWithAgentFromSDK,
-  resolveMessageContext,
-} from "./injector"
-export type { StoredMessage } from "./injector"
-export type { MessageMeta, OriginalMessageContext, TextPart, ToolPermission } from "./types"
-export { MESSAGE_STORAGE } from "./constants"

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
-```