cc-prompter 0.1.0

package/dist/index.cjs

@@ -0,0 +1,924 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ccPromptPlugin: () => ccPromptPlugin
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/vite-plugin.ts
+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);
+function loadPty() {
+  return require2("node-pty-prebuilt-multiarch");
+}
+function resolveClaudeBin(cwd) {
+  const local = path.resolve(cwd, "node_modules/@anthropic-ai/claude-code/bin/claude.exe");
+  if (fs.existsSync(local)) return local;
+  return "claude";
+}
+function findClaudeProjectsDir() {
+  return path.join(os.homedir(), ".claude", "projects");
+}
+function cwdToProjectDir(cwd) {
+  return "-" + cwd.replace(/^\//, "").replace(/\//g, "-");
+}
+function findRecentJsonl(cwd, afterMs) {
+  const projectsDir = findClaudeProjectsDir();
+  const projectSubdir = cwdToProjectDir(cwd);
+  const targetDir = path.join(projectsDir, projectSubdir);
+  if (!fs.existsSync(targetDir)) return null;
+  const files = fs.readdirSync(targetDir).filter((f) => f.endsWith(".jsonl"));
+  let best = null;
+  for (const f of files) {
+    const fp = path.join(targetDir, f);
+    try {
+      const stat = fs.statSync(fp);
+      if (stat.mtimeMs > afterMs) {
+        if (!best || stat.mtimeMs > best.mtime) {
+          best = { path: fp, mtime: stat.mtimeMs };
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return best?.path || null;
+}
+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/g, "").replace(/\x1b\[[\?]?[0-9;]*[a-zA-Z]/g, "").replace(/\r/g, "");
+}
+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;
+  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
+  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 bin = resolveClaudeBin(this.cwd);
+    console.log(`[pty-session ${this.id}] spawning: ${bin} cwd: ${this.cwd}`);
+    this.pty = ptyModule.spawn(bin, [], {
+      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) => {
+      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.busyBuffer = "";
+    this.lastUserContent = content;
+    this.ptyResponseText = "";
+    this.ptyResponseEmitted = 0;
+    this.usedJsonl = false;
+    this.ptyDoneEmitted = false;
+    this.lastProgress = "";
+    this.interrupted = false;
+    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() {
+    this.emitProgress();
+    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(/Brewed for.*$/s, "").trim();
+      raw = raw.replace(/Sautéed for.*$/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 toolName = toolCallMatch[1];
+      const filePath = toolCallMatch[2];
+      this.emit("message", {
+        type: "assistant_tool",
+        tool: { name: toolName, input: { file: filePath } }
+      });
+    }
+    if (!this.ptyDoneEmitted && /(?:Brewed|Sautéed) for/.test(this.busyBuffer)) {
+      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(/Brewed for.*$/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 = this.busyBuffer.match(/Brewed for (\d+)s/);
+      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;
+    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;
+      }
+      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) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+  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);
+  const MAX_PORT = startPort + 10;
+  function tryListen(port) {
+    return new Promise((resolve2, reject) => {
+      server.listen(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/vite-plugin.ts
+function ccPromptPlugin(options) {
+  const enableInspector = options?.inspector !== false;
+  let projectRoot = process.cwd();
+  let sidecarServer = null;
+  let actualPort = 0;
+  const startPort = options?.port || 3456;
+  let cleanedUp = false;
+  function cleanup() {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    if (sidecarServer) {
+      sidecarServer.close();
+      sidecarServer = null;
+    }
+  }
+  const inspectorPlugin = enableInspector ? (0, import_code_inspector_plugin.codeInspectorPlugin)({
+    bundler: "vite",
+    behavior: {
+      locate: false,
+      copy: false
+    },
+    hideDomPathAttr: true,
+    hideConsole: true
+  }) : null;
+  const promptPlugin = {
+    name: "cc-prompt-plugin",
+    configResolved(config) {
+      projectRoot = options?.root || config.root;
+    },
+    configureServer(server) {
+      sidecarServer = startSidecar(projectRoot, { startPort });
+      const checkPort = () => {
+        const addr = sidecarServer?.address();
+        if (addr && typeof addr === "object") {
+          actualPort = addr.port;
+          console.log(`[cc-prompter] Sidecar port: ${actualPort}`);
+        }
+      };
+      setTimeout(checkPort, 200);
+      setTimeout(checkPort, 1e3);
+      server.middlewares.use("/__cc-port", (req, res) => {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.end(String(actualPort || startPort));
+      });
+      server.httpServer?.on("close", cleanup);
+      process.on("SIGTERM", () => {
+        cleanup();
+        process.exit(0);
+      });
+      process.on("SIGINT", () => {
+        cleanup();
+        process.exit(0);
+      });
+      process.on("exit", cleanup);
+    },
+    // Only inject in dev mode (ctx.server is undefined during build)
+    transformIndexHtml: {
+      order: "post",
+      handler(html, ctx) {
+        if (!ctx.server) return html;
+        const script = getInjectScript();
+        return html.replace("</body>", `<script>${script}</script></body>`);
+      }
+    },
+    closeBundle() {
+      cleanup();
+    }
+  };
+  const plugins = [promptPlugin];
+  if (inspectorPlugin) plugins.unshift(inspectorPlugin);
+  return plugins;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ccPromptPlugin
+});
+//# sourceMappingURL=index.cjs.map