codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/task-rules.js

@@ -0,0 +1,81 @@
+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);
+var task_rules_exports = {};
+__export(task_rules_exports, {
+  taskFiles: () => taskFiles,
+  taskRules: () => taskRules
+});
+module.exports = __toCommonJS(task_rules_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_architecture_rules = require("./architecture-rules");
+var import_architecture_rule = require("./architecture-rule");
+var import_check_runs = require("./check-runs");
+var import_open_findings = require("../../shared/lib/open-findings");
+var import_rule_pattern = require("../../shared/lib/rule-pattern");
+function taskFiles(item, projectRoot) {
+  const out = /* @__PURE__ */ new Set();
+  for (const spec of item.fileSpecs ?? []) {
+    if (!spec?.path || spec.isDir) continue;
+    let rel = spec.path.replace(/\\/g, "/");
+    if (import_node_path.default.posix.isAbsolute(rel)) {
+      if (!projectRoot || !rel.startsWith(`${projectRoot.replace(/\\/g, "/")}/`)) continue;
+      rel = rel.slice(projectRoot.length + 1);
+    } else if (item.scopePath) {
+      rel = import_node_path.default.posix.join(item.scopePath.replace(/\\/g, "/"), rel);
+    }
+    rel = import_node_path.default.posix.normalize(rel).replace(/^\.\//, "");
+    if (rel.startsWith("../") || rel === "..") continue;
+    out.add(rel);
+    if (spec.action === "move" && spec.moveTo) out.add(import_node_path.default.posix.normalize(spec.moveTo).replace(/^\.\//, ""));
+  }
+  return [...out];
+}
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+function taskRules(item, projectRoot) {
+  const files = taskFiles(item, projectRoot);
+  if (!projectRoot || files.length === 0) {
+    return { files, in_scope: [], latest_run: null, says: "This task names no files, so no rule is known to judge it." };
+  }
+  const in_scope = (0, import_architecture_rules.rulesOf)(projectRoot).filter((r) => files.some((f) => r.kind === "grep" || r.kind === "agent" ? (0, import_rule_pattern.ruleCovers)(r, f) : (0, import_architecture_rule.inPattern)(r.from, f) && (r.kind !== "package" && r.kind !== "symbol" && r.kind !== "calls" ? true : (0, import_rule_pattern.ruleCovers)(r, f)))).map((r) => ({ rule: r.id, suite: r.suite ?? "architecture", strength: r.strength, words: (0, import_architecture_rule.ruleStatement)(r), because: r.because, ...r.guide ? { guide: r.guide } : {}, ...r.kind === "agent" ? { engine: "agent" } : {} }));
+  const open = (0, import_open_findings.openFindings)((0, import_check_runs.listCheckRuns)(projectRoot), files);
+  const latest_run = open && {
+    id: open.run.id,
+    who: open.run.who,
+    ran_in: open.run.ranIn,
+    at: new Date(open.run.at).toISOString(),
+    findings: open.findings.map((f) => ({ rule: f.rule, path: f.path, imports: f.imports, failing: f.failing, words: f.words, fix: f.fix }))
+  };
+  const rulesWords = in_scope.length === 0 ? "No rule is about this task's files." : `${plural(in_scope.length, "rule")} ${in_scope.length === 1 ? "judges" : "judge"} this task's files.`;
+  const runWords = !open ? " No check has run yet." : open.findings.length === 0 ? ` The latest check (${open.run.who} in ${open.run.ranIn}) found nothing in them.` : ` The latest check (${open.run.who} in ${open.run.ranIn}) found ${plural(open.findings.length, "import")} in them that ${open.findings.length === 1 ? "breaks a rule" : "break rules"}.`;
+  return { files, in_scope, latest_run, says: rulesWords + runWords };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  taskFiles,
+  taskRules
+});

package/src/backend/services/task-workstreams.js

@@ -0,0 +1,90 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var task_workstreams_exports = {};
+__export(task_workstreams_exports, {
+  TASK_PREFIX: () => TASK_PREFIX,
+  isTaskWorkstream: () => isTaskWorkstream,
+  listTaskWorkstreams: () => listTaskWorkstreams,
+  sessionWorkstreams: () => sessionWorkstreams,
+  taskLabel: () => taskLabel,
+  taskWorkstreamId: () => taskWorkstreamId
+});
+module.exports = __toCommonJS(task_workstreams_exports);
+var import_database = require("./database");
+var import_session_service = require("./session-service");
+const TASK_PREFIX = "task:";
+function taskWorkstreamId(itemUid) {
+  return `${TASK_PREFIX}${itemUid}`;
+}
+function isTaskWorkstream(id) {
+  return id.startsWith(TASK_PREFIX);
+}
+function sessionWorkstreams(session) {
+  if (!session) return [];
+  return [
+    ...session.workstreamRoot ? [session.workstreamRoot] : [],
+    ...session.briefItemUid ? [taskWorkstreamId(session.briefItemUid)] : []
+  ];
+}
+function listTaskWorkstreams(projectRoot, opts = {}) {
+  const bound = /* @__PURE__ */ new Map();
+  for (const s of (0, import_session_service.getActiveSessions)()) {
+    if (!s.briefItemUid) continue;
+    (bound.get(s.briefItemUid) ?? bound.set(s.briefItemUid, []).get(s.briefItemUid)).push(s);
+  }
+  const trimmed = projectRoot.replace(/[\\/]+$/, "");
+  const rows = (0, import_database.getDb)().exec(
+    `SELECT i.uid, i.title, i.status, i.plan_uid, p.title,
+            (SELECT COUNT(*) FROM attachments a WHERE a.target_uid = i.uid AND a.role = 'material'),
+            (SELECT COUNT(*) FROM attachments a WHERE a.target_uid = i.uid AND a.role = 'output')
+       FROM plan_items i JOIN plans p ON p.uid = i.plan_uid
+      WHERE (p.project_path = ? OR p.project_path = ?)
+        AND (i.uid IN (${[...bound.keys()].map(() => "?").join(",") || "''"})
+             OR (? = 1 AND EXISTS (SELECT 1 FROM attachments a WHERE a.target_uid = i.uid AND a.role IN ('material', 'output'))))
+      ORDER BY p.title, i.sort_order, i.title`,
+    [projectRoot, trimmed, ...bound.keys(), opts.includeIdle ? 1 : 0]
+  )[0]?.values ?? [];
+  return rows.map((r) => {
+    const itemUid = r[0];
+    const sessions = bound.get(itemUid) ?? [];
+    return {
+      id: taskWorkstreamId(itemUid),
+      itemUid,
+      title: r[1],
+      status: r[2],
+      planUid: r[3],
+      planTitle: r[4],
+      agents: sessions.map((s) => ({ sessionId: s.sessionId, agentType: s.agentType, model: s.model, source: "mcp", lastSeen: s.lastSeen })),
+      materials: Number(r[5] ?? 0),
+      outputs: Number(r[6] ?? 0),
+      idle: sessions.length === 0
+    };
+  });
+}
+function taskLabel(t) {
+  return `Task \xB7 ${t.title}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TASK_PREFIX,
+  isTaskWorkstream,
+  listTaskWorkstreams,
+  sessionWorkstreams,
+  taskLabel,
+  taskWorkstreamId
+});

package/src/backend/services/terminal-history-service.js

@@ -0,0 +1,266 @@
+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);
+var terminal_history_service_exports = {};
+__export(terminal_history_service_exports, {
+  appendHistory: () => appendHistory,
+  closeAllTerminalHistory: () => closeAllTerminalHistory,
+  closeTerminalHistory: () => closeTerminalHistory,
+  getHistoryChunk: () => getHistoryChunk,
+  getHistorySize: () => getHistorySize,
+  initTerminalHistory: () => initTerminalHistory
+});
+module.exports = __toCommonJS(terminal_history_service_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_persistence = require("./persistence");
+const PER_TERMINAL_CAP_BYTES = 200 * 1024 * 1024;
+const GLOBAL_HISTORY_CAP_BYTES = 5 * 1024 * 1024 * 1024;
+const WRITE_FLUSH_INTERVAL_MS = 1e3;
+const WRITE_FLUSH_BYTES = 16 * 1024;
+const DEFAULT_READ_CHUNK_BYTES = 64 * 1024;
+const logs = /* @__PURE__ */ new Map();
+function getTerminalsDir() {
+  return import_node_path.default.join((0, import_persistence.getDataDir)(), "terminals");
+}
+const SAFE_TERMINAL_ID = /^[A-Za-z0-9_-]{1,128}$/;
+function assertSafeTerminalId(terminalId) {
+  if (!SAFE_TERMINAL_ID.test(terminalId)) {
+    throw new Error(
+      `Invalid terminal id "${String(terminalId).slice(0, 64)}" \u2014 ids may contain only letters, digits, underscore and hyphen.`
+    );
+  }
+  return terminalId;
+}
+function getLogPath(terminalId) {
+  return import_node_path.default.join(getTerminalsDir(), `${assertSafeTerminalId(terminalId)}.log`);
+}
+function ensureLog(terminalId) {
+  assertSafeTerminalId(terminalId);
+  let log = logs.get(terminalId);
+  if (log) return log;
+  const dir = getTerminalsDir();
+  if (!import_node_fs.default.existsSync(dir)) import_node_fs.default.mkdirSync(dir, { recursive: true });
+  const filePath = getLogPath(terminalId);
+  const fd = import_node_fs.default.openSync(filePath, "a+");
+  const stat = import_node_fs.default.fstatSync(fd);
+  log = {
+    fd,
+    pendingWrites: [],
+    pendingBytes: 0,
+    flushTimer: null,
+    bytesWritten: stat.size,
+    capped: stat.size >= PER_TERMINAL_CAP_BYTES
+  };
+  logs.set(terminalId, log);
+  return log;
+}
+function flushLog(log) {
+  if (log.pendingWrites.length === 0) {
+    if (log.flushTimer) {
+      clearTimeout(log.flushTimer);
+      log.flushTimer = null;
+    }
+    return;
+  }
+  const buf = Buffer.from(log.pendingWrites.join(""), "utf-8");
+  log.pendingWrites = [];
+  log.pendingBytes = 0;
+  if (log.flushTimer) {
+    clearTimeout(log.flushTimer);
+    log.flushTimer = null;
+  }
+  try {
+    import_node_fs.default.writeSync(log.fd, buf);
+    log.bytesWritten += buf.length;
+    if (log.bytesWritten >= PER_TERMINAL_CAP_BYTES) log.capped = true;
+  } catch (err) {
+    console.warn("[TerminalHistory] flush failed:", err);
+  }
+}
+function appendHistory(terminalId, data) {
+  if (data.length === 0) return;
+  const log = ensureLog(terminalId);
+  if (log.capped) return;
+  log.pendingWrites.push(data);
+  log.pendingBytes += Buffer.byteLength(data, "utf-8");
+  if (log.pendingBytes >= WRITE_FLUSH_BYTES) {
+    flushLog(log);
+    return;
+  }
+  if (!log.flushTimer) {
+    log.flushTimer = setTimeout(() => {
+      const current = logs.get(terminalId);
+      if (current) flushLog(current);
+    }, WRITE_FLUSH_INTERVAL_MS);
+  }
+}
+function readClosedLog(terminalId, before, limit) {
+  const empty = { data: "", prevOffset: 0, hasMore: false, fileSize: 0, capped: false };
+  let fd = null;
+  try {
+    fd = import_node_fs.default.openSync(getLogPath(terminalId), "r");
+    const fileSize = import_node_fs.default.fstatSync(fd).size;
+    let endOffset = before ?? fileSize;
+    if (endOffset > fileSize) endOffset = fileSize;
+    const startOffset = Math.max(0, endOffset - limit);
+    const readLen = endOffset - startOffset;
+    if (readLen <= 0) return { ...empty, fileSize };
+    const buf = Buffer.alloc(readLen);
+    import_node_fs.default.readSync(fd, buf, 0, readLen, startOffset);
+    return {
+      data: buf.toString("utf-8"),
+      prevOffset: startOffset,
+      hasMore: startOffset > 0,
+      fileSize,
+      capped: fileSize >= PER_TERMINAL_CAP_BYTES
+    };
+  } catch {
+    return empty;
+  } finally {
+    if (fd !== null) {
+      try {
+        import_node_fs.default.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+function getHistoryChunk(terminalId, before, limit = DEFAULT_READ_CHUNK_BYTES) {
+  assertSafeTerminalId(terminalId);
+  const existing = logs.get(terminalId);
+  if (!existing) {
+    return readClosedLog(terminalId, before, limit);
+  }
+  const log = existing;
+  flushLog(log);
+  const fileSize = log.bytesWritten;
+  let endOffset = before ?? fileSize;
+  if (endOffset > fileSize) endOffset = fileSize;
+  const startOffset = Math.max(0, endOffset - limit);
+  const readLen = endOffset - startOffset;
+  if (readLen <= 0) {
+    return { data: "", prevOffset: 0, hasMore: false, fileSize, capped: log.capped };
+  }
+  const buf = Buffer.alloc(readLen);
+  try {
+    import_node_fs.default.readSync(log.fd, buf, 0, readLen, startOffset);
+  } catch (err) {
+    console.warn("[TerminalHistory] read failed:", err);
+    return { data: "", prevOffset: 0, hasMore: false, fileSize, capped: log.capped };
+  }
+  return {
+    data: buf.toString("utf-8"),
+    prevOffset: startOffset,
+    hasMore: startOffset > 0,
+    fileSize,
+    capped: log.capped
+  };
+}
+function getHistorySize(terminalId) {
+  assertSafeTerminalId(terminalId);
+  const log = logs.get(terminalId);
+  if (log) return log.bytesWritten;
+  try {
+    return import_node_fs.default.statSync(getLogPath(terminalId)).size;
+  } catch {
+    return 0;
+  }
+}
+function closeTerminalHistory(terminalId) {
+  const log = logs.get(terminalId);
+  if (!log) return;
+  flushLog(log);
+  try {
+    import_node_fs.default.closeSync(log.fd);
+  } catch {
+  }
+  logs.delete(terminalId);
+}
+function closeAllTerminalHistory() {
+  for (const id of Array.from(logs.keys())) {
+    closeTerminalHistory(id);
+  }
+}
+function initTerminalHistory() {
+  const dir = getTerminalsDir();
+  if (!import_node_fs.default.existsSync(dir)) {
+    return;
+  }
+  let files;
+  try {
+    files = import_node_fs.default.readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    console.warn("[TerminalHistory] init: readdir failed:", err);
+    return;
+  }
+  const logFiles = [];
+  let totalBytes = 0;
+  for (const f of files) {
+    if (!f.isFile() || !f.name.endsWith(".log")) continue;
+    const full = import_node_path.default.join(dir, f.name);
+    try {
+      const stat = import_node_fs.default.statSync(full);
+      const id = f.name.slice(0, -".log".length);
+      logFiles.push({ path: full, size: stat.size, mtimeMs: stat.mtimeMs, id });
+      totalBytes += stat.size;
+    } catch {
+    }
+  }
+  console.log(
+    `[TerminalHistory] init \u2014 ${logFiles.length} log file(s), total ${Math.round(totalBytes / 1024 / 1024)} MB (cap ${Math.round(GLOBAL_HISTORY_CAP_BYTES / 1024 / 1024)} MB)`
+  );
+  if (totalBytes <= GLOBAL_HISTORY_CAP_BYTES) return;
+  const candidates = logFiles.filter((f) => !logs.has(f.id)).sort((a, b) => a.mtimeMs - b.mtimeMs);
+  let deleted = 0;
+  let bytesFreed = 0;
+  for (const f of candidates) {
+    if (totalBytes <= GLOBAL_HISTORY_CAP_BYTES) break;
+    try {
+      import_node_fs.default.unlinkSync(f.path);
+      totalBytes -= f.size;
+      bytesFreed += f.size;
+      deleted++;
+    } catch (err) {
+      console.warn(`[TerminalHistory] init: failed to delete ${f.path}:`, err);
+    }
+  }
+  if (deleted > 0) {
+    console.log(
+      `[TerminalHistory] init \u2014 pruned ${deleted} file(s), freed ${Math.round(bytesFreed / 1024 / 1024)} MB`
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendHistory,
+  closeAllTerminalHistory,
+  closeTerminalHistory,
+  getHistoryChunk,
+  getHistorySize,
+  initTerminalHistory
+});

package/src/backend/services/terminal-service.js

@@ -0,0 +1,267 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var terminal_service_exports = {};
+__export(terminal_service_exports, {
+  createTerminal: () => createTerminal,
+  getTerminal: () => getTerminal,
+  injectPrompt: () => injectPrompt,
+  killAllTerminals: () => killAllTerminals,
+  killTerminal: () => killTerminal,
+  listTerminals: () => listTerminals,
+  onTerminalData: () => onTerminalData,
+  onTerminalExit: () => onTerminalExit,
+  readTerminalDelta: () => readTerminalDelta,
+  readTerminalOutput: () => readTerminalOutput,
+  resizeTerminal: () => resizeTerminal,
+  writeTerminal: () => writeTerminal
+});
+module.exports = __toCommonJS(terminal_service_exports);
+var import_node_pty = require("node-pty");
+var import_terminal_history_service = require("./terminal-history-service");
+const sessions = /* @__PURE__ */ new Map();
+let counter = 0;
+const RING_BUFFER_MAX_BYTES = 256 * 1024;
+const outputBuffers = /* @__PURE__ */ new Map();
+const bufferTotals = /* @__PURE__ */ new Map();
+function appendToBuffer(id, data) {
+  const existing = outputBuffers.get(id) ?? "";
+  const combined = existing + data;
+  bufferTotals.set(id, (bufferTotals.get(id) ?? 0) + data.length);
+  if (combined.length > RING_BUFFER_MAX_BYTES) {
+    outputBuffers.set(id, combined.slice(combined.length - RING_BUFFER_MAX_BYTES));
+  } else {
+    outputBuffers.set(id, combined);
+  }
+}
+function readTerminalDelta(id, since) {
+  const buf = outputBuffers.get(id);
+  if (buf === void 0) return null;
+  const total = bufferTotals.get(id) ?? buf.length;
+  const bufStart = total - buf.length;
+  if (since == null || since < bufStart) {
+    return { data: buf, total, reset: true };
+  }
+  if (since >= total) {
+    return { data: "", total, reset: false };
+  }
+  return { data: buf.slice(since - bufStart), total, reset: false };
+}
+const MAX_TERMINAL_SESSIONS = 20;
+const dataListeners = [];
+const exitListeners = [];
+function onTerminalData(fn) {
+  dataListeners.push(fn);
+  return () => {
+    const idx = dataListeners.indexOf(fn);
+    if (idx >= 0) dataListeners.splice(idx, 1);
+  };
+}
+function onTerminalExit(fn) {
+  exitListeners.push(fn);
+  return () => {
+    const idx = exitListeners.indexOf(fn);
+    if (idx >= 0) exitListeners.splice(idx, 1);
+  };
+}
+function getDefaultShell() {
+  if (process.platform === "win32") return "powershell.exe";
+  return process.env.SHELL || "/bin/zsh";
+}
+function presetCommand(preset) {
+  const shell = getDefaultShell();
+  switch (preset) {
+    case "claude":
+      return { file: shell, args: ["-l"] };
+    case "codex":
+      return { file: shell, args: ["-l"] };
+    case "aider":
+      return { file: shell, args: ["-l"] };
+    case "shell":
+    default:
+      return { file: shell, args: ["-l"] };
+  }
+}
+function presetInitCommand(preset) {
+  switch (preset) {
+    case "claude":
+      return "claude\n";
+    case "codex":
+      return "codex\n";
+    case "aider":
+      return "aider\n";
+    default:
+      return null;
+  }
+}
+function createTerminal(opts) {
+  for (const [id2, s] of sessions) {
+    if (!s.alive) sessions.delete(id2);
+  }
+  if (sessions.size >= MAX_TERMINAL_SESSIONS) {
+    throw new Error(
+      `Terminal session limit reached (${MAX_TERMINAL_SESSIONS}). Close unused terminals before opening new ones.`
+    );
+  }
+  const id = `term-${++counter}-${Date.now().toString(36)}`;
+  const preset = opts.preset ?? "shell";
+  const cwd = opts.cwd ?? process.cwd();
+  const cols = opts.cols ?? 120;
+  const rows = opts.rows ?? 30;
+  const { file, args } = presetCommand(preset);
+  const env = {
+    ...process.env,
+    TERM: "xterm-256color",
+    COLORTERM: "truecolor",
+    // Enable colored output for ls, grep, and other tools
+    CLICOLOR: "1",
+    CLICOLOR_FORCE: "1",
+    LSCOLORS: "GxFxCxDxBxegedabagaced",
+    // Avoid pager for git and other tools inside the terminal
+    GIT_PAGER: "",
+    PAGER: "",
+    // Self-write detection: agents running inside this PTY can read
+    // this env var and pass it to register_session(host_terminal_id=...)
+    // so terminal_write can reject writes to their own host terminal.
+    CODETRELLIS_HOST_TERMINAL: id
+  };
+  const pty = (0, import_node_pty.spawn)(file, args, {
+    name: "xterm-256color",
+    cols,
+    rows,
+    cwd,
+    env
+  });
+  const session = {
+    id,
+    pty,
+    preset,
+    title: opts.title ?? `${preset === "shell" ? "Terminal" : preset} ${counter}`,
+    cwd,
+    pid: pty.pid,
+    createdAt: Date.now(),
+    alive: true
+  };
+  sessions.set(id, session);
+  pty.onData((data) => {
+    appendToBuffer(id, data);
+    (0, import_terminal_history_service.appendHistory)(id, data);
+    for (const fn of dataListeners) fn(id, data);
+  });
+  pty.onExit(({ exitCode }) => {
+    session.alive = false;
+    (0, import_terminal_history_service.closeTerminalHistory)(id);
+    for (const fn of exitListeners) fn(id, exitCode);
+  });
+  const initCmd = presetInitCommand(preset);
+  if (initCmd) {
+    setTimeout(() => {
+      if (session.alive) pty.write(initCmd);
+    }, 500);
+  }
+  return sessionToInfo(session);
+}
+function writeTerminal(id, data) {
+  const s = sessions.get(id);
+  if (!s || !s.alive) return false;
+  s.pty.write(data);
+  return true;
+}
+function resizeTerminal(id, cols, rows) {
+  const s = sessions.get(id);
+  if (!s || !s.alive) return false;
+  try {
+    s.pty.resize(cols, rows);
+  } catch {
+    return false;
+  }
+  return true;
+}
+function injectPrompt(id, text) {
+  const s = sessions.get(id);
+  if (!s || !s.alive) return false;
+  s.pty.write(text);
+  return true;
+}
+function killTerminal(id) {
+  const s = sessions.get(id);
+  if (!s) return false;
+  s.alive = false;
+  s.pty.kill();
+  sessions.delete(id);
+  outputBuffers.delete(id);
+  (0, import_terminal_history_service.closeTerminalHistory)(id);
+  return true;
+}
+function listTerminals() {
+  return Array.from(sessions.values()).map(sessionToInfo);
+}
+function getTerminal(id) {
+  const s = sessions.get(id);
+  return s ? sessionToInfo(s) : null;
+}
+function killAllTerminals() {
+  for (const s of sessions.values()) {
+    s.pty.kill();
+    try {
+      (0, import_terminal_history_service.closeTerminalHistory)(s.id);
+    } catch {
+    }
+  }
+  sessions.clear();
+  outputBuffers.clear();
+}
+function readTerminalOutput(id, lines, raw = false) {
+  const buf = outputBuffers.get(id);
+  if (buf === void 0) return null;
+  let text;
+  if (raw) {
+    text = buf;
+  } else {
+    text = buf.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "").replace(/\x1b\].*?\x07/g, "").replace(/\x1b[()][A-Z0-9]/g, "").replace(/[\x00-\x09\x0b\x0c\x0e-\x1f]/g, "");
+  }
+  const allLines = text.split("\n");
+  const maxLines = lines ?? 50;
+  const tail = allLines.slice(-maxLines);
+  return tail.join("\n");
+}
+function sessionToInfo(s) {
+  return {
+    id: s.id,
+    preset: s.preset,
+    title: s.title,
+    cwd: s.cwd,
+    pid: s.pid,
+    createdAt: s.createdAt,
+    alive: s.alive
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTerminal,
+  getTerminal,
+  injectPrompt,
+  killAllTerminals,
+  killTerminal,
+  listTerminals,
+  onTerminalData,
+  onTerminalExit,
+  readTerminalDelta,
+  readTerminalOutput,
+  resizeTerminal,
+  writeTerminal
+});