opencode-translate 0.1.2 → 0.1.3

package/src/activation/types.ts

@@ -0,0 +1,41 @@
+import type { PluginClientLike, ResolvedTranslateOptions, TranslateState } from "../constants"
+
+export const INACTIVE_ROOT_SESSION = "inactive-root"
+export const INACTIVE_CHILD_SESSION = "inactive-child"
+export const QUESTION_TOOL_ID = "question"
+
+export type CachedSessionState = TranslateState | typeof INACTIVE_ROOT_SESSION | typeof INACTIVE_CHILD_SESSION
+
+export interface ResolvedSessionState {
+  sessionActive: boolean
+  canActivate: boolean
+  state?: TranslateState
+  storedMessages: import("../constants").MessageWithPartsLike[]
+}
+
+export interface TriggerMatch {
+  partArrayIndex: number
+  eligibleIndex: number
+  keyword: string
+  offset: number
+}
+
+interface TranslatorLike {
+  translateText(input: {
+    text: string
+    sourceLanguage: string
+    targetLanguage: string
+    direction: "inbound" | "outbound"
+  }): Promise<string>
+}
+
+export interface HookDependencies {
+  translator?: TranslatorLike
+}
+
+export interface HookContext {
+  client: PluginClientLike
+  directory?: string
+  options: ResolvedTranslateOptions
+  translator: TranslatorLike
+}

package/src/activation.ts

@@ -1,633 +1 @@
-import { randomBytes } from "node:crypto"
-import type { Hooks, PluginInput, PluginOptions } from "@opencode-ai/plugin"
-import {
-  buildInboundTranslationError,
-  isTextPart,
-  isTranslateStateRecord,
-  isUserAuthoredTextPart,
-  LLM_LANGUAGE,
-  type MessageWithPartsLike,
-  NONCE_PATTERN,
-  normalizeReason,
-  PLUGIN_NAME,
-  type PluginClientLike,
-  parseTranslatorModel,
-  type ResolvedTranslateOptions,
-  resolveOptions,
-  SPEC_VERSION,
-  type StoredTextMetadata,
-  type TextPartLike,
-  type TranslateState,
-  unwrapData,
-} from "./constants"
-import { composeTranslatedAssistantText, composeTranslationFailureText, extractEnglishHistoryText } from "./formatting"
-import { getDisplayLanguageLabel } from "./labels"
-import {
-  isQuestionArgs,
-  type QuestionSnapshot,
-  type QuestionToolOutput,
-  restoreQuestionOutput,
-  snapshotQuestions,
-  translateQuestionArgs,
-} from "./question-tool"
-import { createSyntheticPartID, createTranslator, hashText } from "./translator"
-
-const INACTIVE_ROOT_SESSION = "inactive-root"
-const INACTIVE_CHILD_SESSION = "inactive-child"
-
-type CachedSessionState = TranslateState | typeof INACTIVE_ROOT_SESSION | typeof INACTIVE_CHILD_SESSION
-
-const sessionStateCache = new Map<string, CachedSessionState>()
-const questionSnapshots = new Map<string, QuestionSnapshot>()
-const QUESTION_TOOL_ID = "question"
-
-export function __resetActivationCacheForTest() {
-  sessionStateCache.clear()
-  questionSnapshots.clear()
-}
-
-interface ResolvedSessionState {
-  sessionActive: boolean
-  canActivate: boolean
-  state?: TranslateState
-  storedMessages: MessageWithPartsLike[]
-}
-
-interface TriggerMatch {
-  partArrayIndex: number
-  eligibleIndex: number
-  keyword: string
-  offset: number
-}
-
-interface HookDependencies {
-  translator?: {
-    translateText(input: {
-      text: string
-      sourceLanguage: string
-      targetLanguage: string
-      direction: "inbound" | "outbound"
-    }): Promise<string>
-  }
-}
-
-function logError(client: PluginClientLike, error: unknown) {
-  return client.app.log({
-    body: {
-      service: PLUGIN_NAME,
-      level: "error",
-      message: normalizeReason(error),
-    },
-  })
-}
-
-function createState(options: ResolvedTranslateOptions): TranslateState {
-  return {
-    translate_enabled: true,
-    translate_source_lang: options.sourceLanguage,
-    translate_display_lang: options.displayLanguage,
-    translate_llm_lang: LLM_LANGUAGE,
-    translate_nonce: randomBytes(16).toString("hex"),
-  }
-}
-
-function createActivationBannerText(options: ResolvedTranslateOptions): string {
-  const { modelID } = parseTranslatorModel(options.translatorModel)
-  return `✓ Translation mode enabled · translator: ${modelID} · source: ${options.sourceLanguage} · display: ${options.displayLanguage}`
-}
-
-function asMetadata(part: TextPartLike): StoredTextMetadata {
-  return (part.metadata ?? {}) as StoredTextMetadata
-}
-
-function extractStateFromMetadata(metadata: StoredTextMetadata | undefined): TranslateState | undefined {
-  if (!isTranslateStateRecord(metadata)) return undefined
-  return {
-    translate_enabled: true,
-    translate_source_lang: metadata.translate_source_lang,
-    translate_display_lang: metadata.translate_display_lang,
-    translate_llm_lang: LLM_LANGUAGE,
-    translate_nonce: metadata.translate_nonce,
-  }
-}
-
-export function extractStoredState(messages: MessageWithPartsLike[]): TranslateState | undefined {
-  let fallback: TranslateState | undefined
-
-  for (const message of messages) {
-    for (const part of message.parts) {
-      if (!isTextPart(part)) continue
-      const metadata = asMetadata(part)
-      const state = extractStateFromMetadata(metadata)
-      if (!state) continue
-      if (metadata.translate_role === "activation_banner") return state
-      if (message.info.role === "user" && part.synthetic !== true && fallback === undefined) {
-        fallback = state
-      }
-    }
-  }
-
-  return fallback
-}
-
-function mergeTranslatedMetadata(state: TranslateState, part: TextPartLike, english: string): Record<string, unknown> {
-  return {
-    ...(part.metadata ?? {}),
-    ...state,
-    translate_source_hash: hashText(part.text ?? ""),
-    translate_en: english,
-  }
-}
-
-// OpenCode's flag semantics are not uniform across every UI path:
-//   synthetic: true  -> hidden from the user UI, still sent to the LLM
-//   ignored: true    -> hidden from the LLM, still shown in the main message UI
-//   both true        -> hidden from both (used for metadata-only marker
-//                       parts like the activation banner that exist purely
-//                       to carry state across reloads)
-// Some secondary UIs, including the web `/fork` dialog, only consider text
-// parts that are neither synthetic nor ignored. Persist translated user display
-// parts as non-ignored so those flows can find them; before model serialization,
-// `experimental.chat.messages.transform` marks those display parts ignored and
-// lets the synthetic English twins carry the actual prompt text.
-// The plugin's user-facing status text (translation preview, activation
-// banner, failure notice) lives inline on the source-language user part
-// itself rather than as sibling parts, because OpenCode's
-// `UserMessageDisplay` renders only the first non-synthetic text part
-// per user message.
-
-// LLM-only text part: hidden from the TUI but the only LLM-visible
-// representation of the user's source-language text. The original
-// user-authored part is marked `ignored:true` in the model-bound transform so
-// the LLM never sees it, and this synthetic English twin carries the actual
-// prompt content.
-function createLlmOnlyTextPart(
-  sessionID: string,
-  messageID: string,
-  text: string,
-  metadata: Record<string, unknown>,
-): TextPartLike {
-  return {
-    id: createSyntheticPartID(),
-    sessionID,
-    messageID,
-    type: "text",
-    text,
-    synthetic: true,
-    ignored: false,
-    metadata,
-  }
-}
-
-function isTranslatedUserDisplayPart(part: TextPartLike): boolean {
-  if (!isTextPart(part) || part.synthetic === true) return false
-  return extractStateFromMetadata(asMetadata(part)) !== undefined
-}
-
-function escapeRegex(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-}
-
-export function findTriggerMatch(parts: TextPartLike[], triggerKeywords: string[]): TriggerMatch | undefined {
-  let eligibleIndex = 0
-  for (let partArrayIndex = 0; partArrayIndex < parts.length; partArrayIndex += 1) {
-    const part = parts[partArrayIndex]
-    if (!isUserAuthoredTextPart(part)) continue
-
-    let bestForPart: TriggerMatch | undefined
-    for (let keywordIndex = 0; keywordIndex < triggerKeywords.length; keywordIndex += 1) {
-      const keyword = triggerKeywords[keywordIndex]
-      const pattern = new RegExp(`(^|[ \\t\\r\\n\\f\\v])${escapeRegex(keyword)}(?=$|[ \\t\\r\\n\\f\\v])`)
-      const match = pattern.exec(part.text)
-      if (!match) continue
-      const offset = match.index + match[1].length
-      if (!bestForPart || offset < bestForPart.offset) {
-        bestForPart = {
-          partArrayIndex,
-          eligibleIndex,
-          keyword,
-          offset,
-        }
-      }
-    }
-
-    if (bestForPart) return bestForPart
-    eligibleIndex += 1
-  }
-
-  return undefined
-}
-
-export function stripTriggerKeyword(text: string, keyword: string, offset: number): string {
-  const lineStart = text.lastIndexOf("\n", offset - 1) + 1
-  const nextNewline = text.indexOf("\n", offset)
-  const lineEnd = nextNewline === -1 ? text.length : nextNewline
-  const line = text.slice(lineStart, lineEnd)
-  const localOffset = offset - lineStart
-
-  let rewrittenLine: string
-  if (localOffset === 0 && line.startsWith(`${keyword} `)) {
-    rewrittenLine = line.slice(keyword.length + 1)
-  } else if (
-    localOffset + keyword.length === line.length &&
-    localOffset > 0 &&
-    line.slice(localOffset - 1, localOffset) === " "
-  ) {
-    rewrittenLine = line.slice(0, localOffset - 1)
-  } else if (
-    localOffset > 0 &&
-    line.slice(localOffset - 1, localOffset) === " " &&
-    line.slice(localOffset + keyword.length, localOffset + keyword.length + 1) === " "
-  ) {
-    rewrittenLine = `${line.slice(0, localOffset - 1)} ${line.slice(localOffset + keyword.length + 1)}`
-  } else {
-    rewrittenLine = `${line.slice(0, localOffset)}${line.slice(localOffset + keyword.length)}`
-  }
-
-  return `${text.slice(0, lineStart)}${rewrittenLine}${text.slice(lineEnd)}`
-}
-
-async function resolveSessionState(
-  client: PluginClientLike,
-  directory: string | undefined,
-  sessionID: string,
-): Promise<ResolvedSessionState> {
-  const cached = sessionStateCache.get(sessionID)
-  if (cached !== undefined) {
-    if (cached === INACTIVE_ROOT_SESSION) {
-      return {
-        sessionActive: false,
-        canActivate: true,
-        storedMessages: [],
-      }
-    }
-
-    if (cached === INACTIVE_CHILD_SESSION) {
-      return {
-        sessionActive: false,
-        canActivate: false,
-        storedMessages: [],
-      }
-    }
-
-    return {
-      sessionActive: true,
-      canActivate: false,
-      state: cached,
-      storedMessages: [],
-    }
-  }
-
-  const session = unwrapData(
-    await client.session.get({
-      path: { id: sessionID },
-      query: { ...(directory ? { directory } : {}) },
-      throwOnError: true,
-    }),
-  )
-  if (session.parentID != null) {
-    sessionStateCache.set(sessionID, INACTIVE_CHILD_SESSION)
-    return { sessionActive: false, canActivate: false, storedMessages: [] }
-  }
-
-  const storedMessages = unwrapData(
-    await client.session.messages({
-      path: { id: sessionID },
-      query: { ...(directory ? { directory } : {}) },
-      throwOnError: true,
-    }),
-  )
-  const state = extractStoredState(storedMessages)
-  if (state) {
-    sessionStateCache.set(sessionID, state)
-  } else {
-    sessionStateCache.set(sessionID, INACTIVE_ROOT_SESSION)
-  }
-
-  return {
-    sessionActive: Boolean(state),
-    canActivate: !state,
-    state: state ?? undefined,
-    storedMessages,
-  }
-}
-
-export function createHooks(ctx: PluginInput, rawOptions: PluginOptions = {}, deps: HookDependencies = {}): Hooks {
-  if (process.env.OPENCODE_TRANSLATE_DISABLE === "1") {
-    return {}
-  }
-
-  const client = ctx.client as unknown as PluginClientLike
-  const options = resolveOptions(rawOptions)
-  const translator = deps.translator ?? createTranslator(client, options)
-
-  return {
-    "chat.message": async (input, output) => {
-      // Hooks must never throw. A thrown error propagates into OpenCode's
-      // Effect runtime as a defect, kills the fiber, and stalls the session —
-      // to the user this looks like infinite loading with no error message.
-      // Instead, we log the failure and fall back to the untranslated text so
-      // the chat keeps moving.
-      try {
-        const resolved = await resolveSessionState(client, ctx.directory, input.sessionID)
-        let activeState = resolved.state
-        let activatedThisTurn = false
-
-        if (!activeState && resolved.canActivate) {
-          const match = findTriggerMatch(output.parts as TextPartLike[], options.triggerKeywords)
-          if (match) {
-            const part = output.parts[match.partArrayIndex] as TextPartLike & { text: string }
-            const originalText = part.text
-            part.text = stripTriggerKeyword(part.text, match.keyword, match.offset)
-            activeState = createState(options)
-            if (!NONCE_PATTERN.test(activeState.translate_nonce)) {
-              part.text = originalText
-              await logError(client, new Error("Generated invalid translation nonce"))
-              return
-            }
-            activatedThisTurn = true
-            sessionStateCache.set(input.sessionID, activeState)
-          }
-        }
-
-        if (!activeState) return
-
-        const nextParts: TextPartLike[] = []
-        let eligibleIndex = 0
-        const translationErrors: { part: TextPartLike; error: unknown }[] = []
-        // Track the first user-authored text part so the activation
-        // banner can be inlined onto it. OpenCode's `UserMessageDisplay`
-        // renders only the first non-synthetic text part per user
-        // message, so any standalone banner part is never visible in
-        // the TUI.
-        let firstUserTextPart: (TextPartLike & { text: string }) | undefined
-
-        for (const part of output.parts as TextPartLike[]) {
-          nextParts.push(part)
-          if (!isUserAuthoredTextPart(part)) continue
-
-          if (firstUserTextPart === undefined) {
-            firstUserTextPart = part
-          }
-
-          const currentEligibleIndex = eligibleIndex
-          eligibleIndex += 1
-          if (part.text.trim().length === 0) continue
-
-          try {
-            const english = await translator.translateText({
-              text: part.text,
-              sourceLanguage: activeState.translate_source_lang,
-              targetLanguage: LLM_LANGUAGE,
-              direction: "inbound",
-            })
-
-            const sourceHash = hashText(part.text)
-            // Compute metadata against the ORIGINAL `part.text` so the
-            // stored `translate_source_hash` keeps a stable round-trip
-            // identity even after we splice the preview into the part
-            // text below.
-            part.metadata = {
-              ...(part.metadata ?? {}),
-              ...mergeTranslatedMetadata(activeState, part, english),
-            }
-            // Inline the `→ EN: ...` preview into the source-language
-            // part. OpenCode's `UserMessageDisplay`
-            // (packages/ui/src/components/message-part.tsx) renders only
-            // ONE text part per user message — the first non-synthetic —
-            // so a sibling `synthetic:false + ignored:true` preview part
-            // would never reach the screen. Combining them here keeps
-            // the original visible alongside the English twin while still
-            // satisfying secondary UI filters like `/fork`, which require
-            // non-synthetic, non-ignored text. The transform hook marks this
-            // display part ignored in the model-bound copy.
-            part.text = `${part.text}\n\n_→ EN: ${english}_`
-
-            // LLM-only English twin. This is the actual prompt the model
-            // sees in place of the source-language display part.
-            nextParts.push(
-              createLlmOnlyTextPart(part.sessionID, part.messageID, english, {
-                translate_role: "llm_only_translation",
-                translate_nonce: activeState.translate_nonce,
-                translate_source_hash: sourceHash,
-                translate_part_index: currentEligibleIndex,
-              }),
-            )
-          } catch (error) {
-            // Translation failed. Append a visible warning to the
-            // source-language part (same UI constraint as the success
-            // path: only one text part per user message renders) and
-            // route the original, untranslated text to the LLM via a
-            // dedicated fallback twin so the model still gets a clean
-            // prompt without the warning text leaking into context.
-            translationErrors.push({ part, error })
-            const reason = normalizeReason(error)
-            const wrapped = buildInboundTranslationError(activeState.translate_source_lang, reason)
-            await logError(client, wrapped)
-
-            const originalText = part.text
-            part.text = `${originalText}\n\n_⚠️ Translation failed: ${reason}. Original text was sent to the model._`
-            part.ignored = true
-
-            nextParts.push(
-              createLlmOnlyTextPart(part.sessionID, part.messageID, originalText, {
-                translate_role: "llm_only_fallback",
-                translate_nonce: activeState.translate_nonce,
-                translate_part_index: currentEligibleIndex,
-              }),
-            )
-          }
-        }
-
-        // If we activated this turn but translation failed for every
-        // user-authored part, roll back activation so the next turn does a
-        // clean retry instead of cementing broken state.
-        if (activatedThisTurn && translationErrors.length > 0 && eligibleIndex === translationErrors.length) {
-          sessionStateCache.set(input.sessionID, INACTIVE_ROOT_SESSION)
-          return
-        }
-
-        if (activatedThisTurn) {
-          const bannerText = createActivationBannerText(options)
-          // Inline the activation banner into the first user-authored
-          // text part so it actually reaches the TUI (see comment above
-          // for the single-text-part rendering constraint). The banner
-          // sits underneath the inline `→ EN: ...` preview that was
-          // appended during translation, giving the user a one-time
-          // confirmation that translation mode just turned on.
-          if (firstUserTextPart !== undefined) {
-            firstUserTextPart.text = `${firstUserTextPart.text}\n\n_${bannerText}_`
-          }
-          // Also emit the banner as a metadata-only synthetic part so
-          // `extractStoredState`'s canonical `translate_role ===
-          // "activation_banner"` marker is preserved across reloads.
-          // `synthetic:true + ignored:true` keeps it hidden from both
-          // the TUI and the LLM serializer; it exists purely as a
-          // database row carrying state metadata.
-          nextParts.push({
-            id: createSyntheticPartID(),
-            sessionID: input.sessionID,
-            messageID: output.message.id,
-            type: "text",
-            text: bannerText,
-            synthetic: true,
-            ignored: true,
-            metadata: {
-              ...activeState,
-              translate_role: "activation_banner",
-              translate_spec_version: SPEC_VERSION,
-            },
-          })
-        }
-
-        output.parts.splice(0, output.parts.length, ...(nextParts as typeof output.parts))
-      } catch (error) {
-        await logError(client, error)
-      }
-    },
-    "experimental.chat.messages.transform": async (_input, output) => {
-      try {
-        const sessionID = output.messages[0]?.info.sessionID
-        if (!sessionID) return
-
-        const resolved = await resolveSessionState(client, ctx.directory, sessionID)
-        const activeState = resolved.state
-        if (!activeState) return
-
-        for (const message of output.messages as MessageWithPartsLike[]) {
-          if (message.info.role === "user") {
-            for (const part of message.parts) {
-              if (!isTranslatedUserDisplayPart(part)) continue
-              part.ignored = true
-            }
-            continue
-          }
-
-          if (message.info.role !== "assistant") continue
-          for (const part of message.parts) {
-            if (!isTextPart(part)) continue
-            part.text = extractEnglishHistoryText(part.text, activeState.translate_nonce)
-          }
-        }
-      } catch (error) {
-        await logError(client, error)
-      }
-    },
-    "experimental.text.complete": async (input, output) => {
-      try {
-        const resolved = await resolveSessionState(client, ctx.directory, input.sessionID)
-        const activeState = resolved.state
-        if (!activeState) return
-
-        const message = unwrapData(
-          await client.session.message({
-            path: { id: input.sessionID, messageID: input.messageID },
-            query: { ...(ctx.directory ? { directory: ctx.directory } : {}) },
-            throwOnError: true,
-          }),
-        ) as MessageWithPartsLike & { info: Record<string, unknown> }
-
-        if (message.info.role !== "assistant") return
-        if (message.info.summary === true) return
-        if (activeState.translate_display_lang === LLM_LANGUAGE || output.text.length === 0) return
-
-        try {
-          const translated = await translator.translateText({
-            text: output.text,
-            sourceLanguage: LLM_LANGUAGE,
-            targetLanguage: activeState.translate_display_lang,
-            direction: "outbound",
-          })
-
-          output.text = composeTranslatedAssistantText(
-            output.text,
-            getDisplayLanguageLabel(activeState.translate_display_lang),
-            translated,
-            activeState.translate_nonce,
-          )
-        } catch (error) {
-          output.text = composeTranslationFailureText(output.text, activeState.translate_nonce)
-          await logError(client, error)
-        }
-      } catch (error) {
-        await logError(client, error)
-      }
-    },
-    // Translate the built-in `question` tool so the TUI dialog renders in
-    // the user's displayLanguage. The tool output string is restored back
-    // to English in `tool.execute.after`; typed custom answers also go
-    // through the inbound user-message translation path.
-    "tool.execute.before": async (input, output) => {
-      try {
-        if (input.tool !== QUESTION_TOOL_ID) return
-        const resolved = await resolveSessionState(client, ctx.directory, input.sessionID)
-        const activeState = resolved.state
-        if (!activeState) return
-
-        const args = output.args as unknown
-        if (!isQuestionArgs(args)) return
-
-        const original = snapshotQuestions(args)
-        if (activeState.translate_display_lang !== LLM_LANGUAGE) {
-          try {
-            await translateQuestionArgs(args, (text) =>
-              translator.translateText({
-                text,
-                sourceLanguage: LLM_LANGUAGE,
-                targetLanguage: activeState.translate_display_lang,
-                direction: "outbound",
-              }),
-            )
-          } catch (error) {
-            // Translation failed: restore the originals so the dialog at least
-            // renders in English instead of a half-translated mess.
-            args.questions.splice(0, args.questions.length, ...snapshotQuestions({ questions: original }))
-            await logError(client, error)
-            return
-          }
-        }
-
-        const translated = snapshotQuestions(args)
-        questionSnapshots.set(input.callID, { original, translated })
-      } catch (error) {
-        await logError(client, error)
-      }
-    },
-    "tool.execute.after": async (input, output) => {
-      try {
-        if (input.tool !== QUESTION_TOOL_ID) return
-        const snapshot = questionSnapshots.get(input.callID)
-        if (!snapshot) return
-        questionSnapshots.delete(input.callID)
-        const resolved = await resolveSessionState(client, ctx.directory, input.sessionID)
-        const activeState = resolved.state
-        const translateCustomAnswer =
-          activeState && activeState.translate_source_lang !== LLM_LANGUAGE
-            ? (text: string) =>
-                translator.translateText({
-                  text,
-                  sourceLanguage: activeState.translate_source_lang,
-                  targetLanguage: LLM_LANGUAGE,
-                  direction: "inbound",
-                })
-            : undefined
-
-        await restoreQuestionOutput(output as QuestionToolOutput, snapshot, {
-          ...(translateCustomAnswer ? { translateCustomAnswer } : {}),
-          onTranslationError: async (error) => {
-            if (!activeState) {
-              await logError(client, error)
-              return
-            }
-            await logError(
-              client,
-              buildInboundTranslationError(activeState.translate_source_lang, normalizeReason(error)),
-            )
-          },
-        })
-      } catch (error) {
-        await logError(client, error)
-      }
-    },
-  }
-}
+export * from "./activation/index"

package/src/anthropic-oauth.ts

@@ -22,10 +22,10 @@ import { createHash } from "node:crypto"
 
 export const CLAUDE_CODE_IDENTITY = "You are a Claude agent, built on Anthropic's Claude Agent SDK."
 
-export const REQUIRED_BETAS = ["oauth-2025-04-20", "interleaved-thinking-2025-05-14"] as const
+const REQUIRED_BETAS = ["oauth-2025-04-20", "interleaved-thinking-2025-05-14"] as const
 
-export const CLAUDE_CODE_VERSION = "2.1.87"
-export const CLAUDE_CODE_ENTRYPOINT = "sdk-cli"
+const CLAUDE_CODE_VERSION = "2.1.87"
+const CLAUDE_CODE_ENTRYPOINT = "sdk-cli"
 export const CLAUDE_CLI_USER_AGENT = `claude-cli/${CLAUDE_CODE_VERSION} (external, cli)`
 
 // Deterministic billing header parameters — must match Claude Code's own derivation.