@koriit/opencode-claude-bridge 0.1.2 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koriit/opencode-claude-bridge",
-  "version": "0.1.2",
+  "version": "0.1.7",
   "description": "An OpenCode plugin that bridges enabled Claude Code plugins (commands, agents, skills, MCP, LSP) into OpenCode at runtime, namespaced so they never shadow your existing items.",
   "type": "module",
   "license": "MIT",
@@ -42,9 +42,6 @@
   "engines": {
     "bun": ">=1.2.0"
   },
-  "opencode": {
-    "supportedRange": ">=1.15.0 <1.16.0"
-  },
   "devDependencies": {
     "@opencode-ai/plugin": "1.15.13",
     "@opencode-ai/sdk": "1.15.13",

package/src/index.ts

@@ -5,10 +5,9 @@ import { injectCommandsAndAgents } from "./inject.js"
 import { injectSkills } from "./skill-inject.js"
 import { injectMcp } from "./mcp-inject.js"
 import { injectLsp } from "./lsp-inject.js"
-import { createLogger } from "./logger.js"
+import { createLogger, type LoggingClient } from "./logger.js"
 import { listClaudePlugins, selectEnabledPlugins } from "./selection.js"
 import { collectExistingSkillNames } from "./skill-scan.js"
-import { checkVersion, fetchOpencodeVersion } from "./version.js"
 
 /**
  * Parse an environment-variable value as a boolean, matching the set of truthy
@@ -52,15 +51,11 @@ export const server: Plugin = async (_input, options) => {
 
   return {
     config: async (cfg) => {
-      const logger = createLogger(bridge.strict)
+      const logger = createLogger(bridge.strict, _input.client as unknown as LoggingClient)
       try {
         // Replay parse-time validation warnings (strict-promotable).
         for (const w of warnings) logger.warn(w)
 
-        // §9 version-compat advisory (always soft — still attempts injection).
-        const version = await fetchOpencodeVersion(_input.serverUrl)
-        checkVersion(version, logger)
-
         // §5 mirror-claude resolution.
         const all = await listClaudePlugins(_input.$, logger)
         if (all === null) return // CLI missing/failed — already warned; inject nothing.

package/src/logger.ts

@@ -1,17 +1,18 @@
+/** Minimal duck-type for the OpenCode client — only the log() method we use. */
+export interface LoggingClient {
+  log(params: { service?: string; level?: "debug" | "info" | "warn" | "error"; message?: string }): unknown
+}
+
 /** Thrown when a soft warning is promoted to a hard error under `strict` mode. */
 export class BridgeError extends Error {
   override name = "BridgeError"
 }
 
-/** Prefix every line the bridge emits so its output is greppable in OpenCode's logs. */
-export const LOG_PREFIX = "[opencode-claude-bridge]"
-
 export interface WarnOptions {
   /**
    * Whether this warning should be promoted to a hard error under `strict`.
    * Defaults to `true` (parse failures, missing CLI). Set `false` for advisory
-   * warnings that must never abort the hook even in strict mode (e.g. the §9
-   * version-range notice, which always still attempts injection).
+   * warnings that must never abort the hook even in strict mode.
    */
   fatalInStrict?: boolean
 }
@@ -28,26 +29,72 @@ export interface Logger {
   hadWarnings(): boolean
 }
 
+
 /**
- * Create a logger bound to the resolved `strict` flag. The hook itself is responsible
- * for catching {@link BridgeError} in non-strict paths; in strict mode it lets the
- * error propagate so OpenCode surfaces a hard failure (design §10).
+ * Fallback output logger used when no real OpenCode client is available (tests,
+ * edge-case early errors). Writes to process.stderr in OpenCode's structured
+ * format and only when --print-logs is in argv — matching OpenCode's own
+ * log-visibility behaviour.
  */
-export function createLogger(strict: boolean): Logger {
+const fallbackLog = (() => {
+  const enabled = process.argv.includes("--print-logs")
+  let last = Date.now()
+
+  function write(level: "INFO" | "WARN", msg: string): void {
+    if (!enabled) return
+    const now = Date.now()
+    const ts = new Date(now).toISOString().split(".")[0]
+    const diff = now - last
+    last = now
+    process.stderr.write(`${level.padEnd(5)} ${ts} +${diff}ms service=opencode-claude-bridge ${msg}\n`)
+  }
+
+  return {
+    info: (msg: string) => write("INFO", msg),
+    warn: (msg: string) => write("WARN", msg),
+  }
+})()
+
+/**
+ * Create a logger bound to the resolved `strict` flag and the OpenCode client.
+ *
+ * When a client is provided, log entries are posted to the server via
+ * `client.log()` — they flow through OpenCode's own log pipeline, appear in
+ * the log file, and respect `--print-logs` automatically.
+ *
+ * When no client is provided (tests, early-startup errors) the fallback logger
+ * writes to process.stderr in the same format, gated on `--print-logs`.
+ */
+export function createLogger(strict: boolean, client?: LoggingClient): Logger {
   let warningCount = 0
+
+  function logInfo(msg: string): void {
+    if (typeof client?.log === "function") {
+      void client.log({ service: "opencode-claude-bridge", level: "info", message: msg })
+    } else {
+      fallbackLog.info(msg)
+    }
+  }
+
+  function logWarn(msg: string): void {
+    if (typeof client?.log === "function") {
+      void client.log({ service: "opencode-claude-bridge", level: "warn", message: msg })
+    } else {
+      fallbackLog.warn(msg)
+    }
+  }
+
   return {
-    info(msg: string): void {
-      console.log(`${LOG_PREFIX} ${msg}`)
+    info(msg) {
+      logInfo(msg)
     },
-    warn(msg: string, opts?: WarnOptions): void {
+    warn(msg, opts) {
       const fatalInStrict = opts?.fatalInStrict ?? true
       warningCount++
-      if (strict && fatalInStrict) {
-        throw new BridgeError(msg)
-      }
-      console.warn(`${LOG_PREFIX} warning: ${msg}`)
+      if (strict && fatalInStrict) throw new BridgeError(msg)
+      logWarn(msg)
     },
-    hadWarnings(): boolean {
+    hadWarnings() {
       return warningCount > 0
     },
   }

package/src/opencode-builtins.ts

@@ -1,14 +1,5 @@
 /**
- * Version-pinned OpenCode built-in name lists and skill-discovery constants.
- *
- * The runtime OpenCode version verified by the spec is **1.15.10**; the source
- * checkout on this machine is **1.15.13**. The constants were re-confirmed
- * unchanged against the 1.15.13 source — the cited line numbers and values are
- * identical in both versions. The pin below records the runtime version (what
- * users run and what the spec validated against); re-validate on the next upgrade.
- *
- * MUST be re-validated on every OpenCode upgrade — these are part of what the
- * §9 compatibility check guards.
+ * OpenCode built-in name lists and skill-discovery constants.
  *
  * Source locations (all in `packages/opencode/src/`):
  *   - Built-in agents:   `agent/agent.ts:127-248`
@@ -17,11 +8,6 @@
  *   - Skill scan dirs:   `skill/index.ts:22-26, 173-233`
  */
 
-// The single source of truth for the verified OpenCode version is VERIFIED_OPENCODE_VERSION
-// in src/version.ts. Re-export it here so callers in this module don't need a cross-module
-// import, and so the value is never duplicated.
-export { VERIFIED_OPENCODE_VERSION as PINNED_OPENCODE_VERSION } from "./version.js"
-
 // ── Built-in agents ─────────────────────────────────────────────────────────
 //
 // Registered as hard-coded entries in the `agents` object before `cfg.agent`

package/src/skill-inject.ts

@@ -353,12 +353,14 @@ async function injectPluginSkills(
       continue
     }
 
-    const bareName = extractSkillName(content)
-    if (bareName === null) {
-      logger.warn(
-        `SKILL.md at "${skillMdPath}" from plugin "${plugin.id}" has no frontmatter name; skipping`,
+    const extractedName = extractSkillName(content)
+    // Fall back to the directory name when the SKILL.md has no `name:` field —
+    // the directory name is the conventional skill identifier and is always present.
+    const bareName = extractedName ?? subdir
+    if (extractedName === null) {
+      logger.info(
+        `SKILL.md at "${skillMdPath}" from plugin "${plugin.id}" has no frontmatter name; using directory name "${subdir}"`,
       )
-      continue
     }
 
     const { name: allocatedName, renamed } = allocator.claim(plugin.id, bareName)

package/src/version.ts

@@ -1,114 +0,0 @@
-import type { Logger } from "./logger.js"
-
-/**
- * Supported OpenCode version range. The injection approach relies on OpenCode-*internal*
- * behavior (a shared mutable config object + lazy-after-`plugin.init()` service init) that
- * is not a documented public contract, so the bridge pins a conservative same-minor window
- * and warns outside it. Widen only when the e2e canary passes against a new version (§9).
- */
-export const SUPPORTED_OPENCODE_RANGE = ">=1.15.0 <1.16.0"
-
-/** The OpenCode version the design and range were verified against (§9). */
-export const VERIFIED_OPENCODE_VERSION = "1.15.10"
-
-interface Semver {
-  major: number
-  minor: number
-  patch: number
-}
-
-/**
- * Parse a `major.minor.patch` string, tolerating a leading `v` and ignoring any
- * prerelease/build suffix (`-rc.1`, `+build`). Returns `null` if the core triple is
- * not three integers.
- */
-export function parseSemver(version: string): Semver | null {
-  // Anchored end so trailing garbage ("1.2.3abc", "1.2.3.4") is rejected rather than
-  // silently truncated to a bogus triple; only a `-prerelease` / `+build` suffix is allowed.
-  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version.trim())
-  if (!match) return null
-  return {
-    major: Number(match[1]),
-    minor: Number(match[2]),
-    patch: Number(match[3]),
-  }
-}
-
-function compare(a: Semver, b: Semver): number {
-  return a.major - b.major || a.minor - b.minor || a.patch - b.patch
-}
-
-const COMPARATORS: Record<string, (cmp: number) => boolean> = {
-  ">=": (c) => c >= 0,
-  "<=": (c) => c <= 0,
-  ">": (c) => c > 0,
-  "<": (c) => c < 0,
-  "=": (c) => c === 0,
-}
-
-/**
- * Test `version` against a space-separated AND range of simple comparator clauses
- * (e.g. `">=1.15.0 <1.16.0"`). Returns `false` if `version` is unparseable or any
- * clause is malformed — callers treat that as "outside the supported range".
- */
-export function satisfiesRange(version: string, range: string): boolean {
-  const parsed = parseSemver(version)
-  if (!parsed) return false
-
-  const clauses = range.trim().split(/\s+/).filter(Boolean)
-  for (const clause of clauses) {
-    const match = /^(>=|<=|>|<|=)?\s*(.+)$/.exec(clause)
-    if (!match) return false
-    const op = match[2] === undefined ? null : (match[1] ?? "=")
-    const bound = parseSemver(match[2]!)
-    if (op === null || !bound) return false
-    if (!COMPARATORS[op]!(compare(parsed, bound))) return false
-  }
-  return true
-}
-
-/**
- * Read the running OpenCode version from the live HTTP server's health endpoint.
- *
- * This is the only mechanism available to an external plugin: the v1 `input.client`
- * exposes no version method, there is no `OPENCODE_VERSION` env var at runtime, and the
- * build-time define global is not visible outside OpenCode's own bundle. The endpoint is
- * mounted at the server root (`GET /global/health` → `{ healthy, version }`) and the HTTP
- * server is already running before `plugin.init()` fires, so calling it from the config
- * hook is safe and touches none of the lazy component services.
- *
- * Returns `null` on any failure (network, parse, missing field) — the caller degrades to
- * "version unknown" rather than blocking injection.
- */
-export async function fetchOpencodeVersion(serverUrl: URL): Promise<string | null> {
-  try {
-    const res = await fetch(new URL("/global/health", serverUrl))
-    if (!res.ok) return null
-    const body = (await res.json()) as { version?: unknown }
-    return typeof body.version === "string" ? body.version : null
-  } catch {
-    return null
-  }
-}
-
-/**
- * Compare the running version against {@link SUPPORTED_OPENCODE_RANGE} and emit the §9
- * advisory warning when it falls outside. This warning is **always soft** — even under
- * `strict`, the bridge still attempts injection (the e2e suite is the real canary). A
- * `null` version (health unreachable) is reported as an inability to verify, not a failure.
- */
-export function checkVersion(version: string | null, logger: Logger): void {
-  if (version === null) {
-    logger.warn(
-      `could not determine the running OpenCode version; proceeding (supported range ${SUPPORTED_OPENCODE_RANGE})`,
-      { fatalInStrict: false },
-    )
-    return
-  }
-  if (!satisfiesRange(version, SUPPORTED_OPENCODE_RANGE)) {
-    logger.warn(
-      `untested OpenCode version ${version} (supported range ${SUPPORTED_OPENCODE_RANGE}) — bridge may misbehave; attempting injection anyway`,
-      { fatalInStrict: false },
-    )
-  }
-}