opencode-translate 1.0.6 → 1.0.7

package/src/activation/text-complete.ts

@@ -1,50 +0,0 @@
-import type { Hooks } from "@opencode-ai/plugin"
-import { LLM_LANGUAGE, type MessageWithPartsLike, unwrapData } from "../constants"
-import { composeTranslatedAssistantText, composeTranslationFailureText } from "../formatting"
-import { getDisplayLanguageLabel } from "../labels"
-import { logError } from "./logging"
-import { resolveSessionState } from "./state"
-import type { HookContext } from "./types"
-
-type TextCompleteHook = NonNullable<Hooks["experimental.text.complete"]>
-
-export function createTextCompleteHook(ctx: HookContext): TextCompleteHook {
-  return async (input, output) => {
-    try {
-      const resolved = await resolveSessionState(ctx.client, ctx.directory, input.sessionID)
-      const activeState = resolved.state
-      if (!activeState) return
-
-      const message = unwrapData(
-        await ctx.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_user_lang === LLM_LANGUAGE || output.text.length === 0) return
-
-      try {
-        const translated = await ctx.translator.translateText({
-          text: output.text,
-          sourceLanguage: LLM_LANGUAGE,
-          targetLanguage: activeState.translate_user_lang,
-          direction: "outbound",
-        })
-        output.text = composeTranslatedAssistantText(
-          output.text,
-          getDisplayLanguageLabel(activeState.translate_user_lang),
-          translated,
-        )
-      } catch (error) {
-        output.text = composeTranslationFailureText(output.text)
-        await logError(ctx.client, error)
-      }
-    } catch (error) {
-      await logError(ctx.client, error)
-    }
-  }
-}

package/src/activation/trigger.ts

@@ -1,57 +0,0 @@
-import { isUserAuthoredTextPart, type TextPartLike } from "../constants"
-import type { TriggerMatch } from "./types"
-
-function escapeRegex(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-}
-
-export function findTriggerMatch(parts: TextPartLike[], trigger: 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 (const keyword of trigger) {
-      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)}`
-}

package/src/activation/types.ts

@@ -1,47 +0,0 @@
-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>
-  translateTexts?(input: {
-    texts: readonly string[]
-    sourceLanguage: string
-    targetLanguage: string
-    direction: "inbound" | "outbound"
-  }): Promise<readonly string[]>
-}
-
-export interface HookDependencies {
-  translator?: TranslatorLike
-}
-
-export interface HookContext {
-  client: PluginClientLike
-  directory?: string
-  options: ResolvedTranslateOptions
-  translator: TranslatorLike
-}

package/src/activation.ts

@@ -1 +0,0 @@
-export * from "./activation/index"

package/src/anthropic-oauth.ts

@@ -1,148 +0,0 @@
-// Anthropic OAuth request transformations.
-//
-// When using Anthropic's OAuth credentials (Claude Pro/Max) outside of the
-// official Claude Code client, the /v1/messages API responds with a
-// `429 rate_limit_error` and an empty "Error" message unless the request
-// shape matches the Claude Code CLI fingerprint: specific headers, a
-// `?beta=true` query, the Claude Code identity in `system[0]`, and a
-// deterministic billing header block.
-//
-// This module implements the minimum transformation that makes translator
-// requests pass those checks. The technique (including the identity string,
-// required beta headers, and CCH billing header format) is documented by the
-// `@ex-machina/opencode-anthropic-auth` plugin:
-//
-//   https://github.com/ex-machina-co/opencode-anthropic-auth
-//
-// We only apply these transformations to translator requests this plugin
-// originates. OpenCode's main chat already has its own auth loader (e.g.
-// `@ex-machina/opencode-anthropic-auth`) handling its requests independently.
-
-import { createHash } from "node:crypto"
-
-export const CLAUDE_CODE_IDENTITY = "You are a Claude agent, built on Anthropic's Claude Agent SDK."
-
-const REQUIRED_BETAS = ["oauth-2025-04-20", "interleaved-thinking-2025-05-14"] as const
-
-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.
-const CCH_SALT = "59cf53e54c78"
-const CCH_POSITIONS = [4, 7, 20] as const
-
-type SystemBlock = { type: string; text: string; [key: string]: unknown }
-
-type MessageLike = {
-  role?: string
-  content?: string | Array<{ type?: string; text?: string }>
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value != null && typeof value === "object" && !Array.isArray(value)
-}
-
-function extractFirstUserMessageText(messages: MessageLike[] | undefined): string {
-  if (!Array.isArray(messages)) return ""
-  const first = messages.find((message) => message?.role === "user")
-  if (!first) return ""
-  const { content } = first
-  if (typeof content === "string") return content
-  if (Array.isArray(content)) {
-    const textBlock = content.find((block) => block?.type === "text")
-    if (textBlock?.text) return textBlock.text
-  }
-  return ""
-}
-
-function computeCCH(messageText: string): string {
-  return createHash("sha256").update(messageText).digest("hex").slice(0, 5)
-}
-
-function computeVersionSuffix(messageText: string, version: string): string {
-  const chars = CCH_POSITIONS.map((index) => messageText[index] ?? "0").join("")
-  return createHash("sha256").update(`${CCH_SALT}${chars}${version}`).digest("hex").slice(0, 3)
-}
-
-export function buildBillingHeaderValue(messages: MessageLike[] | undefined): string {
-  const text = extractFirstUserMessageText(messages)
-  const cch = computeCCH(text)
-  const suffix = computeVersionSuffix(text, CLAUDE_CODE_VERSION)
-  return (
-    "x-anthropic-billing-header: " +
-    `cc_version=${CLAUDE_CODE_VERSION}.${suffix}; ` +
-    `cc_entrypoint=${CLAUDE_CODE_ENTRYPOINT}; ` +
-    `cch=${cch};`
-  )
-}
-
-export function mergeBetaHeaders(headers: Headers): string {
-  const incoming = headers.get("anthropic-beta") || ""
-  const incomingList = incoming
-    .split(",")
-    .map((value) => value.trim())
-    .filter(Boolean)
-  return [...new Set([...REQUIRED_BETAS, ...incomingList])].join(",")
-}
-
-export function setOAuthHeaders(headers: Headers, accessToken: string): Headers {
-  headers.set("authorization", `Bearer ${accessToken}`)
-  headers.set("anthropic-beta", mergeBetaHeaders(headers))
-  headers.set("user-agent", CLAUDE_CLI_USER_AGENT)
-  headers.delete("x-api-key")
-  return headers
-}
-
-export function rewriteMessagesURL(input: URL): URL {
-  if (input.pathname === "/v1/messages" && !input.searchParams.has("beta")) {
-    input.searchParams.set("beta", "true")
-  }
-  return input
-}
-
-function normalizeSystem(raw: unknown): SystemBlock[] {
-  if (raw == null) return []
-  if (typeof raw === "string") return raw.length > 0 ? [{ type: "text", text: raw }] : []
-  if (isRecord(raw)) {
-    const type = typeof raw.type === "string" ? raw.type : "text"
-    const text = typeof raw.text === "string" ? raw.text : ""
-    return [{ ...raw, type, text }]
-  }
-  if (!Array.isArray(raw)) return []
-  return raw
-    .map((item): SystemBlock | null => {
-      if (typeof item === "string") return { type: "text", text: item }
-      if (isRecord(item) && typeof item.text === "string") {
-        const type = typeof item.type === "string" ? item.type : "text"
-        return { ...item, type, text: item.text }
-      }
-      return null
-    })
-    .filter((block): block is SystemBlock => block !== null)
-}
-
-export function buildOAuthSystem(rawSystem: unknown, messages: MessageLike[] | undefined): SystemBlock[] {
-  const identity: SystemBlock = { type: "text", text: CLAUDE_CODE_IDENTITY }
-  const existing = normalizeSystem(rawSystem).filter((block) => block.text !== CLAUDE_CODE_IDENTITY)
-  const billing: SystemBlock = { type: "text", text: buildBillingHeaderValue(messages) }
-  return [billing, identity, ...existing]
-}
-
-// Rewrite an /v1/messages POST body so its system prompt and billing header
-// satisfy Claude Code's OAuth fingerprint. Returns the original body on parse
-// failure so we never break a request that was already well-formed.
-export function rewriteMessagesBody(body: string): string {
-  try {
-    const parsed = JSON.parse(body) as Record<string, unknown>
-    const messages = Array.isArray(parsed.messages) ? (parsed.messages as MessageLike[]) : undefined
-    parsed.system = buildOAuthSystem(parsed.system, messages)
-    return JSON.stringify(parsed)
-  } catch {
-    return body
-  }
-}
-
-export function isAnthropicMessagesRequest(url: URL): boolean {
-  return url.pathname === "/v1/messages"
-}

package/src/auth/codex-request.ts

@@ -1,108 +0,0 @@
-import { isRecord } from "./codex-shared"
-import type { CodexBodyRewrite } from "./types"
-
-function textFromContent(content: unknown): string | undefined {
-  if (typeof content === "string") return content
-  if (!Array.isArray(content)) return undefined
-
-  const text = content
-    .map((part) => (isRecord(part) && typeof part.text === "string" ? part.text : undefined))
-    .filter((value): value is string => value !== undefined)
-    .join("\n")
-
-  return text || undefined
-}
-
-function normalizeCodexContent(role: string, content: unknown): Record<string, unknown>[] {
-  const textType = role === "assistant" ? "output_text" : "input_text"
-  if (typeof content === "string") return [{ type: textType, text: content }]
-  if (!Array.isArray(content)) return []
-
-  const result: Record<string, unknown>[] = []
-  for (const part of content) {
-    if (!isRecord(part)) continue
-    const type = part.type
-    if (type === "input_text" || type === "output_text") {
-      result.push({ ...part, type: textType })
-      continue
-    }
-    if (type === "input_image") {
-      result.push({ ...part })
-      continue
-    }
-    if (typeof part.text === "string") result.push({ type: textType, text: part.text })
-  }
-
-  return result
-}
-
-function normalizeCodexInputItem(item: unknown, instructions: string[]): unknown | undefined {
-  if (!isRecord(item)) return item
-  const role = typeof item.role === "string" ? item.role : undefined
-
-  if (role === "system" || role === "developer") {
-    const text = textFromContent(item.content)
-    if (text) instructions.push(text)
-    return undefined
-  }
-
-  if (item.type === "message" && role) {
-    const content = normalizeCodexContent(role, item.content)
-    return content.length > 0 ? { ...item, role, content } : undefined
-  }
-
-  if (role) {
-    const content = normalizeCodexContent(role, item.content)
-    return content.length > 0 ? { type: "message", role, content } : undefined
-  }
-
-  return item
-}
-
-export function rewriteOpenAICodexBody(body: BodyInit | null | undefined): CodexBodyRewrite {
-  if (typeof body !== "string") return { body, originalStream: false }
-
-  let parsed: unknown
-  try {
-    parsed = JSON.parse(body)
-  } catch {
-    return { body, originalStream: false }
-  }
-
-  if (!isRecord(parsed)) return { body, originalStream: false }
-  const originalStream = parsed.stream === true
-  const sourceInput = Array.isArray(parsed.input)
-    ? parsed.input
-    : Array.isArray(parsed.messages)
-      ? parsed.messages
-      : undefined
-  if (!sourceInput) return { body, originalStream }
-
-  const instructions: string[] = []
-  if (typeof parsed.instructions === "string" && parsed.instructions) instructions.push(parsed.instructions)
-  const input = sourceInput
-    .map((item) => normalizeCodexInputItem(item, instructions))
-    .filter((item): item is unknown => item !== undefined)
-  const include = Array.isArray(parsed.include)
-    ? parsed.include.filter((item): item is string => typeof item === "string")
-    : []
-  if (!include.includes("reasoning.encrypted_content")) include.push("reasoning.encrypted_content")
-
-  return {
-    body: JSON.stringify({
-      ...parsed,
-      instructions: instructions.join("\n\n"),
-      input,
-      tools: Array.isArray(parsed.tools) ? parsed.tools : [],
-      tool_choice: typeof parsed.tool_choice === "string" ? parsed.tool_choice : "auto",
-      parallel_tool_calls: typeof parsed.parallel_tool_calls === "boolean" ? parsed.parallel_tool_calls : false,
-      store: false,
-      stream: true,
-      include,
-      max_output_tokens: undefined,
-      max_completion_tokens: undefined,
-      messages: undefined,
-    }),
-    originalStream,
-  }
-}

package/src/auth/codex-response.ts

@@ -1,78 +0,0 @@
-import { isRecord } from "./codex-shared"
-
-function normalizeCodexOutputItem(item: unknown, index: number): unknown | undefined {
-  if (!isRecord(item)) return undefined
-  if (item.type !== "message" || item.role !== "assistant") return item
-  if (!Array.isArray(item.content)) return undefined
-
-  const content: Record<string, unknown>[] = []
-  for (const part of item.content) {
-    if (!isRecord(part) || part.type !== "output_text" || typeof part.text !== "string") continue
-    content.push({ ...part, annotations: Array.isArray(part.annotations) ? part.annotations : [] })
-  }
-
-  if (content.length === 0) return undefined
-  return {
-    ...item,
-    id: typeof item.id === "string" ? item.id : `msg_opencode_translate_${index}`,
-    role: "assistant",
-    content,
-  }
-}
-
-function buildCodexTextOutput(text: string): Record<string, unknown> {
-  return {
-    type: "message",
-    id: "msg_opencode_translate_0",
-    role: "assistant",
-    content: [{ type: "output_text", text, annotations: [] }],
-  }
-}
-
-function parseCodexSSEResponse(text: string): unknown | undefined {
-  let finalResponse: unknown
-  let deltaText = ""
-  const outputItems: unknown[] = []
-
-  for (const line of text.split(/\r?\n/)) {
-    if (!line.startsWith("data: ")) continue
-    const payload = line.slice(6).trim()
-    if (!payload || payload === "[DONE]") continue
-    try {
-      const parsed = JSON.parse(payload) as Record<string, unknown>
-      if (parsed.type === "response.output_text.delta" && typeof parsed.delta === "string") {
-        deltaText += parsed.delta
-      } else if (
-        (parsed.type === "response.output_item.done" || parsed.type === "response.output_item.added") &&
-        parsed.item
-      ) {
-        outputItems.push(parsed.item)
-      } else if ((parsed.type === "response.done" || parsed.type === "response.completed") && parsed.response) {
-        finalResponse = parsed.response
-      }
-    } catch {}
-  }
-
-  if (!finalResponse && !deltaText && outputItems.length === 0) return undefined
-  const response: Record<string, unknown> = isRecord(finalResponse)
-    ? { ...finalResponse }
-    : { id: "resp_opencode_translate" }
-  const existingOutput: unknown[] = Array.isArray(response.output) ? response.output : []
-  const sourceOutput = existingOutput.length > 0 ? existingOutput : outputItems
-  const normalizedOutput = sourceOutput
-    .map((item, index) => normalizeCodexOutputItem(item, index))
-    .filter((item): item is unknown => item !== undefined)
-
-  response.output = normalizedOutput.length > 0 ? normalizedOutput : deltaText ? [buildCodexTextOutput(deltaText)] : []
-  return response
-}
-
-export async function convertCodexSSEToJSON(response: Response): Promise<Response> {
-  const headers = new Headers(response.headers)
-  const text = await response.text()
-  const parsed = parseCodexSSEResponse(text)
-  if (!parsed) return new Response(text, { status: response.status, statusText: response.statusText, headers })
-
-  headers.set("content-type", "application/json; charset=utf-8")
-  return new Response(JSON.stringify(parsed), { status: response.status, statusText: response.statusText, headers })
-}

package/src/auth/codex-shared.ts

@@ -1,3 +0,0 @@
-export function isRecord(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === "object" && !Array.isArray(value)
-}

package/src/auth/headers.ts

@@ -1,18 +0,0 @@
-import { USER_AGENT } from "../constants"
-
-export function copyHeaders(headers?: HeadersInit): Headers {
-  return new Headers(headers)
-}
-
-export function headerValue(headers: Headers, key: string): string | undefined {
-  const value = headers.get(key)
-  return value === null ? undefined : value
-}
-
-export function packageUserAgent(packageVersion?: string): string {
-  return packageVersion ? USER_AGENT.replace("0.0.0", packageVersion) : USER_AGENT
-}
-
-export function setUserAgent(headers: Headers, packageVersion?: string) {
-  headers.set("User-Agent", packageUserAgent(packageVersion))
-}