@koriit/opencode-claude-bridge 0.1.3 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koriit/opencode-claude-bridge",
-  "version": "0.1.3",
+  "version": "0.1.8",
   "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",

package/src/logger.ts

@@ -3,15 +3,11 @@ 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
 }
@@ -29,25 +25,51 @@ export interface Logger {
 }
 
 /**
- * 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).
+ * Internal output logger. Writes to process.stderr in OpenCode's structured
+ * log format, gated on --print-logs to match OpenCode's own log-visibility
+ * behaviour.
+ *
+ * Note: client.log() (HTTP POST to /log) was tried but is unreliable during
+ * the config hook because it fires during server bootstrap before the /log
+ * endpoint is ready. Direct stderr write is the safe, synchronous alternative.
+ */
+const log = (() => {
+  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. The hook itself is
+ * responsible for catching {@link BridgeError} in non-strict paths; in strict
+ * mode the error propagates so OpenCode surfaces a hard failure.
  */
 export function createLogger(strict: boolean): Logger {
   let warningCount = 0
   return {
-    info(msg: string): void {
-      console.log(`${LOG_PREFIX} ${msg}`)
+    info(msg) {
+      log.info(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)
+      log.warn(msg)
     },
-    hadWarnings(): boolean {
+    hadWarnings() {
       return warningCount > 0
     },
   }

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)