opencode-secrets-obfuscation 0.1.0 → 0.1.1

package/src/opencode/v2/runtime.ts

@@ -1,207 +0,0 @@
-import { Effect } from "effect"
-import { randomBytes } from "node:crypto"
-import * as fs from "node:fs"
-import * as path from "node:path"
-import { Tool } from "@opencode/schema/tool"
-import type { Context } from "@opencode/plugin/effect/plugin"
-import { ActivationStore } from "../../store/index.ts"
-import { BudgetLedger } from "../../budgets/index.ts"
-import { loadDotenvFile, type DotenvSnapshot } from "../../sources/dotenv.ts"
-import { admitPatterns, type Pattern } from "../../sanitize/index.ts"
-import type { PluginOptions } from "../../config/options.ts"
-import type { CoreRuntime, CoreRuntimeFactory } from "./index.ts"
-import {
-  WITHHELD,
-  containsSecret,
-  dropMentions,
-  hasSecrets,
-  redactHeaders,
-  redactRequest,
-  redactResponse,
-  redactString,
-  redactTree,
-  type FilterState,
-} from "./filter.ts"
-
-const GENERATION = 1
-const SOURCE_TOOLS = new Set(["read", "write", "edit", "patch"])
-const PATH_KEYS = ["filePath", "file_path", "path"]
-
-interface LoadedEntry { readonly sourceId: string; readonly key: string; readonly value: string }
-
-/**
- * Transparent runtime: load private source values, assign opaque replacements,
- * and sanitize existing OpenCode surfaces. It does not register tools and it
- * never performs network I/O.
- */
-export const realRuntimeFactory: CoreRuntimeFactory = (
-  options: PluginOptions,
-  location: Context["location"],
-): Effect.Effect<CoreRuntime, never, never> => {
-  const locationDir = location.directory
-  let locationReal: string
-  try { locationReal = fs.realpathSync(locationDir) } catch { throw new Error("SOURCE_INVALID") }
-  const entries: LoadedEntry[] = []
-  let totalBytes = 0
-
-  for (const descriptor of options.sources) {
-    const resolved = path.resolve(locationDir, descriptor.path)
-    let sourceReal: string
-    try { sourceReal = fs.realpathSync(resolved) } catch { if (descriptor.required) throw new Error("SOURCE_INVALID"); continue }
-    const relativeSource = path.relative(locationReal, sourceReal)
-    if (relativeSource === ".." || relativeSource.startsWith(`..${path.sep}`) || path.isAbsolute(relativeSource)) {
-      if (descriptor.required) throw new Error("SOURCE_INVALID")
-      continue
-    }
-    let snapshot: DotenvSnapshot
-    try {
-      snapshot = loadDotenvFile(resolved, {
-        maxBytes: options.limits.sourceBytes,
-        maxEntries: options.limits.secretCount,
-        maxValueBytes: options.limits.secretBytes,
-      })
-    } catch {
-      if (descriptor.required) throw new Error("SOURCE_INVALID")
-      continue
-    }
-    for (const entry of snapshot.entries) {
-      if (!descriptor.keys.includes(entry.key) || entry.value.length === 0) continue
-      totalBytes += Buffer.byteLength(entry.value, "utf8")
-      if (totalBytes > options.limits.totalSourceBytes || entries.length >= options.limits.secretCount) throw new Error("SOURCE_INVALID")
-      entries.push({ sourceId: descriptor.id, key: entry.key, value: entry.value })
-    }
-  }
-
-  const budget = new BudgetLedger({
-    activeSessions: options.limits.activeSessions,
-    handles: options.limits.secretCount,
-    handlesPerSession: options.limits.handlesPerSession,
-    secretCount: options.limits.secretCount,
-    secretBytes: options.limits.secretBytes,
-    indexBytes: options.limits.indexBytes,
-    workingBytes: options.limits.workingBytes,
-  })
-  const store = new ActivationStore({
-    location: { directory: locationDir },
-    generation: GENERATION,
-    budget,
-    randomBytes: () => new Uint8Array(randomBytes(16)),
-  })
-
-  const handles = new Map<string, string>()
-  for (const entry of entries) if (!handles.has(entry.value)) handles.set(entry.value, store.register(entry.value))
-  const patterns: Pattern[] = []
-  for (const entry of entries) {
-    if (patterns.some((pattern) => pattern.text === entry.value)) continue
-    const replacement = handles.get(entry.value)
-    if (replacement === undefined) throw new Error("SANITIZATION_UNAVAILABLE")
-    patterns.push({ text: entry.value, replacement, entry: entry.value })
-  }
-  if (!admitPatterns(patterns).ok) throw new Error("SANITIZATION_UNAVAILABLE")
-
-  const filter: FilterState = {
-    patterns,
-    budget: {
-      maxOutputBytes: Math.min(options.limits.outputBytes, 2 * 1024 * 1024),
-      maxDepth: Math.min(options.limits.traversalDepth, 32),
-      maxNodes: Math.min(options.limits.traversalNodes, 50_000),
-      maxMatches: Math.min(options.limits.traversalNodes, 50_000),
-    },
-    maxInputBytes: options.limits.inputBytes,
-  }
-  const scanCeiling = Math.min(filter.maxInputBytes, filter.budget.maxOutputBytes)
-  const sourcePaths = new Set(options.sources.map((descriptor) => {
-    const resolved = path.resolve(locationDir, descriptor.path)
-    return process.platform === "win32" ? resolved.toLowerCase() : resolved
-  }))
-
-  const pathInput = (input: unknown): string | undefined => {
-    if (!input || typeof input !== "object") return undefined
-    const record = input as Record<string, unknown>
-    for (const key of PATH_KEYS) {
-      const value = record[key]
-      if (typeof value === "string" && value.length > 0 && value.length <= 4_096) return value
-    }
-    return undefined
-  }
-  const isSourcePath = (candidate: string): boolean => {
-    const resolved = path.resolve(locationDir, candidate)
-    return sourcePaths.has(process.platform === "win32" ? resolved.toLowerCase() : resolved)
-  }
-  const inputHasSecret = (input: unknown): boolean => {
-    if (!hasSecrets(filter) || input === undefined || input === null) return false
-    let serialized: string | undefined
-    try { serialized = JSON.stringify(input) } catch { return false }
-    return serialized !== undefined && Buffer.byteLength(serialized, "utf8") <= scanCeiling && containsSecret(serialized, filter)
-  }
-  const redactToolError = (event: { error: Tool.Error }): void => {
-    const original = event.error
-    const message = typeof original.message === "string" ? redactString(original.message, filter) : null
-    event.error = new Tool.Error({ message: message ?? WITHHELD })
-  }
-  const sanitizeValue = (value: unknown): unknown => {
-    if (typeof value === "string") return redactString(value, filter) ?? WITHHELD
-    redactTree(value, filter)
-    return value
-  }
-  const sanitizeRequestContext = (event: { system: unknown; messages: unknown; options: unknown; tools?: unknown }): void => {
-    event.system = sanitizeValue(event.system)
-    redactTree(event.messages, filter)
-    event.options = sanitizeValue(event.options)
-    if (event.tools !== undefined) event.tools = sanitizeValue(event.tools)
-  }
-
-  const runtime: CoreRuntime = {
-    close: () => Effect.sync(() => store.teardown()),
-    session: {
-      prompt: (event) => Effect.sync(() => {
-        if (!hasSecrets(filter)) return
-        let changed = redactTree(event.prompt, filter)
-        if (event.metadata !== undefined) changed = redactTree(event.metadata, filter) || changed
-        if (changed) dropMentions(event.prompt)
-      }),
-      context: (event) => Effect.sync(() => { if (hasSecrets(filter)) sanitizeRequestContext(event) }),
-      compaction: (event) => Effect.sync(() => {
-        if (!hasSecrets(filter)) return
-        sanitizeRequestContext(event)
-        if (event.result !== undefined) event.result = sanitizeValue(event.result) as typeof event.result
-      }),
-      generate: (event) => Effect.sync(() => { if (hasSecrets(filter)) sanitizeRequestContext(event) }),
-      title: (event) => Effect.sync(() => {
-        if (!hasSecrets(filter)) return
-        sanitizeRequestContext(event)
-        if (event.result !== undefined) event.result = redactString(event.result, filter) ?? WITHHELD
-      }),
-      modelRequest: (event) => Effect.gen(function* () {
-        if (!hasSecrets(filter)) return
-        if (redactHeaders(event.headers, filter, { skipAuth: true, strict: true }) === "withheld") yield* Effect.die(new Error(WITHHELD))
-        if (event.baseURL !== undefined) event.baseURL = redactString(event.baseURL, filter) ?? WITHHELD
-      }),
-      httpRequest: (event) => Effect.promise(async () => {
-        if (!hasSecrets(filter)) return
-        const replacement = await redactRequest(event.request, filter).catch(() => "withheld" as const)
-        if (replacement === "withheld") throw new Error(WITHHELD)
-        event.request = replacement
-      }),
-      httpResponse: (event) => Effect.promise(async () => {
-        if (!hasSecrets(filter)) return
-        try { event.response = await redactResponse(event.response, filter) } catch { event.response = new Response(null, { status: 502 }) }
-      }),
-    },
-    tool: {
-      before: (event) => Effect.gen(function* () {
-        if (SOURCE_TOOLS.has(event.tool)) {
-          const candidate = pathInput(event.input)
-          if (candidate !== undefined && isSourcePath(candidate)) yield* Effect.fail(new Tool.Error({ message: "ACCESS_DENIED" }))
-        }
-        if (inputHasSecret(event.input)) yield* Effect.fail(new Tool.Error({ message: "ACCESS_DENIED" }))
-      }),
-      after: (event) => Effect.sync(() => {
-        if (!hasSecrets(filter)) return
-        if (event.status === "completed") event.result = sanitizeValue(event.result) as typeof event.result
-        else redactToolError(event)
-      }),
-    },
-  }
-  return Effect.succeed(runtime)
-}

package/src/opencode/v2/transports/README.md

@@ -1,5 +0,0 @@
-# Placeholder: model transports
-
-Qualify one exact native HTTP route while active first. SDK, WebSocket, hosted
-tools and independent generation require separate coverage; do not silently count
-them as blocked. No implementation yet.

package/src/runtime/http-transport.ts

@@ -1,20 +0,0 @@
-export type FetchResult = { readonly code: number }
-
-export interface HttpRequest {
-  readonly url: string
-  readonly method: string
-  readonly headers: Record<string, string>
-  readonly signal: any
-}
-
-export type CancelableHttpRequest = Promise<FetchResult>
-
-export interface HttpTransport {
-  request(request: HttpRequest): CancelableHttpRequest
-}
-
-export const nativeHttpTransport: HttpTransport = {
-  request(request) {
-    return Promise.resolve({ code: 0 })
-  },
-}

package/src/sanitize/README.md

@@ -1,4 +0,0 @@
-# Placeholder: sanitization
-
-Write independent admission/interval/sink-byte oracles first. Implement overlap
-unions and post-serialization validation, not leaf-only replacement. No code yet.