cc-prompter 0.2.1 → 0.3.1

package/dist/webpack-plugin.cjs

@@ -0,0 +1,1078 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/webpack-plugin.ts
+var webpack_plugin_exports = {};
+__export(webpack_plugin_exports, {
+  CcPromptWebpackPlugin: () => CcPromptWebpackPlugin
+});
+module.exports = __toCommonJS(webpack_plugin_exports);
+var import_path2 = require("path");
+var import_url3 = require("url");
+var import_code_inspector_plugin = require("code-inspector-plugin");
+
+// src/sidecar.ts
+var import_express = __toESM(require("express"), 1);
+var import_http = require("http");
+
+// src/pty-session.ts
+var import_module = require("module");
+var import_url = require("url");
+var import_events = require("events");
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var os = __toESM(require("os"), 1);
+var import_meta = {};
+var _metaUrl = typeof __filename !== "undefined" ? __filename : (0, import_url.fileURLToPath)(import_meta.url);
+var require2 = (0, import_module.createRequire)(_metaUrl);
+var PTY_PACKAGES = [
+  "node-pty-prebuilt-multiarch",
+  // macOS / Linux prebuilt
+  "@homebridge/node-pty-prebuilt-multiarch",
+  // Better Windows support
+  "node-pty"
+  // Original (needs build tools)
+];
+var _ptyModule = null;
+function loadPty() {
+  if (_ptyModule) return _ptyModule;
+  const errors = [];
+  for (const pkg of PTY_PACKAGES) {
+    try {
+      const mod = require2(pkg);
+      const modDir = path.dirname(require2.resolve(pkg + "/package.json"));
+      const buildDir = path.join(modDir, "build", "Release");
+      if (!fs.existsSync(buildDir) || fs.readdirSync(buildDir).filter((f) => f.endsWith(".node")).length === 0) {
+        errors.push(`${pkg}: no native binary in ${buildDir}`);
+        continue;
+      }
+      console.log(`[cc-prompter] Loaded PTY from: ${pkg}`);
+      _ptyModule = mod;
+      return _ptyModule;
+    } catch (err) {
+      errors.push(`${pkg}: ${err.message}`);
+    }
+  }
+  throw new Error(
+    `No PTY module available. Tried:
+${errors.map((e) => "  " + e).join("\n")}
+Install one: npm install node-pty-prebuilt-multiarch (macOS/Linux) or @homebridge/node-pty-prebuilt-multiarch (Windows)`
+  );
+}
+function resolveClaudeBin(cwd) {
+  if (process.platform === "win32") {
+    const localJs = path.resolve(cwd, "node_modules/@anthropic-ai/claude-code/bin/claude.js");
+    if (fs.existsSync(localJs)) {
+      return { file: process.execPath, args: [localJs] };
+    }
+    const globalPrefix = path.dirname(process.execPath);
+    const globalJs = path.join(globalPrefix, "node_modules/@anthropic-ai/claude-code/bin/claude.js");
+    if (fs.existsSync(globalJs)) {
+      return { file: process.execPath, args: [globalJs] };
+    }
+    const appDataJs = path.join(process.env.APPDATA || "", "npm/node_modules/@anthropic-ai/claude-code/bin/claude.js");
+    if (fs.existsSync(appDataJs)) {
+      return { file: process.execPath, args: [appDataJs] };
+    }
+    return { file: process.env.COMSPEC || "cmd.exe", args: ["/c", "claude"] };
+  }
+  const local = path.resolve(cwd, "node_modules/@anthropic-ai/claude-code/bin/claude");
+  if (fs.existsSync(local)) return { file: local, args: [] };
+  return { file: "claude", args: [] };
+}
+function findClaudeProjectsDir() {
+  return path.join(os.homedir(), ".claude", "projects");
+}
+function cwdToProjectDir(cwd) {
+  const normalized = cwd.replace(/\\/g, "/").replace(/^[A-Za-z]:/, (m) => "-" + m[0].toLowerCase());
+  return normalized.replace(/^\//, "").replace(/\/+/g, "-").replace(/^-+/, "");
+}
+function findRecentJsonl(cwd, afterMs) {
+  const projectsDir = findClaudeProjectsDir();
+  if (!fs.existsSync(projectsDir)) return null;
+  const candidates = [];
+  const collectFromDir = (dir) => {
+    try {
+      const files = fs.readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+      for (const f of files) {
+        const fp = path.join(dir, f);
+        try {
+          const stat = fs.statSync(fp);
+          if (stat.mtimeMs > afterMs) {
+            candidates.push({ path: fp, mtime: stat.mtimeMs });
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  };
+  const projectSubdir = cwdToProjectDir(cwd);
+  const targetDir = path.join(projectsDir, projectSubdir);
+  collectFromDir(targetDir);
+  if (candidates.length === 0) {
+    try {
+      const entries = fs.readdirSync(projectsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name !== projectSubdir) {
+          collectFromDir(path.join(projectsDir, entry.name));
+        }
+      }
+    } catch {
+    }
+  }
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => b.mtime - a.mtime);
+  return candidates[0].path;
+}
+function sessionIdFromJsonlPath(jsonPath) {
+  const base = path.basename(jsonPath, ".jsonl");
+  const match = base.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/);
+  return match ? match[0] : null;
+}
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1b\].*?(?:\x07|\x1b\\)/g, "").replace(/\x1b\[[\?]?[0-9;]*[a-zA-Z]/g, "").replace(/\x1b\[[0-9;]*m/g, "").replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1b[^[\]()]?.?/g, "").replace(/\r/g, "");
+}
+function stripSpinner(s) {
+  return s.replace(/[✻✶✽✢·●✳◇◆▸▹⏵⏶]+/g, "").replace(/\w{3,}ing[…\s]*\(\d{1,3}s?\)?/g, "").replace(/\w{3,}ing…/g, "").replace(/\s{2,}/g, " ").trim();
+}
+var PtySession = class extends import_events.EventEmitter {
+  id;
+  cwd;
+  status = "spawning";
+  pty = null;
+  jsonlPath = null;
+  sessionId = null;
+  history = [];
+  jsonlOffset = 0;
+  jsonlWatcher = null;
+  spawnTime;
+  messageSentAt = 0;
+  busySince = 0;
+  // timestamp when last message was sent (for grace period)
+  title = "New Session";
+  lastActivityAt;
+  killed = false;
+  ptyBuffer = "";
+  // accumulated for prompt detection
+  jsonlDiscoverPromise = null;
+  // ── PTY streaming fields ──
+  busyBuffer = "";
+  // accumulated during busy state
+  lastUserContent = "";
+  // last user message text
+  ptyResponseText = "";
+  // extracted response text so far
+  ptyResponseEmitted = 0;
+  // chars already emitted
+  usedJsonl = false;
+  // JSONL events received this turn
+  ptyDoneEmitted = false;
+  lastProgress = "";
+  // last emitted progress text
+  interrupted = false;
+  // set when user sends interrupt
+  lastSpinnerSec = 0;
+  // highest spinner seconds counter seen
+  lastSpinnerAt = 0;
+  // timestamp when spinner was last active
+  emittedTools = /* @__PURE__ */ new Set();
+  // dedup tool call emissions
+  constructor(id, cwd) {
+    super();
+    this.id = id;
+    this.cwd = cwd;
+    this.spawnTime = Date.now();
+    this.lastActivityAt = this.spawnTime;
+  }
+  /** Spawn the claude process via PTY */
+  async spawn() {
+    const ptyModule = loadPty();
+    const { file, args } = resolveClaudeBin(this.cwd);
+    console.log(`[pty-session ${this.id}] spawning: ${file} ${args.join(" ")} cwd: ${this.cwd}`);
+    this.pty = ptyModule.spawn(file, args, {
+      name: "xterm-256color",
+      cols: 120,
+      rows: 30,
+      cwd: this.cwd,
+      env: { ...process.env }
+    });
+    console.log(`[pty-session ${this.id}] PID: ${this.pty.pid}`);
+    this.pty.onData((data) => {
+      if (this.status === "spawning") {
+        console.log(`[pty-session ${this.id}] output: ${JSON.stringify(data.substring(0, 500))}`);
+      }
+      const clean = stripAnsi(data);
+      this.ptyBuffer += clean;
+      this.detectPrompt();
+      if (this.status === "busy" && !this.usedJsonl) {
+        this.busyBuffer += clean;
+        this.parseBusyOutput();
+      }
+    });
+    this.pty.onExit(({ exitCode }) => {
+      console.log(`[pty-session ${this.id}] exited with code: ${exitCode}`);
+      this.status = "exited";
+      this.lastActivityAt = Date.now();
+      this.emit("exit", exitCode);
+      this.cleanup();
+    });
+  }
+  // ── Prompt Detection ──────────────────────────────────
+  detectPrompt() {
+    const indicators = [
+      /for shortcuts/,
+      /\/effort/,
+      /refactor/
+    ];
+    for (const re of indicators) {
+      if (re.test(this.ptyBuffer) && this.status === "spawning") {
+        console.log(`[pty-session ${this.id}] detected prompt \u2192 ready`);
+        this.status = "ready";
+        this.emit("ready");
+        return;
+      }
+    }
+    if (this.interrupted && this.status === "busy") {
+      for (const re of indicators) {
+        if (re.test(this.ptyBuffer)) {
+          console.log(`[pty-session ${this.id}] detected prompt after interrupt \u2192 done`);
+          this.interrupted = false;
+          this.ptyDoneEmitted = true;
+          this.status = "ready";
+          this.lastActivityAt = Date.now();
+          this.emit("message", { type: "done", durationMs: 0 });
+          return;
+        }
+      }
+    }
+  }
+  async waitUntilReady(timeoutMs = 3e4) {
+    if (this.status === "ready") return;
+    if (this.status === "exited") throw new Error("Session exited");
+    return new Promise((resolve2, reject) => {
+      const deadline = Date.now() + timeoutMs;
+      const timer = setInterval(() => {
+        if (this.status === "ready") {
+          clearInterval(timer);
+          resolve2();
+        } else if (this.status === "exited") {
+          clearInterval(timer);
+          reject(new Error("Session exited while waiting"));
+        } else if (Date.now() > deadline) {
+          clearInterval(timer);
+          reject(new Error("Timeout waiting for session to be ready"));
+        }
+      }, 100);
+    });
+  }
+  // ── Send Message ──────────────────────────────────────
+  async sendMessage(content) {
+    if (!this.pty || this.status === "exited") {
+      throw new Error("Session not active");
+    }
+    if (this.status === "busy") {
+      throw new Error("Session busy");
+    }
+    if (this.status !== "ready") {
+      console.log(`[pty-session ${this.id}] waiting for prompt before sending message...`);
+      await this.waitUntilReady();
+    }
+    await new Promise((r) => setTimeout(r, 200));
+    this.status = "busy";
+    this.lastActivityAt = Date.now();
+    this.busySince = Date.now();
+    this.busyBuffer = "";
+    this.ptyBuffer = "";
+    this.lastUserContent = content;
+    this.ptyResponseText = "";
+    this.ptyResponseEmitted = 0;
+    this.usedJsonl = false;
+    this.ptyDoneEmitted = false;
+    this.lastProgress = "";
+    this.interrupted = false;
+    this.lastSpinnerSec = 0;
+    this.lastSpinnerAt = 0;
+    this.emittedTools.clear();
+    if (!this.messageSentAt) {
+      this.messageSentAt = Date.now();
+      console.log(`[pty-session ${this.id}] first message, starting JSONL discovery`);
+      this.jsonlDiscoverPromise = this.discoverJsonl();
+    }
+    console.log(`[pty-session ${this.id}] writing to PTY: ${JSON.stringify(content.slice(0, 100))}`);
+    this.pty.write(content + "\r");
+    await new Promise((r) => setTimeout(r, 150));
+    this.pty.write("\r");
+  }
+  /** Send a slash command to the PTY */
+  sendCommand(command) {
+    if (!this.pty || this.status === "exited") {
+      throw new Error("Session not active");
+    }
+    this.pty.write(command + "\r");
+    if (command === "/new") {
+      this.history = [];
+      this.title = "New Session";
+      this.jsonlPath = null;
+      this.jsonlOffset = 0;
+      this.jsonlWatcher?.close();
+      this.jsonlWatcher = null;
+      this.sessionId = null;
+      this.messageSentAt = 0;
+      this.status = "ready";
+      this.ptyBuffer = "";
+    }
+  }
+  /** Send Escape to PTY to interrupt current generation */
+  interrupt() {
+    if (!this.pty || this.status === "exited") {
+      throw new Error("Session not active");
+    }
+    if (this.status !== "busy") return;
+    this.interrupted = true;
+    this.pty.write("\x1B");
+    setTimeout(() => {
+      if (this.interrupted && this.status === "busy") {
+        console.log(`[pty-session ${this.id}] interrupt timeout \u2192 force done`);
+        this.interrupted = false;
+        this.ptyDoneEmitted = true;
+        this.status = "ready";
+        this.lastActivityAt = Date.now();
+        this.emit("message", { type: "done", durationMs: 0 });
+      }
+    }, 5e3);
+  }
+  // ── PTY Output Parsing (streaming fallback) ───────────
+  /**
+   * Parse PTY output during busy state to extract streaming response.
+   *
+   * Claude Code TUI patterns:
+   *   - Spinner frames: ✳ ✶ ✻ ✽ ✢ · (ignore — just animation)
+   *   - Response text:  ⏺<text>  or  ●<text>
+   *   - Tool use:       ⚡<tool_name> or ✢ editing <file>
+   *   - Completion:     "Brewed for Xs" (ONLY reliable indicator)
+   *   - ⚠️  ❯ appears in input echo too — NOT a completion signal!
+   *   - Timing:         (Xs · ↓NNN tokens)
+   */
+  parseBusyOutput() {
+    if (this.busyBuffer.length > 3e3) {
+      this.busyBuffer = this.busyBuffer.slice(-2e3);
+    }
+    this.emitProgress();
+    const secMatches = [...this.busyBuffer.matchAll(/\w{3,}ing[…\s]*\((\d{1,3})s?/g)];
+    for (const m of secMatches) {
+      const sec = parseInt(m[1]);
+      if (sec > this.lastSpinnerSec) {
+        this.lastSpinnerSec = sec;
+        this.lastSpinnerAt = Date.now();
+      }
+    }
+    const respMatch = this.busyBuffer.match(/⏺([一-鿿　-〿＀-￯].+)/s);
+    if (respMatch) {
+      let raw = respMatch[1];
+      raw = raw.replace(/[✳✶✻✽✢·].*$/s, "").trim();
+      raw = raw.replace(/─{3,}.*$/s, "").trim();
+      raw = raw.replace(/\w{3,}ed (?:for|in) \d{1,4}s?.*$/s, "").trim();
+      raw = raw.replace(/esctointerrupt.*$/s, "").trim();
+      if (raw.length > this.ptyResponseText.length) {
+        this.ptyResponseText = raw;
+        this.emitIncrementalText();
+      }
+    }
+    const toolCallMatch = this.busyBuffer.match(/⏺(Update|Read|Edit|Write|Bash)\(([^)]+)\)/);
+    if (toolCallMatch) {
+      const sig = `${toolCallMatch[1]}:${toolCallMatch[2]}`;
+      if (!this.emittedTools.has(sig)) {
+        this.emittedTools.add(sig);
+        this.emit("message", {
+          type: "assistant_tool",
+          tool: { name: toolCallMatch[1], input: { file: toolCallMatch[2] } }
+        });
+      }
+    }
+    const winToolMatch = this.busyBuffer.match(/● (Reading|Editing|Writing|Searching|Bashing)[^\n]*\n\s*⎿\s*(.+)/);
+    if (!toolCallMatch && winToolMatch) {
+      const filePath = winToolMatch[2].trim();
+      const sig = `${winToolMatch[1]}:${filePath}`;
+      if (!this.emittedTools.has(sig)) {
+        this.emittedTools.add(sig);
+        this.emit("message", {
+          type: "assistant_tool",
+          tool: { name: winToolMatch[1], input: { file: filePath } }
+        });
+      }
+    }
+    if (this.ptyDoneEmitted) return;
+    const cleanBuf = stripSpinner(this.busyBuffer);
+    const hasDoneMarker = /\b\w+ed (?:for|in) \d{1,4}s?\b/i.test(cleanBuf);
+    const spinnerTimeout = this.lastSpinnerAt > 0 && Date.now() - this.lastSpinnerAt > 1e4 && this.ptyResponseEmitted > 0;
+    if (hasDoneMarker || spinnerTimeout) {
+      const reason = hasDoneMarker ? "completion marker" : `spinner timeout (${Math.round((Date.now() - this.lastSpinnerAt) / 1e3)}s since last activity)`;
+      console.log(`[pty-session ${this.id}] detected done via ${reason}`);
+      this.ptyDoneEmitted = true;
+      if (this.ptyResponseText.length > this.ptyResponseEmitted) {
+        this.emitIncrementalText();
+      }
+      if (this.ptyResponseEmitted === 0) {
+        const finalMatch = this.busyBuffer.match(/⏺(.+)/s);
+        if (finalMatch) {
+          let text = finalMatch[1].replace(/[✳✶✻✽✢·].*$/s, "").replace(/─{3,}.*$/s, "").replace(/\w{3,}ed (?:for|in) \d{1,4}s?.*$/s, "").replace(/esctointerrupt.*$/s, "").trim();
+          if (text.length > 0) {
+            this.emitUserIfNeeded();
+            this.history.push({
+              role: "assistant",
+              content: text,
+              timestamp: Date.now()
+            });
+            this.emit("message", { type: "assistant_text", content: text });
+            this.ptyResponseEmitted = text.length;
+          }
+        }
+      }
+      const durMatch = cleanBuf.match(/\w+ed (?:for|in) (\d{1,4})s?/i);
+      const durationMs = durMatch ? parseInt(durMatch[1]) * 1e3 : 0;
+      if (this.history.filter((m) => m.role === "user").length <= 1 && this.lastUserContent) {
+        this.title = this.lastUserContent.slice(0, 60);
+        this.emit("title-change", this.title);
+      }
+      this.status = "ready";
+      this.lastActivityAt = Date.now();
+      this.emit("message", { type: "done", durationMs });
+    }
+  }
+  /** Emit only the newly arrived characters (incremental streaming) */
+  emitIncrementalText() {
+    const newText = this.ptyResponseText.slice(this.ptyResponseEmitted);
+    if (newText.length === 0) return;
+    if (this.ptyResponseEmitted === 0) {
+      this.emitUserIfNeeded();
+    }
+    this.ptyResponseEmitted = this.ptyResponseText.length;
+    this.emit("message", { type: "assistant_text", content: newText });
+  }
+  /**
+   * Extract and emit progress updates from busyBuffer.
+   *
+   * Parses PTY output for Claude Code's progress indicators:
+   *   - "Thinking for Xs, reading N files"
+   *   - "Thought for Xs, read N files"
+   *   - "Crafting… (Xs · ↓NN tokens)"
+   *   - "Update(file)" / "Read(file)"
+   *   - "⎿ Removed N lines"
+   *   - "(Xs · ↓NN tokens)" timing
+   */
+  emitProgress() {
+    const text = this.busyBuffer.replace(/[✳✶✻✽✢·][a-zA-Z0-9…]{0,4}/g, "").replace(/\s+/g, " ");
+    const patterns = [
+      // Thinking phase
+      [/Thinking for (\d+s)[^─]{0,60}(reading \d+ file[^)]*)?/, (m) => {
+        return m[0].replace(/\s+/g, " ").replace(/\s*\(ctrl.*$/, "").trim();
+      }],
+      // Thought completed
+      [/Thought for (\d+s)[^─]{0,60}(read \d+ file[^)]*)?/, (m) => {
+        return m[0].replace(/\s+/g, " ").replace(/\s*\(ctrl.*$/, "").trim();
+      }],
+      // Tool call: Update(file) / Read(file)
+      [/⏺(Update|Read|Edit|Write|Bash)\(([^)]+)\)/, (m) => {
+        return m[1] + ": " + m[2].split("/").slice(-2).join("/");
+      }],
+      // Tool result: ⎿ Removed N lines
+      [/⎿\s*(Removed|Added|Modified|Created)\s+(\d+)\s+(lines?)/, (m) => {
+        return m[1] + " " + m[2] + " " + m[3];
+      }],
+      // Crafting with timing
+      [/Crafting[^─]{0,30}\(\d+s[^)]*\)/, (m) => {
+        return m[0].replace(/\s+/g, " ").trim();
+      }],
+      // Simple timing: (5s · ↓9 tokens)
+      [/\((\d+s)\s*·\s*[↓↑]\s*(\d+)\s*tokens?\)/, (m) => {
+        return m[1] + " \xB7 " + m[2] + " tokens";
+      }]
+    ];
+    let progress = "";
+    for (const [re, fn] of patterns) {
+      const m = text.match(re);
+      if (m) progress = fn(m);
+    }
+    if (progress && progress !== this.lastProgress) {
+      this.lastProgress = progress;
+      this.emit("message", { type: "progress", content: progress });
+    }
+  }
+  /** Emit user message event (only if not already emitted this turn) */
+  emitUserIfNeeded() {
+    if (!this.lastUserContent) return;
+    const already = this.history.some(
+      (m) => m.role === "user" && m.content === this.lastUserContent
+    );
+    if (!already) {
+      this.history.push({
+        role: "user",
+        content: this.lastUserContent,
+        timestamp: Date.now()
+      });
+      this.emit("message", { type: "user", content: this.lastUserContent });
+    }
+  }
+  // ── JSONL Discovery & Parsing (structured events) ─────
+  async discoverJsonl() {
+    const searchStart = this.messageSentAt - 2e3;
+    const projectsDir = findClaudeProjectsDir();
+    const expectedSubdir = cwdToProjectDir(this.cwd);
+    console.log(`[pty-session ${this.id}] JSONL discovery: projectsDir=${projectsDir}, expected=${expectedSubdir}, cwd=${this.cwd}`);
+    for (let i = 0; i < 120; i++) {
+      if (this.killed) return;
+      const jsonl = findRecentJsonl(this.cwd, searchStart);
+      if (jsonl) {
+        this.jsonlPath = jsonl;
+        this.sessionId = sessionIdFromJsonlPath(jsonl) || null;
+        console.log(`[pty-session ${this.id}] found JSONL: ${jsonl} (session: ${this.sessionId})`);
+        this.startTailingJsonl();
+        return;
+      }
+      if (i === 10) {
+        try {
+          if (fs.existsSync(projectsDir)) {
+            const dirs = fs.readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+            console.log(`[pty-session ${this.id}] JSONL not found in expected dir. Available project dirs: ${dirs.join(", ")}`);
+          } else {
+            console.log(`[pty-session ${this.id}] projectsDir does not exist: ${projectsDir}`);
+          }
+        } catch {
+        }
+      }
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    console.warn(`[pty-session ${this.id}] JSONL not found after 60s \u2014 using PTY output parsing`);
+  }
+  startTailingJsonl() {
+    if (!this.jsonlPath) return;
+    this.readNewJsonlLines();
+    try {
+      this.jsonlWatcher = fs.watch(
+        path.dirname(this.jsonlPath),
+        (eventType, filename) => {
+          if (filename === path.basename(this.jsonlPath)) {
+            this.readNewJsonlLines();
+          }
+        }
+      );
+    } catch (err) {
+      console.warn(`[pty-session ${this.id}] fs.watch failed:`, err);
+    }
+  }
+  readNewJsonlLines() {
+    if (!this.jsonlPath) return;
+    try {
+      const stat = fs.statSync(this.jsonlPath);
+      if (stat.size <= this.jsonlOffset) return;
+      const fd = fs.openSync(this.jsonlPath, "r");
+      const buf = Buffer.alloc(stat.size - this.jsonlOffset);
+      fs.readSync(fd, buf, 0, buf.length, this.jsonlOffset);
+      fs.closeSync(fd);
+      this.jsonlOffset = stat.size;
+      const text = buf.toString("utf8");
+      for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const evt = JSON.parse(trimmed);
+          this.processJsonlEvent(evt);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  /** Process a JSONL event — marks usedJsonl to disable PTY parsing */
+  processJsonlEvent(evt) {
+    this.usedJsonl = true;
+    if (!this.sessionId && evt.sessionId) {
+      this.sessionId = evt.sessionId;
+    }
+    switch (evt.type) {
+      case "user": {
+        const text = typeof evt.message?.content === "string" ? evt.message.content : Array.isArray(evt.message?.content) ? evt.message.content.filter((c) => c.type === "text").map((c) => c.text).join("\n") : "";
+        this.history.push({
+          role: "user",
+          content: text,
+          timestamp: evt.timestamp ? new Date(evt.timestamp).getTime() : Date.now()
+        });
+        this.lastActivityAt = Date.now();
+        this.emit("message", { type: "user", content: text });
+        if (this.history.filter((m) => m.role === "user").length === 1 && text) {
+          this.title = text.slice(0, 60);
+          this.emit("title-change", this.title);
+        }
+        break;
+      }
+      case "assistant": {
+        const content = evt.message?.content;
+        if (!Array.isArray(content)) break;
+        const texts = content.filter((c) => c.type === "text").map((c) => c.text).join("\n").trim();
+        const tools = content.filter((c) => c.type === "tool_use").map((c) => ({
+          name: c.name,
+          input: c.input || {}
+        }));
+        if (texts || tools.length) {
+          this.history.push({
+            role: "assistant",
+            content: texts,
+            toolUse: tools.length ? tools : void 0,
+            timestamp: evt.timestamp ? new Date(evt.timestamp).getTime() : Date.now()
+          });
+        }
+        if (texts) {
+          this.emit("message", { type: "assistant_text", content: texts });
+        }
+        for (const t of tools) {
+          this.emit("message", { type: "assistant_tool", tool: t });
+        }
+        break;
+      }
+      case "system": {
+        if (evt.subtype === "tool_result") {
+          const lastAssistant = [...this.history].reverse().find((m) => m.role === "assistant" && m.toolUse?.length);
+          if (lastAssistant?.toolUse?.length) {
+            const lastTool = lastAssistant.toolUse[lastAssistant.toolUse.length - 1];
+            const resultText = typeof evt.message?.content === "string" ? evt.message.content : "";
+            lastTool.result = resultText.slice(0, 500);
+          }
+          const resultContent = typeof evt.message?.content === "string" ? evt.message.content : Array.isArray(evt.message?.content) ? evt.message.content.map((c) => c.text || "").join("") : "";
+          this.emit("message", { type: "system", content: resultContent.slice(0, 200) });
+        } else if (evt.subtype === "turn_duration") {
+          this.status = "ready";
+          this.lastActivityAt = Date.now();
+          this.emit("message", { type: "done", durationMs: evt.durationMs });
+        }
+        break;
+      }
+    }
+  }
+  // ── Lifecycle ─────────────────────────────────────────
+  kill() {
+    this.killed = true;
+    this.cleanup();
+    if (this.pty) {
+      try {
+        this.pty.kill();
+      } catch {
+      }
+      this.pty = null;
+    }
+    this.status = "exited";
+  }
+  cleanup() {
+    if (this.jsonlWatcher) {
+      this.jsonlWatcher.close();
+      this.jsonlWatcher = null;
+    }
+  }
+  getInfo() {
+    const lastMsg = this.history[this.history.length - 1];
+    return {
+      id: this.id,
+      title: this.title,
+      status: this.status,
+      createdAt: this.spawnTime,
+      lastActivityAt: this.lastActivityAt,
+      messageCount: this.history.length,
+      lastMessagePreview: lastMsg ? lastMsg.content.slice(0, 80) : "",
+      sessionId: this.sessionId
+    };
+  }
+  getHistory() {
+    return [...this.history];
+  }
+};
+
+// src/assets.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var import_url2 = require("url");
+var import_meta2 = {};
+var _dirname = typeof __dirname !== "undefined" ? __dirname : (0, import_path.dirname)((0, import_url2.fileURLToPath)(import_meta2.url));
+function assetPath(filename) {
+  const here = (0, import_path.join)(_dirname, filename);
+  if ((0, import_fs.existsSync)(here)) return here;
+  const parent = (0, import_path.join)(_dirname, "..", filename);
+  if ((0, import_fs.existsSync)(parent)) return parent;
+  throw new Error(
+    `[cc-prompter] Asset not found: ${filename}
+  Tried: ${here}
+  Tried: ${parent}
+  __dirname: ${_dirname}`
+  );
+}
+function getPanelHtml() {
+  return (0, import_fs.readFileSync)(assetPath("panel.html"), "utf8");
+}
+function getInjectScript() {
+  return (0, import_fs.readFileSync)(assetPath("inject.js"), "utf8");
+}
+
+// src/sidecar.ts
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  counter = 0;
+  async create(cwd) {
+    const id = `s${++this.counter}-${Date.now().toString(36)}`;
+    const session = new PtySession(id, cwd);
+    this.sessions.set(id, session);
+    session.on("exit", () => {
+    });
+    await session.spawn();
+    return session;
+  }
+  get(id) {
+    return this.sessions.get(id);
+  }
+  list() {
+    return Array.from(this.sessions.values()).map((s) => {
+      const info = s.getInfo();
+      return {
+        id: info.id,
+        title: info.title,
+        status: info.status,
+        createdAt: info.createdAt,
+        lastActivityAt: info.lastActivityAt,
+        messageCount: info.messageCount,
+        lastMessagePreview: info.lastMessagePreview
+      };
+    });
+  }
+  destroy(id) {
+    const session = this.sessions.get(id);
+    if (!session) return false;
+    session.kill();
+    this.sessions.delete(id);
+    return true;
+  }
+  destroyAll() {
+    for (const session of this.sessions.values()) {
+      session.kill();
+    }
+    this.sessions.clear();
+  }
+};
+function startSidecar(projectRoot, options) {
+  const startPort = options?.startPort || 3456;
+  const app = (0, import_express.default)();
+  app.use(import_express.default.json());
+  const manager = new SessionManager();
+  app.use((req, res, next) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.header("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.sendStatus(204);
+      return;
+    }
+    next();
+  });
+  app.get("/__panel/", (_req, res) => {
+    const html = getPanelHtml();
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    res.setHeader("Content-Length", Buffer.byteLength(html));
+    res.end(html);
+  });
+  app.get("/favicon.ico", (_req, res) => {
+    res.sendStatus(204);
+  });
+  app.get("/api/sessions", (_req, res) => {
+    res.json(manager.list());
+  });
+  app.post("/api/sessions", async (req, res) => {
+    try {
+      const cwd = req.body?.cwd || projectRoot;
+      const session = await manager.create(cwd);
+      res.json(session.getInfo());
+    } catch (err) {
+      console.error("[cc-prompter] Failed to create session:", err);
+      res.status(500).json({ error: err.message, stack: err.stack });
+    }
+  });
+  app.post(
+    "/api/sessions/:id/message",
+    async (req, res) => {
+      const session = manager.get(req.params.id);
+      if (!session) {
+        res.status(404).json({ error: "Session not found" });
+        return;
+      }
+      if (session.status === "exited") {
+        res.status(410).json({ error: "Session exited" });
+        return;
+      }
+      if (session.status === "busy") {
+        res.status(409).json({ error: "Session busy" });
+        return;
+      }
+      const { content, sourceInfo } = req.body;
+      if (!content) {
+        res.status(400).json({ error: "Missing content" });
+        return;
+      }
+      let prompt = content;
+      if (sourceInfo) {
+        const relPath = sourceInfo.path;
+        const parts = [
+          `[source: ${relPath}:${sourceInfo.line}:${sourceInfo.column}]`
+        ];
+        if (sourceInfo.elementInfo) {
+          parts.push(`[element: ${sourceInfo.elementInfo}]`);
+        }
+        prompt = parts.join(" ") + " " + content;
+      }
+      res.setHeader("Content-Type", "text/event-stream");
+      res.setHeader("Cache-Control", "no-cache");
+      res.setHeader("Connection", "keep-alive");
+      res.setHeader("X-Accel-Buffering", "no");
+      res.flushHeaders();
+      const onMessage = (evt) => {
+        res.write(`data: ${JSON.stringify(evt)}
+
+`);
+        if (evt.type === "done") {
+          cleanup();
+        }
+      };
+      const onError = (err) => {
+        res.write(`data: ${JSON.stringify({ type: "error", content: err.message })}
+
+`);
+        cleanup();
+      };
+      const cleanup = () => {
+        if (cleanedUp) return;
+        cleanedUp = true;
+        session.removeListener("message", onMessage);
+        session.removeListener("error", onError);
+        res.end();
+      };
+      session.on("message", onMessage);
+      session.on("error", onError);
+      let cleanedUp = false;
+      setTimeout(() => {
+        req.on("close", () => {
+          if (!cleanedUp) {
+            cleanup();
+          }
+        });
+      }, 3e3);
+      try {
+        await session.sendMessage(prompt);
+      } catch (err) {
+        res.write(`data: ${JSON.stringify({ type: "error", content: err.message })}
+
+`);
+        cleanup();
+      }
+    }
+  );
+  app.post(
+    "/api/sessions/:id/command",
+    (req, res) => {
+      const session = manager.get(req.params.id);
+      if (!session) {
+        res.status(404).json({ error: "Session not found" });
+        return;
+      }
+      const { command } = req.body;
+      if (!command) {
+        res.status(400).json({ error: "Missing command" });
+        return;
+      }
+      try {
+        session.sendCommand(command);
+        res.json({ ok: true });
+      } catch (err) {
+        res.status(500).json({ error: err.message });
+      }
+    }
+  );
+  app.post("/api/sessions/:id/interrupt", (req, res) => {
+    const session = manager.get(req.params.id);
+    if (!session) {
+      res.status(404).json({ error: "Session not found" });
+      return;
+    }
+    try {
+      session.interrupt();
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+  app.delete("/api/sessions/:id", (req, res) => {
+    if (manager.destroy(req.params.id)) {
+      res.json({ ok: true });
+    } else {
+      res.status(404).json({ error: "Session not found" });
+    }
+  });
+  app.get("/api/sessions/:id/history", (req, res) => {
+    const session = manager.get(req.params.id);
+    if (!session) {
+      res.status(404).json({ error: "Session not found" });
+      return;
+    }
+    res.json(session.getHistory());
+  });
+  const server = (0, import_http.createServer)(app);
+  let actualPort = startPort;
+  app.get("/__cc-port", (_req, res) => {
+    const addr = server.address();
+    const port = addr && typeof addr === "object" ? addr.port : actualPort;
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.end(String(port));
+  });
+  const MAX_PORT = startPort + 10;
+  function tryListen(port) {
+    return new Promise((resolve2, reject) => {
+      server.listen(port, () => {
+        actualPort = port;
+        console.log(`[cc-prompter] Sidecar running on http://localhost:${port}`);
+        resolve2(server);
+      });
+      server.on("error", (err) => {
+        if (err.code === "EADDRINUSE" && port < MAX_PORT) {
+          console.log(`[cc-prompter] Port ${port} in use, trying ${port + 1}...`);
+          tryListen(port + 1).then(resolve2, reject);
+        } else {
+          reject(err);
+        }
+      });
+    });
+  }
+  tryListen(startPort).catch((err) => {
+    console.error(`[cc-prompter] Failed to start sidecar:`, err.message);
+  });
+  server.on("close", () => {
+    manager.destroyAll();
+  });
+  return server;
+}
+
+// src/webpack-plugin.ts
+var import_meta3 = {};
+var _dirname2 = typeof __dirname !== "undefined" ? __dirname : (0, import_path2.dirname)((0, import_url3.fileURLToPath)(import_meta3.url));
+var CcPromptWebpackPlugin = class {
+  options;
+  sidecarServer = null;
+  sidecarStarted = false;
+  cleanedUp = false;
+  constructor(options) {
+    this.options = options || {};
+  }
+  apply(compiler) {
+    const isDev = this.options.dev !== void 0 ? this.options.dev : process.env.NODE_ENV !== "production";
+    if (!isDev) return;
+    const startPort = this.options.port || 3456;
+    const clientEntryPath = (0, import_path2.join)(_dirname2, "client-entry.js");
+    if (!this.sidecarStarted) {
+      this.sidecarStarted = true;
+      const projectRoot = this.options.root || process.cwd();
+      this.sidecarServer = startSidecar(projectRoot, { startPort });
+    }
+    compiler.hooks.thisCompilation.tap("CcPromptWebpackPlugin", () => {
+      if (!this.cleanedUp) {
+        this.setupCleanup();
+      }
+    });
+    if (this.options.inspector !== false) {
+      const inspectorPlugin = (0, import_code_inspector_plugin.codeInspectorPlugin)({
+        bundler: "webpack",
+        behavior: {
+          locate: false,
+          copy: false
+        },
+        hideDomPathAttr: true,
+        hideConsole: true
+      });
+      if (inspectorPlugin && typeof inspectorPlugin.apply === "function") {
+        inspectorPlugin.apply(compiler);
+      } else if (Array.isArray(inspectorPlugin)) {
+        for (const p of inspectorPlugin) {
+          if (p && typeof p.apply === "function") p.apply(compiler);
+        }
+      }
+    }
+    const webpack = require("webpack");
+    const injectScript = getInjectScript();
+    new webpack.DefinePlugin({
+      "__CC_PROMPTER_INJECT_SCRIPT__": JSON.stringify(injectScript),
+      "__CC_PROMPTER_PORT__": JSON.stringify(startPort)
+    }).apply(compiler);
+    const originalEntry = compiler.options.entry;
+    compiler.options.entry = async () => {
+      const entries = typeof originalEntry === "function" ? await originalEntry() : originalEntry;
+      if (typeof entries === "string") {
+        return { main: [clientEntryPath, entries] };
+      }
+      if (Array.isArray(entries)) {
+        return { main: [clientEntryPath, ...entries] };
+      }
+      if (typeof entries === "object") {
+        for (const key in entries) {
+          if (Array.isArray(entries[key])) {
+            entries[key].unshift(clientEntryPath);
+          } else if (typeof entries[key] === "string") {
+            entries[key] = [clientEntryPath, entries[key]];
+          }
+        }
+      }
+      return entries;
+    };
+  }
+  setupCleanup() {
+    const cleanup = () => {
+      if (this.cleanedUp) return;
+      this.cleanedUp = true;
+      if (this.sidecarServer) {
+        this.sidecarServer.close();
+        this.sidecarServer = null;
+      }
+    };
+    process.on("SIGTERM", () => {
+      cleanup();
+      process.exit(0);
+    });
+    process.on("SIGINT", () => {
+      cleanup();
+      process.exit(0);
+    });
+    process.on("exit", cleanup);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CcPromptWebpackPlugin
+});
+//# sourceMappingURL=webpack-plugin.cjs.map