@openacp/cli 2026.328.2 → 2026.330.3

package/dist/{chunk-6VR4GWOO.js → chunk-UCIZM5SW.js}

@@ -142,8 +142,8 @@ var TypedEmitter = class {
 // src/core/agents/agent-instance.ts
 import { spawn as spawn2, execFileSync } from "child_process";
 import { Transform } from "stream";
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 import { ClientSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
 import { PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
 
@@ -297,15 +297,48 @@ var McpManager = class {
   }
 };
 
+// src/core/utils/debug-tracer.ts
+import fs from "fs";
+import path from "path";
+var DEBUG_ENABLED = process.env.OPENACP_DEBUG === "true" || process.env.OPENACP_DEBUG === "1";
+var DebugTracer = class {
+  constructor(sessionId, workingDirectory) {
+    this.sessionId = sessionId;
+    this.workingDirectory = workingDirectory;
+    this.logDir = path.join(workingDirectory, ".log");
+  }
+  dirCreated = false;
+  logDir;
+  log(layer, data) {
+    try {
+      if (!this.dirCreated) {
+        fs.mkdirSync(this.logDir, { recursive: true });
+        this.dirCreated = true;
+      }
+      const filePath = path.join(this.logDir, `${this.sessionId}_${layer}.jsonl`);
+      const line = JSON.stringify({ ts: Date.now(), ...data }) + "\n";
+      fs.appendFileSync(filePath, line);
+    } catch {
+    }
+  }
+  /** No-op cleanup — establishes the pattern for future async implementations */
+  destroy() {
+  }
+};
+function createDebugTracer(sessionId, workingDirectory) {
+  if (!DEBUG_ENABLED) return null;
+  return new DebugTracer(sessionId, workingDirectory);
+}
+
 // src/core/agents/agent-instance.ts
 var log = createChildLogger({ module: "agent-instance" });
 function findPackageRoot(startDir) {
   let dir = startDir;
-  while (dir !== path.dirname(dir)) {
-    if (fs.existsSync(path.join(dir, "package.json"))) {
+  while (dir !== path2.dirname(dir)) {
+    if (fs2.existsSync(path2.join(dir, "package.json"))) {
       return dir;
     }
-    dir = path.dirname(dir);
+    dir = path2.dirname(dir);
   }
   return startDir;
 }
@@ -317,26 +350,26 @@ function resolveAgentCommand(cmd) {
   }
   for (const root of searchRoots) {
     const packageDirs = [
-      path.resolve(root, "node_modules", "@zed-industries", cmd, "dist", "index.js"),
-      path.resolve(root, "node_modules", cmd, "dist", "index.js")
+      path2.resolve(root, "node_modules", "@zed-industries", cmd, "dist", "index.js"),
+      path2.resolve(root, "node_modules", cmd, "dist", "index.js")
     ];
     for (const jsPath of packageDirs) {
-      if (fs.existsSync(jsPath)) {
+      if (fs2.existsSync(jsPath)) {
         return { command: process.execPath, args: [jsPath] };
       }
     }
   }
   for (const root of searchRoots) {
-    const localBin = path.resolve(root, "node_modules", ".bin", cmd);
-    if (fs.existsSync(localBin)) {
-      const content = fs.readFileSync(localBin, "utf-8");
+    const localBin = path2.resolve(root, "node_modules", ".bin", cmd);
+    if (fs2.existsSync(localBin)) {
+      const content = fs2.readFileSync(localBin, "utf-8");
       if (content.startsWith("#!/usr/bin/env node")) {
         return { command: process.execPath, args: [localBin] };
       }
       const match = content.match(/"([^"]+\.js)"/);
       if (match) {
-        const target = path.resolve(path.dirname(localBin), match[1]);
-        if (fs.existsSync(target)) {
+        const target = path2.resolve(path2.dirname(localBin), match[1]);
+        if (fs2.existsSync(target)) {
           return { command: process.execPath, args: [target] };
         }
       }
@@ -345,7 +378,7 @@ function resolveAgentCommand(cmd) {
   try {
     const fullPath = execFileSync("which", [cmd], { encoding: "utf-8" }).trim();
     if (fullPath) {
-      const content = fs.readFileSync(fullPath, "utf-8");
+      const content = fs2.readFileSync(fullPath, "utf-8");
       if (content.startsWith("#!/usr/bin/env node")) {
         return { command: process.execPath, args: [fullPath] };
       }
@@ -365,6 +398,7 @@ var AgentInstance = class _AgentInstance extends TypedEmitter {
   agentName;
   promptCapabilities;
   middlewareChain;
+  debugTracer = null;
   // Callback — set by core when wiring events
   onPermissionRequest = async () => "";
   constructor(agentName) {
@@ -407,20 +441,28 @@ var AgentInstance = class _AgentInstance extends TypedEmitter {
     });
     const stdinLogger = new Transform({
       transform(chunk, _enc, cb) {
-        log.debug(
-          { direction: "send", raw: chunk.toString().trimEnd() },
-          "ACP raw"
-        );
+        if (instance.debugTracer) {
+          const raw = chunk.toString().trimEnd();
+          try {
+            instance.debugTracer.log("acp", { dir: "send", data: JSON.parse(raw) });
+          } catch {
+            instance.debugTracer.log("acp", { dir: "send", data: raw });
+          }
+        }
         cb(null, chunk);
       }
     });
     stdinLogger.pipe(instance.child.stdin);
     const stdoutLogger = new Transform({
       transform(chunk, _enc, cb) {
-        log.debug(
-          { direction: "recv", raw: chunk.toString().trimEnd() },
-          "ACP raw"
-        );
+        if (instance.debugTracer) {
+          const raw = chunk.toString().trimEnd();
+          try {
+            instance.debugTracer.log("acp", { dir: "recv", data: JSON.parse(raw) });
+          } catch {
+            instance.debugTracer.log("acp", { dir: "recv", data: raw });
+          }
+        }
         cb(null, chunk);
       }
     });
@@ -489,6 +531,7 @@ ${stderr}`
       mcpServers: resolvedMcp
     });
     instance.sessionId = response.sessionId;
+    instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
     instance.setupCrashDetection();
     log.info(
       { sessionId: response.sessionId, durationMs: Date.now() - spawnStart },
@@ -509,6 +552,7 @@ ${stderr}`
         cwd: workingDirectory
       });
       instance.sessionId = response.sessionId;
+      instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
       log.info(
         { sessionId: response.sessionId, durationMs: Date.now() - spawnStart },
         "Agent resume complete"
@@ -524,6 +568,7 @@ ${stderr}`
         mcpServers: resolvedMcp
       });
       instance.sessionId = response.sessionId;
+      instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
       log.info(
         { sessionId: response.sessionId, durationMs: Date.now() - spawnStart },
         "Agent fallback spawn complete"
@@ -712,8 +757,8 @@ ${stderr}`
           writePath = result.path;
           writeContent = result.content;
         }
-        await fs.promises.mkdir(path.dirname(writePath), { recursive: true });
-        await fs.promises.writeFile(writePath, writeContent, "utf-8");
+        await fs2.promises.mkdir(path2.dirname(writePath), { recursive: true });
+        await fs2.promises.writeFile(writePath, writeContent, "utf-8");
         return {};
       },
       // ── Terminal operations (delegated to TerminalManager) ─────────────
@@ -797,10 +842,10 @@ ${stderr}`
     for (const att of attachments ?? []) {
       const tooLarge = att.size > 10 * 1024 * 1024;
       if (att.type === "image" && this.promptCapabilities?.image && !tooLarge && SUPPORTED_IMAGE_MIMES.has(att.mimeType)) {
-        const data = await fs.promises.readFile(att.filePath);
+        const data = await fs2.promises.readFile(att.filePath);
         contentBlocks.push({ type: "image", data: data.toString("base64"), mimeType: att.mimeType });
       } else if (att.type === "audio" && this.promptCapabilities?.audio && !tooLarge) {
-        const data = await fs.promises.readFile(att.filePath);
+        const data = await fs2.promises.readFile(att.filePath);
         contentBlocks.push({ type: "audio", data: data.toString("base64"), mimeType: att.mimeType });
       } else {
         if ((att.type === "image" || att.type === "audio") && !tooLarge) {
@@ -1003,7 +1048,7 @@ var PermissionGate = class {
 
 // src/core/sessions/session.ts
 import { nanoid } from "nanoid";
-import * as fs2 from "fs";
+import * as fs3 from "fs";
 var moduleLog = createChildLogger({ module: "session" });
 var TTS_PROMPT_INSTRUCTION = `
 
@@ -1220,7 +1265,7 @@ ${text}`;
       try {
         const audioPath = att.originalFilePath || att.filePath;
         const audioMime = att.originalFilePath ? "audio/ogg" : att.mimeType;
-        const audioBuffer = await fs2.promises.readFile(audioPath);
+        const audioBuffer = await fs3.promises.readFile(audioPath);
         const result = await this.speechService.transcribe(audioBuffer, audioMime);
         this.log.info({ provider: "stt", duration: result.duration }, "Voice transcribed");
         this.emit("agent_event", {
@@ -1564,17 +1609,23 @@ var SessionBridge = class {
   sessionEventHandler;
   statusChangeHandler;
   namedHandler;
+  get tracer() {
+    return this.session.agentInstance.debugTracer ?? null;
+  }
   /** Send message to adapter, optionally running through message:outgoing middleware */
   async sendMessage(sessionId, message) {
     try {
       const mw = this.deps.middlewareChain;
       if (mw) {
         const result = await mw.execute("message:outgoing", { sessionId, message }, async (m) => m);
+        this.tracer?.log("core", { step: "middleware:outgoing", sessionId, hook: "message:outgoing", blocked: !result });
         if (!result) return;
+        this.tracer?.log("core", { step: "dispatch", sessionId, message: result.message });
         this.adapter.sendMessage(sessionId, result.message).catch((err) => {
           log2.error({ err, sessionId }, "Failed to send message to adapter");
         });
       } else {
+        this.tracer?.log("core", { step: "dispatch", sessionId, message });
         this.adapter.sendMessage(sessionId, message).catch((err) => {
           log2.error({ err, sessionId }, "Failed to send message to adapter");
         });
@@ -1616,9 +1667,11 @@ var SessionBridge = class {
   }
   wireSessionToAdapter() {
     this.sessionEventHandler = (event) => {
+      this.tracer?.log("core", { step: "agent_event", sessionId: this.session.id, event });
       const mw = this.deps.middlewareChain;
       if (mw) {
         mw.execute("agent:beforeEvent", { sessionId: this.session.id, event }, async (e) => e).then((result) => {
+          this.tracer?.log("core", { step: "middleware:before", sessionId: this.session.id, hook: "agent:beforeEvent", blocked: !result });
           if (!result) return;
           try {
             const transformedEvent = result.event;
@@ -1668,6 +1721,7 @@ var SessionBridge = class {
       case "plan":
       case "usage":
         outgoing = this.deps.messageTransformer.transform(event, ctx);
+        this.tracer?.log("core", { step: "transform", sessionId: this.session.id, input: event, output: outgoing });
         this.sendMessage(this.session.id, outgoing);
         break;
       case "session_end":
@@ -1697,12 +1751,12 @@ var SessionBridge = class {
         break;
       case "image_content": {
         if (this.deps.fileService) {
-          const fs5 = this.deps.fileService;
+          const fs6 = this.deps.fileService;
           const sid = this.session.id;
           const { data, mimeType } = event;
           const buffer = Buffer.from(data, "base64");
-          const ext = fs5.extensionFromMime(mimeType);
-          fs5.saveFile(sid, `agent-image${ext}`, buffer, mimeType).then((att) => {
+          const ext = fs6.extensionFromMime(mimeType);
+          fs6.saveFile(sid, `agent-image${ext}`, buffer, mimeType).then((att) => {
             this.sendMessage(sid, {
               type: "attachment",
               text: "",
@@ -1714,12 +1768,12 @@ var SessionBridge = class {
       }
       case "audio_content": {
         if (this.deps.fileService) {
-          const fs5 = this.deps.fileService;
+          const fs6 = this.deps.fileService;
           const sid = this.session.id;
           const { data, mimeType } = event;
           const buffer = Buffer.from(data, "base64");
-          const ext = fs5.extensionFromMime(mimeType);
-          fs5.saveFile(sid, `agent-audio${ext}`, buffer, mimeType).then((att) => {
+          const ext = fs6.extensionFromMime(mimeType);
+          fs6.saveFile(sid, `agent-audio${ext}`, buffer, mimeType).then((att) => {
             this.sendMessage(sid, {
               type: "attachment",
               text: "",
@@ -1896,14 +1950,22 @@ function extractFileInfo(name, kind, content, rawInput, meta) {
   let info = null;
   if (meta) {
     const m = meta;
-    const claudeCode = m?.claudeCode;
-    const tr = claudeCode?.toolResponse;
-    const file = tr?.file;
-    if (typeof file?.filePath === "string" && typeof file?.content === "string") {
-      info = { filePath: file.filePath, content: file.content };
-    }
-    if (!info && typeof tr?.filePath === "string" && typeof tr?.content === "string") {
-      info = { filePath: tr.filePath, content: tr.content };
+    const toolResponse = resolveToolResponse(m);
+    if (toolResponse) {
+      const file = toolResponse.file;
+      if (typeof file?.filePath === "string" && typeof file?.content === "string") {
+        info = { filePath: file.filePath, content: file.content };
+      }
+      if (!info && typeof toolResponse.filePath === "string" && typeof toolResponse.originalFile === "string") {
+        const originalFile = toolResponse.originalFile;
+        const oldString = typeof toolResponse.oldString === "string" ? toolResponse.oldString : void 0;
+        const newString = typeof toolResponse.newString === "string" ? toolResponse.newString : void 0;
+        const newContent = oldString && newString ? originalFile.replace(oldString, newString) : originalFile;
+        info = { filePath: toolResponse.filePath, content: newContent, oldContent: originalFile };
+      }
+      if (!info && typeof toolResponse.filePath === "string" && typeof toolResponse.content === "string") {
+        info = { filePath: toolResponse.filePath, content: toolResponse.content };
+      }
     }
   }
   if (!info && rawInput && typeof rawInput === "object") {
@@ -1912,7 +1974,19 @@ function extractFileInfo(name, kind, content, rawInput, meta) {
     if (typeof filePath === "string") {
       const parsed = content ? parseContent(content) : null;
       const riContent = typeof ri?.content === "string" ? ri.content : void 0;
-      info = { filePath, content: parsed?.content || riContent, oldContent: parsed?.oldContent };
+      if (kind === "edit") {
+        const oldStr = typeof ri.old_string === "string" ? ri.old_string : typeof ri.oldText === "string" ? ri.oldText : void 0;
+        const newStr = typeof ri.new_string === "string" ? ri.new_string : typeof ri.newText === "string" ? ri.newText : void 0;
+        if (newStr) {
+          info = { filePath, content: newStr, oldContent: oldStr };
+        } else {
+          info = { filePath, content: riContent || parsed?.content, oldContent: parsed?.oldContent };
+        }
+      } else if (kind === "write") {
+        info = { filePath, content: riContent || parsed?.content, oldContent: parsed?.oldContent };
+      } else {
+        info = { filePath, content: parsed?.content || riContent, oldContent: parsed?.oldContent };
+      }
     }
   }
   if (!info && content) {
@@ -1926,6 +2000,16 @@ function extractFileInfo(name, kind, content, rawInput, meta) {
   if (!info.filePath || !info.content) return null;
   return info;
 }
+function resolveToolResponse(meta) {
+  const claudeCode = meta.claudeCode;
+  if (claudeCode?.toolResponse && typeof claudeCode.toolResponse === "object") {
+    return claudeCode.toolResponse;
+  }
+  if (meta.toolResponse && typeof meta.toolResponse === "object") {
+    return meta.toolResponse;
+  }
+  return void 0;
+}
 function parseContent(content) {
   if (typeof content === "string") {
     return { content };
@@ -1984,7 +2068,30 @@ function parseContent(content) {
 
 // src/core/message-transformer.ts
 var log3 = createChildLogger({ module: "message-transformer" });
+function computeLineDiff(oldStr, newStr) {
+  const oldLines = oldStr ? oldStr.split("\n") : [];
+  const newLines = newStr ? newStr.split("\n") : [];
+  let prefixLen = 0;
+  const minLen = Math.min(oldLines.length, newLines.length);
+  while (prefixLen < minLen && oldLines[prefixLen] === newLines[prefixLen]) {
+    prefixLen++;
+  }
+  let suffixLen = 0;
+  const maxSuffix = minLen - prefixLen;
+  while (suffixLen < maxSuffix && oldLines[oldLines.length - 1 - suffixLen] === newLines[newLines.length - 1 - suffixLen]) {
+    suffixLen++;
+  }
+  return {
+    added: Math.max(0, newLines.length - prefixLen - suffixLen),
+    removed: Math.max(0, oldLines.length - prefixLen - suffixLen)
+  };
+}
 var MessageTransformer = class {
+  tunnelService;
+  /** Cache rawInput from tool_call so it's available in tool_update (which often lacks it) */
+  toolRawInputCache = /* @__PURE__ */ new Map();
+  /** Cache viewer links generated from intermediate updates so completion events carry them */
+  toolViewerCache = /* @__PURE__ */ new Map();
   constructor(tunnelService) {
     this.tunnelService = tunnelService;
   }
@@ -1995,6 +2102,9 @@ var MessageTransformer = class {
       case "thought":
         return { type: "thought", text: event.content };
       case "tool_call": {
+        if (event.id && this.isNonEmptyInput(event.rawInput)) {
+          this.toolRawInputCache.set(event.id, event.rawInput);
+        }
         const meta = event.meta;
         const metadata = {
           id: event.id,
@@ -2012,6 +2122,14 @@ var MessageTransformer = class {
         return { type: "tool_call", text: event.name, metadata };
       }
       case "tool_update": {
+        if (event.id && this.isNonEmptyInput(event.rawInput)) {
+          this.toolRawInputCache.set(event.id, event.rawInput);
+        }
+        const cachedRawInput = event.id ? this.toolRawInputCache.get(event.id) : void 0;
+        const effectiveRawInput = this.isNonEmptyInput(event.rawInput) ? event.rawInput : cachedRawInput;
+        if (event.id && (event.status === "completed" || event.status === "done" || event.status === "failed" || event.status === "error")) {
+          this.toolRawInputCache.delete(event.id);
+        }
         const meta = event.meta;
         const metadata = {
           id: event.id,
@@ -2019,12 +2137,28 @@ var MessageTransformer = class {
           kind: event.kind,
           status: event.status,
           content: event.content,
-          rawInput: event.rawInput,
+          rawInput: effectiveRawInput,
           displaySummary: meta?.displaySummary,
           displayTitle: meta?.displayTitle,
           displayKind: meta?.displayKind
         };
-        this.enrichWithViewerLinks(event, metadata, sessionContext);
+        const enrichEvent = { ...event, rawInput: effectiveRawInput };
+        this.enrichWithViewerLinks(enrichEvent, metadata, sessionContext);
+        if (event.id) {
+          const cached = this.toolViewerCache.get(event.id);
+          if (cached) {
+            metadata.viewerLinks = cached.viewerLinks;
+            metadata.viewerFilePath = cached.viewerFilePath;
+          } else if (metadata.viewerLinks) {
+            this.toolViewerCache.set(event.id, {
+              viewerLinks: metadata.viewerLinks,
+              viewerFilePath: metadata.viewerFilePath
+            });
+          }
+          if (event.status === "completed" || event.status === "done" || event.status === "failed" || event.status === "error") {
+            this.toolViewerCache.delete(event.id);
+          }
+        }
         return { type: "tool_update", text: "", metadata };
       }
       case "plan":
@@ -2094,12 +2228,38 @@ var MessageTransformer = class {
         return { type: "text", text: "" };
     }
   }
+  /** Check if rawInput is a non-empty object (not null, not {}) */
+  isNonEmptyInput(input) {
+    return input !== null && input !== void 0 && typeof input === "object" && !Array.isArray(input) && Object.keys(input).length > 0;
+  }
   enrichWithViewerLinks(event, metadata, sessionContext) {
-    if (!this.tunnelService || !sessionContext) return;
-    const name = "name" in event ? event.name || "" : "";
     const kind = "kind" in event ? event.kind : void 0;
+    if (!metadata.diffStats && (kind === "edit" || kind === "write")) {
+      const ri = event.rawInput;
+      if (ri) {
+        const oldStr = typeof ri.old_string === "string" ? ri.old_string : typeof ri.oldText === "string" ? ri.oldText : null;
+        const newStr = typeof ri.new_string === "string" ? ri.new_string : typeof ri.newText === "string" ? ri.newText : typeof ri.content === "string" ? ri.content : null;
+        if (oldStr !== null && newStr !== null) {
+          const stats = computeLineDiff(oldStr, newStr);
+          if (stats.added > 0 || stats.removed > 0) {
+            metadata.diffStats = stats;
+          }
+        } else if (oldStr === null && newStr !== null && kind === "write") {
+          const added = newStr.split("\n").length;
+          if (added > 0) metadata.diffStats = { added, removed: 0 };
+        }
+      }
+    }
+    if (!this.tunnelService || !sessionContext) {
+      log3.debug(
+        { hasTunnel: !!this.tunnelService, hasCtx: !!sessionContext, kind },
+        "enrichWithViewerLinks: skipping (no tunnel or session context)"
+      );
+      return;
+    }
+    const name = "name" in event ? event.name || "" : "";
     log3.debug(
-      { name, kind, status: event.status, hasContent: !!event.content },
+      { name, kind, status: event.status, hasContent: !!event.content, hasRawInput: !!event.rawInput },
       "enrichWithViewerLinks: inspecting event"
     );
     const fileInfo = extractFileInfo(
@@ -2109,7 +2269,18 @@ var MessageTransformer = class {
       event.rawInput,
       event.meta
     );
-    if (!fileInfo) return;
+    if (!fileInfo) {
+      log3.debug(
+        { name, kind, hasContent: !!event.content, hasRawInput: !!event.rawInput, hasMeta: !!event.meta },
+        "enrichWithViewerLinks: extractFileInfo returned null"
+      );
+      return;
+    }
+    const publicUrl = this.tunnelService.getPublicUrl();
+    if (publicUrl.startsWith("http://localhost") || publicUrl.startsWith("http://127.0.0.1")) {
+      log3.debug({ kind, filePath: fileInfo.filePath }, "enrichWithViewerLinks: skipping (no public tunnel URL)");
+      return;
+    }
     log3.info(
       {
         name,
@@ -2130,6 +2301,12 @@ var MessageTransformer = class {
         sessionContext.workingDirectory
       );
       if (id2) viewerLinks.diff = this.tunnelService.diffUrl(id2);
+      if (!metadata.diffStats) {
+        const stats = computeLineDiff(fileInfo.oldContent, fileInfo.content);
+        if (stats.added > 0 || stats.removed > 0) {
+          metadata.diffStats = stats;
+        }
+      }
     }
     const id = store.storeFile(
       sessionContext.id,
@@ -2245,12 +2422,12 @@ var EventBus = class extends TypedEmitter {
 };
 
 // src/core/core.ts
-import path4 from "path";
+import path5 from "path";
 import os from "os";
 
 // src/core/sessions/session-store.ts
-import fs3 from "fs";
-import path2 from "path";
+import fs4 from "fs";
+import path3 from "path";
 var log5 = createChildLogger({ module: "session-store" });
 var DEBOUNCE_MS = 2e3;
 var JsonFileSessionStore = class {
@@ -2312,9 +2489,9 @@ var JsonFileSessionStore = class {
       version: 1,
       sessions: Object.fromEntries(this.records)
     };
-    const dir = path2.dirname(this.filePath);
-    if (!fs3.existsSync(dir)) fs3.mkdirSync(dir, { recursive: true });
-    fs3.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
+    const dir = path3.dirname(this.filePath);
+    if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
+    fs4.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
   }
   destroy() {
     if (this.debounceTimer) clearTimeout(this.debounceTimer);
@@ -2327,10 +2504,10 @@ var JsonFileSessionStore = class {
     }
   }
   load() {
-    if (!fs3.existsSync(this.filePath)) return;
+    if (!fs4.existsSync(this.filePath)) return;
     try {
       const raw = JSON.parse(
-        fs3.readFileSync(this.filePath, "utf-8")
+        fs4.readFileSync(this.filePath, "utf-8")
       );
       if (raw.version !== 1) {
         log5.warn(
@@ -2346,7 +2523,7 @@ var JsonFileSessionStore = class {
     } catch (err) {
       log5.error({ err }, "Failed to load session store, backing up corrupt file");
       try {
-        fs3.renameSync(this.filePath, `${this.filePath}.bak`);
+        fs4.renameSync(this.filePath, `${this.filePath}.bak`);
       } catch {
       }
     }
@@ -2620,27 +2797,27 @@ var ErrorTracker = class {
 };
 
 // src/core/plugin/plugin-storage.ts
-import fs4 from "fs";
-import path3 from "path";
+import fs5 from "fs";
+import path4 from "path";
 var PluginStorageImpl = class {
   kvPath;
   dataDir;
   writeChain = Promise.resolve();
   constructor(baseDir) {
-    this.dataDir = path3.join(baseDir, "data");
-    this.kvPath = path3.join(baseDir, "kv.json");
-    fs4.mkdirSync(baseDir, { recursive: true });
+    this.dataDir = path4.join(baseDir, "data");
+    this.kvPath = path4.join(baseDir, "kv.json");
+    fs5.mkdirSync(baseDir, { recursive: true });
   }
   readKv() {
     try {
-      const raw = fs4.readFileSync(this.kvPath, "utf-8");
+      const raw = fs5.readFileSync(this.kvPath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return {};
     }
   }
   writeKv(data) {
-    fs4.writeFileSync(this.kvPath, JSON.stringify(data), "utf-8");
+    fs5.writeFileSync(this.kvPath, JSON.stringify(data), "utf-8");
   }
   async get(key) {
     const data = this.readKv();
@@ -2666,7 +2843,7 @@ var PluginStorageImpl = class {
     return Object.keys(this.readKv());
   }
   getDataDir() {
-    fs4.mkdirSync(this.dataDir, { recursive: true });
+    fs5.mkdirSync(this.dataDir, { recursive: true });
     return this.dataDir;
   }
 };
@@ -3113,7 +3290,7 @@ var OpenACPCore = class {
     this.agentCatalog = new AgentCatalog();
     this.agentCatalog.load();
     this.agentManager = new AgentManager(this.agentCatalog);
-    const storePath = path4.join(os.homedir(), ".openacp", "sessions.json");
+    const storePath = path5.join(os.homedir(), ".openacp", "sessions.json");
     this.sessionStore = new JsonFileSessionStore(
       storePath,
       config.sessionStore.ttlDays
@@ -3136,7 +3313,7 @@ var OpenACPCore = class {
       sessions: this.sessionManager,
       config: this.configManager,
       core: this,
-      storagePath: path4.join(os.homedir(), ".openacp", "plugins", "data"),
+      storagePath: path5.join(os.homedir(), ".openacp", "plugins", "data"),
       log: createChildLogger({ module: "plugin" })
     });
     this.sessionFactory.middlewareChain = this.lifecycleManager.middlewareChain;
@@ -3169,7 +3346,7 @@ var OpenACPCore = class {
   }
   set tunnelService(service) {
     this._tunnelService = service;
-    this.messageTransformer = new MessageTransformer(service);
+    this.messageTransformer.tunnelService = service;
   }
   registerAdapter(name, adapter) {
     this.adapters.set(name, adapter);
@@ -3737,4 +3914,4 @@ export {
   OpenACPCore,
   CommandRegistry
 };
-//# sourceMappingURL=chunk-6VR4GWOO.js.map
+//# sourceMappingURL=chunk-UCIZM5SW.js.map