codeharbor 0.1.0

package/dist/cli.js

@@ -0,0 +1,2342 @@
+#!/usr/bin/env node
+"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 __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
+));
+
+// src/cli.ts
+var import_commander = require("commander");
+
+// src/app.ts
+var import_node_child_process2 = require("child_process");
+var import_node_util = require("util");
+
+// src/channels/matrix-channel.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_node_os = __toESM(require("os"));
+var import_node_path = __toESM(require("path"));
+var import_matrix_js_sdk = require("matrix-js-sdk");
+
+// src/utils/message.ts
+function extractCommandText(rawText, prefix) {
+  const incoming = rawText.trim();
+  if (!incoming) {
+    return null;
+  }
+  if (!prefix) {
+    return incoming;
+  }
+  if (!incoming.startsWith(prefix)) {
+    return null;
+  }
+  const nextChar = incoming.slice(prefix.length, prefix.length + 1);
+  if (nextChar && !/\s/.test(nextChar)) {
+    return null;
+  }
+  const stripped = incoming.slice(prefix.length).trim();
+  return stripped.length > 0 ? stripped : null;
+}
+function splitText(text, chunkSize) {
+  const clean = text.trim();
+  if (!clean) {
+    return [""];
+  }
+  if (chunkSize <= 0 || clean.length <= chunkSize) {
+    return [clean];
+  }
+  const blocks = splitIntoBlocks(clean);
+  const chunks = [];
+  let current = "";
+  for (const block of blocks) {
+    if (block.length > chunkSize) {
+      if (current) {
+        chunks.push(current);
+        current = "";
+      }
+      chunks.push(...splitOversizedBlock(block, chunkSize));
+      continue;
+    }
+    if (!current) {
+      current = block;
+      continue;
+    }
+    const combined = `${current}
+
+${block}`;
+    if (combined.length <= chunkSize) {
+      current = combined;
+      continue;
+    }
+    chunks.push(current);
+    current = block;
+  }
+  if (current) {
+    chunks.push(current);
+  }
+  return chunks;
+}
+function splitIntoBlocks(text) {
+  const blocks = [];
+  const codeFenceRegex = /```[\s\S]*?```/g;
+  let cursor = 0;
+  for (const match of text.matchAll(codeFenceRegex)) {
+    const index = match.index ?? 0;
+    const before = text.slice(cursor, index);
+    blocks.push(...splitParagraphs(before));
+    const codeBlock = match[0]?.trim();
+    if (codeBlock) {
+      blocks.push(codeBlock);
+    }
+    cursor = index + (match[0]?.length ?? 0);
+  }
+  const remainder = text.slice(cursor);
+  blocks.push(...splitParagraphs(remainder));
+  return blocks.filter((entry) => entry.length > 0);
+}
+function splitParagraphs(text) {
+  return text.split(/\n\s*\n+/).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function splitOversizedBlock(block, chunkSize) {
+  if (isFencedCodeBlock(block)) {
+    return splitFencedCodeBlock(block, chunkSize);
+  }
+  return splitPlainText(block, chunkSize);
+}
+function isFencedCodeBlock(block) {
+  return block.startsWith("```") && block.endsWith("```");
+}
+function splitFencedCodeBlock(block, chunkSize) {
+  const lines = block.split("\n");
+  if (lines.length < 2) {
+    return splitPlainText(block, chunkSize);
+  }
+  const openingFence = lines[0];
+  const closingFence = lines[lines.length - 1];
+  if (!openingFence.startsWith("```") || closingFence !== "```") {
+    return splitPlainText(block, chunkSize);
+  }
+  const maxBodySize = chunkSize - openingFence.length - closingFence.length - 2;
+  if (maxBodySize <= 20) {
+    return splitPlainText(block, chunkSize);
+  }
+  const body = lines.slice(1, -1).join("\n");
+  const bodyParts = splitPlainText(body, maxBodySize);
+  if (bodyParts.length === 0) {
+    return [block];
+  }
+  return bodyParts.map((part) => `${openingFence}
+${part}
+${closingFence}`);
+}
+function splitPlainText(text, chunkSize) {
+  if (text.length <= chunkSize) {
+    return [text];
+  }
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > chunkSize) {
+    const candidate = remaining.slice(0, chunkSize);
+    const breakIndex = findBreakIndex(candidate);
+    const splitAt = breakIndex > 0 ? breakIndex : chunkSize;
+    const head = remaining.slice(0, splitAt).trim();
+    if (head) {
+      chunks.push(head);
+    }
+    remaining = remaining.slice(splitAt).trim();
+  }
+  if (remaining) {
+    chunks.push(remaining);
+  }
+  return chunks.length > 0 ? chunks : [text.slice(0, chunkSize)];
+}
+function findBreakIndex(candidate) {
+  const newline = candidate.lastIndexOf("\n");
+  if (newline >= Math.floor(candidate.length * 0.5)) {
+    return newline;
+  }
+  const whitespace = candidate.search(/\s[^\s]*$/);
+  if (whitespace >= Math.floor(candidate.length * 0.5)) {
+    return whitespace;
+  }
+  return -1;
+}
+
+// src/channels/matrix-channel.ts
+var MatrixChannel = class {
+  config;
+  logger;
+  chunkSize;
+  splitReplies;
+  preserveWhitespace;
+  fetchMedia;
+  client;
+  handler = null;
+  started = false;
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+    this.chunkSize = config.replyChunkSize;
+    this.splitReplies = !config.cliCompat.disableReplyChunkSplit;
+    this.preserveWhitespace = config.cliCompat.preserveWhitespace;
+    this.fetchMedia = config.cliCompat.fetchMedia;
+    this.client = (0, import_matrix_js_sdk.createClient)({
+      baseUrl: config.matrixHomeserver,
+      accessToken: config.matrixAccessToken,
+      userId: config.matrixUserId
+    });
+  }
+  async start(handler) {
+    this.handler = handler;
+    this.client.on(import_matrix_js_sdk.RoomEvent.Timeline, this.onTimeline);
+    this.client.on(import_matrix_js_sdk.RoomMemberEvent.Membership, this.onMembership);
+    const readyPromise = this.waitUntilReady();
+    this.client.startClient({ initialSyncLimit: 10 });
+    await readyPromise;
+    await this.joinPendingInvites();
+    this.started = true;
+    this.logger.info("Matrix channel ready.");
+  }
+  async sendMessage(conversationId, text) {
+    if (!this.started) {
+      throw new Error("Matrix channel not started.");
+    }
+    const chunks = this.splitReplies ? splitText(text, this.chunkSize) : [text];
+    for (const chunk of chunks) {
+      await this.client.sendTextMessage(conversationId, chunk);
+    }
+  }
+  async sendNotice(conversationId, text) {
+    if (!this.started) {
+      throw new Error("Matrix channel not started.");
+    }
+    const chunks = this.splitReplies ? splitText(text, this.chunkSize) : [text];
+    for (const chunk of chunks) {
+      await this.client.sendNotice(conversationId, chunk);
+    }
+  }
+  async upsertProgressNotice(conversationId, text, replaceEventId) {
+    if (!this.started) {
+      throw new Error("Matrix channel not started.");
+    }
+    const normalized = (this.splitReplies ? splitText(text, this.chunkSize)[0] : text) ?? "";
+    if (!normalized.trim()) {
+      throw new Error("Progress notice cannot be empty.");
+    }
+    if (!replaceEventId) {
+      const response2 = await this.client.sendNotice(conversationId, normalized);
+      return response2.event_id;
+    }
+    const content = {
+      msgtype: "m.notice",
+      body: `* ${normalized}`,
+      "m.new_content": {
+        msgtype: "m.notice",
+        body: normalized
+      },
+      "m.relates_to": {
+        rel_type: "m.replace",
+        event_id: replaceEventId
+      }
+    };
+    const sendEditEvent = this.client.sendEvent;
+    const response = await sendEditEvent(conversationId, import_matrix_js_sdk.EventType.RoomMessage, content);
+    return response.event_id;
+  }
+  async setTyping(conversationId, isTyping, timeoutMs) {
+    if (!this.started) {
+      throw new Error("Matrix channel not started.");
+    }
+    const safeTimeout = Math.max(0, timeoutMs);
+    await this.client.sendTyping(conversationId, isTyping, safeTimeout);
+  }
+  async stop() {
+    this.client.removeListener(import_matrix_js_sdk.RoomEvent.Timeline, this.onTimeline);
+    this.client.removeListener(import_matrix_js_sdk.RoomMemberEvent.Membership, this.onMembership);
+    this.client.stopClient();
+    this.started = false;
+  }
+  onMembership = (_event, member) => {
+    if (!member || member.membership !== "invite") {
+      return;
+    }
+    if (member.userId !== this.config.matrixUserId) {
+      return;
+    }
+    if (!member.roomId) {
+      return;
+    }
+    void this.joinInvitedRoom(member.roomId);
+  };
+  onTimeline = (event, room, toStartOfTimeline) => {
+    if (!this.handler || !room || toStartOfTimeline) {
+      return;
+    }
+    if (event.getType() !== "m.room.message") {
+      return;
+    }
+    const senderId = event.getSender();
+    if (!senderId || senderId === this.config.matrixUserId) {
+      return;
+    }
+    const content = event.getContent();
+    if (!content || typeof content !== "object") {
+      return;
+    }
+    const msgtype = typeof content.msgtype === "string" ? content.msgtype : "";
+    const acceptedMsgtypes = /* @__PURE__ */ new Set(["m.text", "m.image", "m.file", "m.audio", "m.video"]);
+    if (!acceptedMsgtypes.has(msgtype)) {
+      return;
+    }
+    const eventId = event.getId();
+    if (!eventId || typeof eventId !== "string") {
+      return;
+    }
+    const body = typeof content.body === "string" ? content.body : "";
+    const text = this.preserveWhitespace ? body : body.trim();
+    const attachments = extractAttachments(content);
+    if (!text.trim() && attachments.length === 0) {
+      return;
+    }
+    const isDirectMessage = isDirectRoom(room);
+    const mentionsBot = checkMentionsBot(content, text, this.config.matrixUserId);
+    const repliesToBot = checkRepliesToBot(content, room, this.config.matrixUserId);
+    void this.dispatchInbound({
+      senderId,
+      roomId: room.roomId,
+      eventId,
+      text,
+      attachments,
+      isDirectMessage,
+      mentionsBot,
+      repliesToBot
+    });
+  };
+  async dispatchInbound(params) {
+    if (!this.handler) {
+      return;
+    }
+    const hydratedAttachments = await this.hydrateAttachments(params.attachments, params.eventId);
+    const inbound = {
+      requestId: buildRequestId(params.eventId),
+      channel: "matrix",
+      conversationId: params.roomId,
+      senderId: params.senderId,
+      eventId: params.eventId,
+      text: params.text,
+      attachments: hydratedAttachments,
+      isDirectMessage: params.isDirectMessage,
+      mentionsBot: params.mentionsBot,
+      repliesToBot: params.repliesToBot
+    };
+    try {
+      await this.handler(inbound);
+    } catch (error) {
+      this.logger.error("Unhandled inbound processing error", error);
+    }
+  }
+  async waitUntilReady(timeoutMs = 6e4) {
+    await new Promise((resolve, reject) => {
+      const currentState = this.client.getSyncState();
+      if (currentState === "PREPARED" || currentState === "SYNCING") {
+        resolve();
+        return;
+      }
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(new Error("Matrix sync timeout."));
+      }, timeoutMs);
+      const onSync = (state) => {
+        if (state === "PREPARED" || state === "SYNCING") {
+          cleanup();
+          resolve();
+        } else if (state === "ERROR") {
+          cleanup();
+          reject(new Error("Matrix sync error."));
+        }
+      };
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.client.removeListener(import_matrix_js_sdk.ClientEvent.Sync, onSync);
+      };
+      this.client.on(import_matrix_js_sdk.ClientEvent.Sync, onSync);
+    });
+  }
+  async joinInvitedRoom(roomId) {
+    try {
+      this.logger.info("Received room invite, joining", { roomId });
+      await this.client.joinRoom(roomId);
+      this.logger.info("Joined room", { roomId });
+    } catch (error) {
+      this.logger.error("Failed to join invited room", { roomId, error });
+    }
+  }
+  async joinPendingInvites() {
+    const rooms = this.client.getRooms();
+    for (const room of rooms) {
+      if (room.getMyMembership() !== "invite") {
+        continue;
+      }
+      await this.joinInvitedRoom(room.roomId);
+    }
+  }
+  async hydrateAttachments(attachments, eventId) {
+    if (!this.fetchMedia || attachments.length === 0) {
+      return attachments;
+    }
+    const hydrated = await Promise.all(
+      attachments.map(async (attachment, index) => {
+        if (attachment.kind !== "image" || !attachment.mxcUrl) {
+          return attachment;
+        }
+        try {
+          const localPath = await this.downloadMxcAttachment(
+            attachment.mxcUrl,
+            attachment.name,
+            attachment.mimeType,
+            eventId,
+            index
+          );
+          return {
+            ...attachment,
+            localPath
+          };
+        } catch (error) {
+          this.logger.warn("Failed to hydrate attachment", {
+            eventId,
+            mxcUrl: attachment.mxcUrl,
+            error
+          });
+          return attachment;
+        }
+      })
+    );
+    return hydrated;
+  }
+  async downloadMxcAttachment(mxcUrl, fileName, mimeType, eventId, index) {
+    const parsed = parseMxcUrl(mxcUrl);
+    if (!parsed) {
+      throw new Error(`Unsupported MXC URL: ${mxcUrl}`);
+    }
+    const mediaUrls = [
+      `${this.config.matrixHomeserver}/_matrix/media/v3/download/${encodeURIComponent(parsed.serverName)}/${encodeURIComponent(parsed.mediaId)}`,
+      `${this.config.matrixHomeserver}/_matrix/media/r0/download/${encodeURIComponent(parsed.serverName)}/${encodeURIComponent(parsed.mediaId)}`
+    ];
+    const headers = {
+      Authorization: `Bearer ${this.config.matrixAccessToken}`
+    };
+    let response = null;
+    for (const url of mediaUrls) {
+      const candidate = await fetch(url, { headers });
+      if (candidate.ok) {
+        response = candidate;
+        break;
+      }
+    }
+    if (!response) {
+      throw new Error(`Failed to download media for ${mxcUrl}`);
+    }
+    const bytes = Buffer.from(await response.arrayBuffer());
+    const extension = resolveFileExtension(fileName, mimeType);
+    const directory = import_node_path.default.join(import_node_os.default.tmpdir(), "codeharbor-media");
+    await import_promises.default.mkdir(directory, { recursive: true });
+    const safeEventId = sanitizeFilename(eventId);
+    const targetPath = import_node_path.default.join(directory, `${safeEventId}-${index}${extension}`);
+    await import_promises.default.writeFile(targetPath, bytes);
+    return targetPath;
+  }
+};
+function buildRequestId(eventId) {
+  const suffix = Math.random().toString(36).slice(2, 8);
+  return `${eventId}:${suffix}`;
+}
+function isDirectRoom(room) {
+  return room.getJoinedMemberCount() <= 2;
+}
+function checkMentionsBot(content, body, botUserId) {
+  const mentions = content["m.mentions"];
+  if (mentions && typeof mentions === "object") {
+    const userIds = mentions.user_ids;
+    if (Array.isArray(userIds) && userIds.some((userId) => userId === botUserId)) {
+      return true;
+    }
+  }
+  return body.includes(botUserId);
+}
+function checkRepliesToBot(content, room, botUserId) {
+  const relatesTo = content["m.relates_to"];
+  if (!relatesTo || typeof relatesTo !== "object") {
+    return false;
+  }
+  const inReplyTo = relatesTo["m.in_reply_to"];
+  if (!inReplyTo || typeof inReplyTo !== "object") {
+    return false;
+  }
+  const eventId = inReplyTo.event_id;
+  if (typeof eventId !== "string" || !eventId) {
+    return false;
+  }
+  const repliedEvent = room.findEventById(eventId);
+  return repliedEvent?.getSender() === botUserId;
+}
+function extractAttachments(content) {
+  const msgtype = typeof content.msgtype === "string" ? content.msgtype : "";
+  const mapping = {
+    "m.image": "image",
+    "m.file": "file",
+    "m.audio": "audio",
+    "m.video": "video"
+  };
+  const kind = mapping[msgtype];
+  if (!kind) {
+    return [];
+  }
+  const body = typeof content.body === "string" && content.body.trim() ? content.body.trim() : "attachment";
+  const info = content.info && typeof content.info === "object" ? content.info : {};
+  const mimeType = typeof info.mimetype === "string" ? info.mimetype : null;
+  const sizeBytes = typeof info.size === "number" ? info.size : null;
+  const directUrl = typeof content.url === "string" ? content.url : null;
+  const encryptedFile = content.file && typeof content.file === "object" ? content.file : {};
+  const encryptedUrl = typeof encryptedFile.url === "string" ? encryptedFile.url : null;
+  return [
+    {
+      kind,
+      name: body,
+      mxcUrl: directUrl ?? encryptedUrl,
+      mimeType,
+      sizeBytes,
+      localPath: null
+    }
+  ];
+}
+function parseMxcUrl(mxcUrl) {
+  if (!mxcUrl.startsWith("mxc://")) {
+    return null;
+  }
+  const stripped = mxcUrl.slice("mxc://".length);
+  const slashIndex = stripped.indexOf("/");
+  if (slashIndex <= 0 || slashIndex === stripped.length - 1) {
+    return null;
+  }
+  const serverName = stripped.slice(0, slashIndex);
+  const mediaId = stripped.slice(slashIndex + 1);
+  return { serverName, mediaId };
+}
+function sanitizeFilename(value) {
+  return value.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 80);
+}
+function resolveFileExtension(fileName, mimeType) {
+  const ext = import_node_path.default.extname(fileName).trim();
+  if (ext) {
+    return ext;
+  }
+  if (mimeType === "image/png") {
+    return ".png";
+  }
+  if (mimeType === "image/jpeg") {
+    return ".jpg";
+  }
+  if (mimeType === "image/webp") {
+    return ".webp";
+  }
+  return ".bin";
+}
+
+// src/executor/codex-executor.ts
+var import_node_child_process = require("child_process");
+var import_node_readline = __toESM(require("readline"));
+var CodexExecutionCancelledError = class extends Error {
+  constructor(message = "codex execution cancelled") {
+    super(message);
+    this.name = "CodexExecutionCancelledError";
+  }
+};
+var CodexExecutor = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async execute(prompt, sessionId, onProgress, startOptions) {
+    return this.startExecution(prompt, sessionId, onProgress, startOptions).result;
+  }
+  startExecution(prompt, sessionId, onProgress, startOptions) {
+    const args = buildCodexArgs(prompt, sessionId, this.options, startOptions);
+    const child = (0, import_node_child_process.spawn)(this.options.bin, args, {
+      cwd: this.options.workdir,
+      env: {
+        ...process.env,
+        ...this.options.extraEnv
+      },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stderr = "";
+    let resolvedThreadId = sessionId;
+    let latestMessage = "";
+    let timedOut = false;
+    let cancelled = false;
+    let killTimer = null;
+    let completed = false;
+    const passThroughRawEvents = startOptions?.passThroughRawEvents ?? false;
+    const lineReader = import_node_readline.default.createInterface({ input: child.stdout });
+    lineReader.on("line", (line) => {
+      const event = parseCodexJsonLine(line);
+      if (!event) {
+        return;
+      }
+      if (passThroughRawEvents) {
+        onProgress?.({
+          stage: "raw_event",
+          eventType: typeof event.type === "string" ? event.type : "unknown",
+          raw: event,
+          message: summarizeRawEvent(event)
+        });
+      }
+      if (event.type === "thread.started" && event.thread_id) {
+        resolvedThreadId = event.thread_id;
+        onProgress?.({ stage: "thread_started", message: event.thread_id, eventType: event.type, raw: event });
+      }
+      if (event.type === "turn.started") {
+        onProgress?.({ stage: "turn_started", eventType: event.type, raw: event });
+      }
+      if (event.type === "item.completed" && event.item?.type === "agent_message" && event.item.text) {
+        latestMessage = event.item.text.trim();
+      }
+      if (event.type === "item.completed" && event.item?.type === "reasoning" && event.item.text) {
+        onProgress?.({
+          stage: "reasoning",
+          message: event.item.text.trim(),
+          eventType: event.type,
+          raw: event
+        });
+      }
+      if (event.type === "item.completed" && event.item?.type && event.item?.type !== "agent_message" && event.item?.type !== "reasoning") {
+        onProgress?.({
+          stage: "item_completed",
+          message: event.item.type,
+          eventType: event.type,
+          raw: event
+        });
+      }
+      if (event.type === "turn.completed") {
+        onProgress?.({ stage: "turn_completed", eventType: event.type, raw: event });
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      const chunkText = chunk.toString("utf8");
+      stderr += chunkText;
+      const normalized = chunkText.replace(/\s+/g, " ").trim();
+      if (normalized) {
+        onProgress?.({
+          stage: "stderr",
+          message: normalized
+        });
+      }
+    });
+    const terminateProcess = (mode) => {
+      if (completed) {
+        return;
+      }
+      if (mode === "timeout") {
+        timedOut = true;
+      } else {
+        cancelled = true;
+      }
+      child.kill("SIGTERM");
+      if (!killTimer) {
+        killTimer = setTimeout(() => {
+          child.kill("SIGKILL");
+        }, 5e3);
+        killTimer.unref?.();
+      }
+    };
+    const timeoutTimer = this.options.timeoutMs > 0 ? setTimeout(() => {
+      terminateProcess("timeout");
+    }, this.options.timeoutMs) : null;
+    timeoutTimer?.unref?.();
+    const result = (async () => {
+      const exitCode = await new Promise((resolve, reject) => {
+        child.on("error", reject);
+        child.on("close", (code) => resolve(code ?? 1));
+      });
+      if (timedOut) {
+        throw new Error(`codex execution timed out after ${this.options.timeoutMs}ms`);
+      }
+      if (cancelled) {
+        throw new CodexExecutionCancelledError();
+      }
+      if (exitCode !== 0) {
+        throw new Error(`codex exited with code ${exitCode}: ${stderr.trim() || "<no stderr output>"}`);
+      }
+      if (!resolvedThreadId) {
+        throw new Error("codex did not return thread_id.");
+      }
+      if (!latestMessage) {
+        throw new Error("codex did not return a final assistant message.");
+      }
+      return {
+        sessionId: resolvedThreadId,
+        reply: latestMessage
+      };
+    })().finally(() => {
+      completed = true;
+      if (timeoutTimer) {
+        clearTimeout(timeoutTimer);
+      }
+      if (killTimer) {
+        clearTimeout(killTimer);
+      }
+      lineReader.close();
+    });
+    return {
+      result,
+      cancel: () => {
+        terminateProcess("cancel");
+      }
+    };
+  }
+};
+function parseCodexJsonLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+function buildCodexArgs(prompt, sessionId, options, startOptions) {
+  const args = [];
+  if (sessionId) {
+    args.push("exec", "resume", "--json", "--skip-git-repo-check", sessionId, prompt);
+  } else {
+    args.push("exec", "--json", "--skip-git-repo-check", prompt);
+  }
+  if (options.model) {
+    args.push("--model", options.model);
+  }
+  if (options.sandboxMode) {
+    args.push("--sandbox", options.sandboxMode);
+  }
+  if (options.approvalPolicy) {
+    args.push("--ask-for-approval", options.approvalPolicy);
+  }
+  for (const imagePath of startOptions?.imagePaths ?? []) {
+    if (imagePath.trim()) {
+      args.push("--image", imagePath);
+    }
+  }
+  if (options.extraArgs.length > 0) {
+    args.push(...options.extraArgs);
+  }
+  if (options.dangerousBypass) {
+    args.push("--dangerously-bypass-approvals-and-sandbox");
+  }
+  return args;
+}
+function summarizeRawEvent(event) {
+  const type = typeof event.type === "string" ? event.type : "unknown";
+  const itemType = event.item?.type ? ` item=${event.item.type}` : "";
+  return `event=${type}${itemType}`;
+}
+
+// src/logger.ts
+var ORDER = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+var Logger = class {
+  level;
+  constructor(level) {
+    this.level = level;
+  }
+  debug(message, ...args) {
+    this.log("debug", message, ...args);
+  }
+  info(message, ...args) {
+    this.log("info", message, ...args);
+  }
+  warn(message, ...args) {
+    this.log("warn", message, ...args);
+  }
+  error(message, ...args) {
+    this.log("error", message, ...args);
+  }
+  log(level, message, ...args) {
+    if (ORDER[level] < ORDER[this.level]) {
+      return;
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const payload = args.length > 0 ? ` ${args.map(stringify).join(" ")}` : "";
+    const line = `${timestamp} ${level.toUpperCase()} ${message}${payload}`;
+    if (level === "error") {
+      process.stderr.write(`${line}
+`);
+      return;
+    }
+    process.stdout.write(`${line}
+`);
+  }
+};
+function stringify(value) {
+  if (value instanceof Error) {
+    return `${value.name}: ${value.message}`;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+// src/orchestrator.ts
+var import_async_mutex = require("async-mutex");
+var import_promises2 = __toESM(require("fs/promises"));
+
+// src/compat/cli-compat-recorder.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+var CliCompatRecorder = class {
+  filePath;
+  chain = Promise.resolve();
+  constructor(filePath) {
+    this.filePath = import_node_path2.default.resolve(filePath);
+    import_node_fs.default.mkdirSync(import_node_path2.default.dirname(this.filePath), { recursive: true });
+  }
+  append(entry) {
+    const payload = `${JSON.stringify(entry)}
+`;
+    this.chain = this.chain.then(async () => {
+      await import_node_fs.default.promises.appendFile(this.filePath, payload, "utf8");
+    });
+    return this.chain;
+  }
+};
+
+// src/executor/codex-session-runtime.ts
+var CodexSessionRuntime = class {
+  executor;
+  idleTtlMs;
+  workers = /* @__PURE__ */ new Map();
+  constructor(executor, options) {
+    this.executor = executor;
+    this.idleTtlMs = options?.idleTtlMs ?? 30 * 60 * 1e3;
+  }
+  startExecution(sessionKey, prompt, persistedSessionId, onProgress, startOptions) {
+    this.prune(Date.now());
+    const worker = this.getOrCreateWorker(sessionKey, persistedSessionId);
+    const effectiveSessionId = worker.lastSessionId ?? persistedSessionId;
+    worker.lastUsedAt = Date.now();
+    const handle = this.executor.startExecution(prompt, effectiveSessionId, onProgress, startOptions);
+    worker.runningHandle = handle;
+    const result = handle.result.then((executionResult) => {
+      worker.lastSessionId = executionResult.sessionId;
+      worker.lastUsedAt = Date.now();
+      return executionResult;
+    }).finally(() => {
+      if (worker.runningHandle === handle) {
+        worker.runningHandle = null;
+      }
+    });
+    return {
+      result,
+      cancel: () => {
+        handle.cancel();
+      }
+    };
+  }
+  clearSession(sessionKey) {
+    const worker = this.workers.get(sessionKey);
+    if (!worker) {
+      return;
+    }
+    worker.lastSessionId = null;
+    worker.lastUsedAt = Date.now();
+  }
+  cancelRunningExecution(sessionKey) {
+    const worker = this.workers.get(sessionKey);
+    if (!worker?.runningHandle) {
+      return false;
+    }
+    worker.runningHandle.cancel();
+    worker.lastUsedAt = Date.now();
+    return true;
+  }
+  getRuntimeStats() {
+    let runningCount = 0;
+    for (const worker of this.workers.values()) {
+      if (worker.runningHandle) {
+        runningCount += 1;
+      }
+    }
+    return {
+      workerCount: this.workers.size,
+      runningCount
+    };
+  }
+  getOrCreateWorker(sessionKey, persistedSessionId) {
+    const existing = this.workers.get(sessionKey);
+    if (existing) {
+      if (persistedSessionId && !existing.lastSessionId) {
+        existing.lastSessionId = persistedSessionId;
+      }
+      return existing;
+    }
+    const created = {
+      lastUsedAt: Date.now(),
+      lastSessionId: persistedSessionId,
+      runningHandle: null
+    };
+    this.workers.set(sessionKey, created);
+    return created;
+  }
+  prune(now) {
+    const expireBefore = now - this.idleTtlMs;
+    for (const [key, worker] of this.workers.entries()) {
+      if (worker.lastUsedAt >= expireBefore) {
+        continue;
+      }
+      if (worker.runningHandle) {
+        continue;
+      }
+      this.workers.delete(key);
+    }
+  }
+};
+
+// src/rate-limiter.ts
+var RateLimiter = class {
+  options;
+  userRequests = /* @__PURE__ */ new Map();
+  roomRequests = /* @__PURE__ */ new Map();
+  userConcurrent = /* @__PURE__ */ new Map();
+  roomConcurrent = /* @__PURE__ */ new Map();
+  globalConcurrent = 0;
+  constructor(options) {
+    this.options = options;
+  }
+  tryAcquire(params, now = Date.now()) {
+    const userTimestamps = this.pruneAndGetWindow(this.userRequests, params.userId, now);
+    if (this.options.maxRequestsPerUser > 0 && userTimestamps.length >= this.options.maxRequestsPerUser) {
+      return {
+        allowed: false,
+        reason: "user_requests_per_window",
+        retryAfterMs: computeRetryAfter(userTimestamps, this.options.windowMs, now)
+      };
+    }
+    const roomTimestamps = this.pruneAndGetWindow(this.roomRequests, params.roomId, now);
+    if (this.options.maxRequestsPerRoom > 0 && roomTimestamps.length >= this.options.maxRequestsPerRoom) {
+      return {
+        allowed: false,
+        reason: "room_requests_per_window",
+        retryAfterMs: computeRetryAfter(roomTimestamps, this.options.windowMs, now)
+      };
+    }
+    if (this.options.maxConcurrentGlobal > 0 && this.globalConcurrent >= this.options.maxConcurrentGlobal) {
+      return {
+        allowed: false,
+        reason: "global_concurrency"
+      };
+    }
+    const activeForUser = this.userConcurrent.get(params.userId) ?? 0;
+    if (this.options.maxConcurrentPerUser > 0 && activeForUser >= this.options.maxConcurrentPerUser) {
+      return {
+        allowed: false,
+        reason: "user_concurrency"
+      };
+    }
+    const activeForRoom = this.roomConcurrent.get(params.roomId) ?? 0;
+    if (this.options.maxConcurrentPerRoom > 0 && activeForRoom >= this.options.maxConcurrentPerRoom) {
+      return {
+        allowed: false,
+        reason: "room_concurrency"
+      };
+    }
+    userTimestamps.push(now);
+    roomTimestamps.push(now);
+    this.userRequests.set(params.userId, userTimestamps);
+    this.roomRequests.set(params.roomId, roomTimestamps);
+    this.globalConcurrent += 1;
+    this.userConcurrent.set(params.userId, activeForUser + 1);
+    this.roomConcurrent.set(params.roomId, activeForRoom + 1);
+    let released = false;
+    return {
+      allowed: true,
+      release: () => {
+        if (released) {
+          return;
+        }
+        released = true;
+        this.globalConcurrent = Math.max(0, this.globalConcurrent - 1);
+        this.decrementCounter(this.userConcurrent, params.userId);
+        this.decrementCounter(this.roomConcurrent, params.roomId);
+      }
+    };
+  }
+  snapshot() {
+    return {
+      activeGlobal: this.globalConcurrent,
+      activeUsers: this.userConcurrent.size,
+      activeRooms: this.roomConcurrent.size
+    };
+  }
+  pruneAndGetWindow(container, key, now) {
+    const existing = container.get(key);
+    if (!existing) {
+      return [];
+    }
+    const threshold = now - this.options.windowMs;
+    const pruned = existing.filter((ts) => ts > threshold);
+    if (pruned.length === 0) {
+      container.delete(key);
+      return [];
+    }
+    container.set(key, pruned);
+    return pruned;
+  }
+  decrementCounter(container, key) {
+    const current = container.get(key) ?? 0;
+    if (current <= 1) {
+      container.delete(key);
+      return;
+    }
+    container.set(key, current - 1);
+  }
+};
+function computeRetryAfter(timestamps, windowMs, now) {
+  const oldest = timestamps[0];
+  if (typeof oldest !== "number") {
+    return windowMs;
+  }
+  return Math.max(0, oldest + windowMs - now);
+}
+
+// src/orchestrator.ts
+var RequestMetrics = class {
+  total = 0;
+  success = 0;
+  failed = 0;
+  timeout = 0;
+  cancelled = 0;
+  rateLimited = 0;
+  ignored = 0;
+  duplicate = 0;
+  totalQueueMs = 0;
+  totalExecMs = 0;
+  totalSendMs = 0;
+  record(outcome, queueMs, execMs, sendMs) {
+    this.total += 1;
+    this.totalQueueMs += Math.max(0, queueMs);
+    this.totalExecMs += Math.max(0, execMs);
+    this.totalSendMs += Math.max(0, sendMs);
+    if (outcome === "success") {
+      this.success += 1;
+      return;
+    }
+    if (outcome === "failed") {
+      this.failed += 1;
+      return;
+    }
+    if (outcome === "timeout") {
+      this.timeout += 1;
+      return;
+    }
+    if (outcome === "cancelled") {
+      this.cancelled += 1;
+      return;
+    }
+    if (outcome === "rate_limited") {
+      this.rateLimited += 1;
+      return;
+    }
+    if (outcome === "ignored") {
+      this.ignored += 1;
+      return;
+    }
+    this.duplicate += 1;
+  }
+  snapshot(activeExecutions) {
+    const divisor = this.total > 0 ? this.total : 1;
+    return {
+      total: this.total,
+      success: this.success,
+      failed: this.failed,
+      timeout: this.timeout,
+      cancelled: this.cancelled,
+      rateLimited: this.rateLimited,
+      ignored: this.ignored,
+      duplicate: this.duplicate,
+      activeExecutions,
+      avgQueueMs: Math.round(this.totalQueueMs / divisor),
+      avgExecMs: Math.round(this.totalExecMs / divisor),
+      avgSendMs: Math.round(this.totalSendMs / divisor)
+    };
+  }
+};
+var Orchestrator = class {
+  channel;
+  executor;
+  sessionRuntime;
+  stateStore;
+  logger;
+  sessionLocks = /* @__PURE__ */ new Map();
+  runningExecutions = /* @__PURE__ */ new Map();
+  lockTtlMs;
+  lockPruneIntervalMs;
+  progressUpdatesEnabled;
+  progressMinIntervalMs;
+  typingTimeoutMs;
+  commandPrefix;
+  matrixUserId;
+  sessionActiveWindowMs;
+  defaultGroupTriggerPolicy;
+  roomTriggerPolicies;
+  rateLimiter;
+  cliCompat;
+  cliCompatRecorder;
+  metrics = new RequestMetrics();
+  lastLockPruneAt = 0;
+  constructor(channel, executor, stateStore, logger, options) {
+    this.channel = channel;
+    this.executor = executor;
+    this.stateStore = stateStore;
+    this.logger = logger;
+    this.lockTtlMs = options?.lockTtlMs ?? 30 * 60 * 1e3;
+    this.lockPruneIntervalMs = options?.lockPruneIntervalMs ?? 5 * 60 * 1e3;
+    this.progressUpdatesEnabled = options?.progressUpdatesEnabled ?? false;
+    this.cliCompat = options?.cliCompat ?? {
+      enabled: false,
+      passThroughEvents: false,
+      preserveWhitespace: false,
+      disableReplyChunkSplit: false,
+      progressThrottleMs: 300,
+      fetchMedia: false,
+      recordPath: null
+    };
+    this.cliCompatRecorder = this.cliCompat.recordPath ? new CliCompatRecorder(this.cliCompat.recordPath) : null;
+    const defaultProgressInterval = options?.progressMinIntervalMs ?? 2500;
+    this.progressMinIntervalMs = this.cliCompat.enabled ? this.cliCompat.progressThrottleMs : defaultProgressInterval;
+    this.typingTimeoutMs = options?.typingTimeoutMs ?? 1e4;
+    this.commandPrefix = (options?.commandPrefix ?? "").trim();
+    this.matrixUserId = options?.matrixUserId ?? "";
+    const sessionActiveWindowMinutes = options?.sessionActiveWindowMinutes ?? 20;
+    this.sessionActiveWindowMs = Math.max(1, sessionActiveWindowMinutes) * 6e4;
+    this.defaultGroupTriggerPolicy = options?.defaultGroupTriggerPolicy ?? {
+      allowMention: true,
+      allowReply: true,
+      allowActiveWindow: true,
+      allowPrefix: true
+    };
+    this.roomTriggerPolicies = options?.roomTriggerPolicies ?? {};
+    this.rateLimiter = new RateLimiter(
+      options?.rateLimiterOptions ?? {
+        windowMs: 6e4,
+        maxRequestsPerUser: 20,
+        maxRequestsPerRoom: 120,
+        maxConcurrentGlobal: 8,
+        maxConcurrentPerUser: 1,
+        maxConcurrentPerRoom: 4
+      }
+    );
+    this.sessionRuntime = new CodexSessionRuntime(this.executor);
+  }
+  async handleMessage(message) {
+    const receivedAt = Date.now();
+    const requestId = message.requestId || message.eventId;
+    const sessionKey = buildSessionKey(message);
+    const directCommand = parseControlCommand(message.text.trim());
+    if (directCommand === "stop") {
+      if (this.stateStore.hasProcessedEvent(sessionKey, message.eventId)) {
+        this.metrics.record("duplicate", 0, 0, 0);
+        this.logger.debug("Duplicate stop command ignored", { requestId, eventId: message.eventId, sessionKey });
+        return;
+      }
+      await this.handleStopCommand(sessionKey, message, requestId);
+      this.stateStore.markEventProcessed(sessionKey, message.eventId);
+      return;
+    }
+    const lock = this.getLock(sessionKey);
+    await lock.runExclusive(async () => {
+      const queueWaitMs = Date.now() - receivedAt;
+      if (this.stateStore.hasProcessedEvent(sessionKey, message.eventId)) {
+        this.metrics.record("duplicate", queueWaitMs, 0, 0);
+        this.logger.debug("Duplicate event ignored", { requestId, eventId: message.eventId, sessionKey, queueWaitMs });
+        return;
+      }
+      const route = this.routeMessage(message, sessionKey);
+      if (route.kind === "ignore") {
+        this.metrics.record("ignored", queueWaitMs, 0, 0);
+        this.logger.debug("Message ignored by routing policy", {
+          requestId,
+          sessionKey,
+          isDirectMessage: message.isDirectMessage,
+          mentionsBot: message.mentionsBot,
+          repliesToBot: message.repliesToBot
+        });
+        return;
+      }
+      if (route.kind === "command") {
+        await this.handleControlCommand(route.command, sessionKey, message, requestId);
+        this.stateStore.markEventProcessed(sessionKey, message.eventId);
+        return;
+      }
+      const rateDecision = this.rateLimiter.tryAcquire({
+        userId: message.senderId,
+        roomId: message.conversationId
+      });
+      if (!rateDecision.allowed) {
+        this.metrics.record("rate_limited", queueWaitMs, 0, 0);
+        await this.channel.sendNotice(message.conversationId, buildRateLimitNotice(rateDecision));
+        this.stateStore.markEventProcessed(sessionKey, message.eventId);
+        this.logger.warn("Request rejected by rate limiter", {
+          requestId,
+          sessionKey,
+          reason: rateDecision.reason,
+          retryAfterMs: rateDecision.retryAfterMs ?? null,
+          queueWaitMs
+        });
+        return;
+      }
+      this.stateStore.activateSession(sessionKey, this.sessionActiveWindowMs);
+      const previousCodexSessionId = this.stateStore.getCodexSessionId(sessionKey);
+      const executionPrompt = this.buildExecutionPrompt(route.prompt, message);
+      const imagePaths = collectImagePaths(message);
+      let lastProgressAt = 0;
+      let lastProgressText = "";
+      let progressNoticeEventId = null;
+      let progressChain = Promise.resolve();
+      let executionHandle = null;
+      let executionDurationMs = 0;
+      let sendDurationMs = 0;
+      const requestStartedAt = Date.now();
+      let cancelRequested = false;
+      this.runningExecutions.set(sessionKey, {
+        requestId,
+        startedAt: requestStartedAt,
+        cancel: () => {
+          cancelRequested = true;
+          executionHandle?.cancel();
+        }
+      });
+      await this.recordCliCompatPrompt({
+        requestId,
+        sessionKey,
+        conversationId: message.conversationId,
+        senderId: message.senderId,
+        prompt: executionPrompt,
+        imageCount: imagePaths.length
+      });
+      this.logger.info("Processing message", {
+        requestId,
+        sessionKey,
+        hasCodexSession: Boolean(previousCodexSessionId),
+        queueWaitMs,
+        attachmentCount: message.attachments.length,
+        isDirectMessage: message.isDirectMessage,
+        mentionsBot: message.mentionsBot,
+        repliesToBot: message.repliesToBot
+      });
+      const stopTyping = this.startTypingHeartbeat(message.conversationId);
+      try {
+        const executionStartedAt = Date.now();
+        executionHandle = this.sessionRuntime.startExecution(
+          sessionKey,
+          executionPrompt,
+          previousCodexSessionId,
+          (progress) => {
+            progressChain = progressChain.then(
+              () => this.handleProgress(
+                message.conversationId,
+                message.isDirectMessage,
+                progress,
+                () => lastProgressAt,
+                (next) => {
+                  lastProgressAt = next;
+                },
+                () => lastProgressText,
+                (next) => {
+                  lastProgressText = next;
+                },
+                () => progressNoticeEventId,
+                (next) => {
+                  progressNoticeEventId = next;
+                }
+              )
+            ).catch((progressError) => {
+              this.logger.debug("Failed to process progress callback", { progressError });
+            });
+          },
+          {
+            passThroughRawEvents: this.cliCompat.enabled && this.cliCompat.passThroughEvents,
+            imagePaths
+          }
+        );
+        const running = this.runningExecutions.get(sessionKey);
+        if (running?.requestId === requestId) {
+          running.startedAt = executionStartedAt;
+          running.cancel = () => {
+            cancelRequested = true;
+            executionHandle?.cancel();
+          };
+        }
+        if (cancelRequested) {
+          executionHandle.cancel();
+        }
+        const result = await executionHandle.result;
+        executionDurationMs = Date.now() - executionStartedAt;
+        await progressChain;
+        const sendStartedAt = Date.now();
+        await this.channel.sendMessage(message.conversationId, result.reply);
+        await this.finishProgress(
+          {
+            conversationId: message.conversationId,
+            isDirectMessage: message.isDirectMessage,
+            getProgressNoticeEventId: () => progressNoticeEventId,
+            setProgressNoticeEventId: (next) => {
+              progressNoticeEventId = next;
+            }
+          },
+          `\u5904\u7406\u5B8C\u6210\uFF08\u8017\u65F6 ${formatDurationMs(Date.now() - requestStartedAt)}\uFF09`
+        );
+        sendDurationMs = Date.now() - sendStartedAt;
+        this.stateStore.commitExecutionSuccess(sessionKey, message.eventId, result.sessionId);
+        this.metrics.record("success", queueWaitMs, executionDurationMs, sendDurationMs);
+        this.logger.info("Request completed", {
+          requestId,
+          sessionKey,
+          status: "success",
+          queueWaitMs,
+          executionDurationMs,
+          sendDurationMs,
+          totalDurationMs: Date.now() - receivedAt
+        });
+      } catch (error) {
+        const status = classifyExecutionOutcome(error);
+        executionDurationMs = Date.now() - requestStartedAt;
+        await progressChain;
+        await this.finishProgress(
+          {
+            conversationId: message.conversationId,
+            isDirectMessage: message.isDirectMessage,
+            getProgressNoticeEventId: () => progressNoticeEventId,
+            setProgressNoticeEventId: (next) => {
+              progressNoticeEventId = next;
+            }
+          },
+          buildFailureProgressSummary(status, requestStartedAt, error)
+        );
+        if (status !== "cancelled") {
+          try {
+            await this.channel.sendMessage(
+              message.conversationId,
+              `[CodeHarbor] Failed to process request: ${formatError(error)}`
+            );
+          } catch (sendError) {
+            this.logger.error("Failed to send error reply to Matrix", sendError);
+          }
+        }
+        this.stateStore.commitExecutionHandled(sessionKey, message.eventId);
+        this.metrics.record(status, queueWaitMs, executionDurationMs, sendDurationMs);
+        this.logger.error("Request failed", {
+          requestId,
+          sessionKey,
+          status,
+          queueWaitMs,
+          executionDurationMs,
+          totalDurationMs: Date.now() - receivedAt,
+          error: formatError(error)
+        });
+      } finally {
+        const running = this.runningExecutions.get(sessionKey);
+        if (running?.requestId === requestId) {
+          this.runningExecutions.delete(sessionKey);
+        }
+        rateDecision.release?.();
+        await stopTyping();
+        await cleanupAttachmentFiles(imagePaths);
+      }
+    });
+  }
+  routeMessage(message, sessionKey) {
+    const incomingRaw = message.text;
+    const incomingTrimmed = incomingRaw.trim();
+    if (!incomingTrimmed && message.attachments.length === 0) {
+      return { kind: "ignore" };
+    }
+    const groupPolicy = message.isDirectMessage ? null : this.resolveGroupPolicy(message.conversationId);
+    const prefixAllowed = message.isDirectMessage || Boolean(groupPolicy?.allowPrefix);
+    const prefixTriggered = prefixAllowed && this.commandPrefix.length > 0;
+    const prefixedText = prefixTriggered ? extractCommandText(incomingTrimmed, this.commandPrefix) : null;
+    const activeSession = message.isDirectMessage || groupPolicy?.allowActiveWindow ? this.stateStore.isSessionActive(sessionKey) : false;
+    const conversationalTrigger = message.isDirectMessage || Boolean(groupPolicy?.allowMention) && message.mentionsBot || Boolean(groupPolicy?.allowReply) && message.repliesToBot || activeSession;
+    if (!conversationalTrigger && prefixedText === null) {
+      return { kind: "ignore" };
+    }
+    let normalized = prefixedText ?? (this.cliCompat.preserveWhitespace ? incomingRaw : incomingTrimmed);
+    if (prefixedText === null && message.mentionsBot && !this.cliCompat.enabled) {
+      normalized = stripLeadingBotMention(normalized, this.matrixUserId);
+    }
+    const normalizedTrimmed = normalized.trim();
+    if (!normalizedTrimmed && message.attachments.length === 0) {
+      return { kind: "ignore" };
+    }
+    const command = parseControlCommand(normalizedTrimmed);
+    if (command) {
+      return { kind: "command", command };
+    }
+    if (!this.cliCompat.preserveWhitespace || prefixedText !== null) {
+      normalized = normalizedTrimmed;
+    }
+    return { kind: "execute", prompt: normalized };
+  }
+  async handleControlCommand(command, sessionKey, message, requestId) {
+    if (command === "stop") {
+      await this.handleStopCommand(sessionKey, message, requestId);
+      return;
+    }
+    if (command === "reset") {
+      this.stateStore.clearCodexSessionId(sessionKey);
+      this.stateStore.activateSession(sessionKey, this.sessionActiveWindowMs);
+      this.sessionRuntime.clearSession(sessionKey);
+      await this.channel.sendNotice(
+        message.conversationId,
+        "[CodeHarbor] \u4E0A\u4E0B\u6587\u5DF2\u91CD\u7F6E\u3002\u4F60\u53EF\u4EE5\u7EE7\u7EED\u76F4\u63A5\u53D1\u9001\u65B0\u9700\u6C42\u3002"
+      );
+      return;
+    }
+    const status = this.stateStore.getSessionStatus(sessionKey);
+    const scope = message.isDirectMessage ? "\u79C1\u804A\uFF08\u514D\u524D\u7F00\uFF09" : "\u7FA4\u804A\uFF08\u6309\u623F\u95F4\u89E6\u53D1\u7B56\u7565\uFF09";
+    const activeUntil = status.activeUntil ?? "\u672A\u6FC0\u6D3B";
+    const metrics = this.metrics.snapshot(this.runningExecutions.size);
+    const limiter = this.rateLimiter.snapshot();
+    const runtime = this.sessionRuntime.getRuntimeStats();
+    await this.channel.sendNotice(
+      message.conversationId,
+      `[CodeHarbor] \u5F53\u524D\u72B6\u6001
+- \u4F1A\u8BDD\u7C7B\u578B: ${scope}
+- \u6FC0\u6D3B\u4E2D: ${status.isActive ? "\u662F" : "\u5426"}
+- activeUntil: ${activeUntil}
+- \u5DF2\u7ED1\u5B9A Codex \u4F1A\u8BDD: ${status.hasCodexSession ? "\u662F" : "\u5426"}
+- \u8FD0\u884C\u4E2D\u4EFB\u52A1: ${metrics.activeExecutions}
+- \u6307\u6807: total=${metrics.total}, success=${metrics.success}, failed=${metrics.failed}, timeout=${metrics.timeout}, cancelled=${metrics.cancelled}, rate_limited=${metrics.rateLimited}
+- \u5E73\u5747\u8017\u65F6: queue=${metrics.avgQueueMs}ms, exec=${metrics.avgExecMs}ms, send=${metrics.avgSendMs}ms
+- \u9650\u6D41\u5E76\u53D1: global=${limiter.activeGlobal}, users=${limiter.activeUsers}, rooms=${limiter.activeRooms}
+- CLI runtime: workers=${runtime.workerCount}, running=${runtime.runningCount}, compat_mode=${this.cliCompat.enabled ? "on" : "off"}`
+    );
+  }
+  async handleStopCommand(sessionKey, message, requestId) {
+    this.stateStore.deactivateSession(sessionKey);
+    this.stateStore.clearCodexSessionId(sessionKey);
+    this.sessionRuntime.clearSession(sessionKey);
+    const running = this.runningExecutions.get(sessionKey);
+    if (running) {
+      this.sessionRuntime.cancelRunningExecution(sessionKey);
+      running.cancel();
+      await this.channel.sendNotice(
+        message.conversationId,
+        "[CodeHarbor] \u5DF2\u8BF7\u6C42\u505C\u6B62\u5F53\u524D\u4EFB\u52A1\uFF0C\u5E76\u5DF2\u6E05\u7406\u4F1A\u8BDD\u4E0A\u4E0B\u6587\u3002"
+      );
+      this.logger.info("Stop command cancelled running execution", {
+        requestId,
+        sessionKey,
+        targetRequestId: running.requestId,
+        runningForMs: Date.now() - running.startedAt
+      });
+      return;
+    }
+    await this.channel.sendNotice(
+      message.conversationId,
+      "[CodeHarbor] \u4F1A\u8BDD\u5DF2\u505C\u6B62\u3002\u540E\u7EED\u5728\u7FA4\u804A\u4E2D\u8BF7\u63D0\u53CA/\u56DE\u590D\u6211\uFF0C\u6216\u5728\u79C1\u804A\u76F4\u63A5\u53D1\u9001\u6D88\u606F\u3002"
+    );
+  }
+  startTypingHeartbeat(conversationId) {
+    let stopped = false;
+    const refreshIntervalMs = Math.max(1e3, Math.floor(this.typingTimeoutMs / 2));
+    const sendTyping = async (isTyping) => {
+      try {
+        await this.channel.setTyping(conversationId, isTyping, isTyping ? this.typingTimeoutMs : 0);
+      } catch (error) {
+        this.logger.debug("Failed to update typing state", { conversationId, isTyping, error });
+      }
+    };
+    void sendTyping(true);
+    const timer = setInterval(() => {
+      if (stopped) {
+        return;
+      }
+      void sendTyping(true);
+    }, refreshIntervalMs);
+    timer.unref?.();
+    return async () => {
+      if (stopped) {
+        return;
+      }
+      stopped = true;
+      clearInterval(timer);
+      await sendTyping(false);
+    };
+  }
+  async handleProgress(conversationId, isDirectMessage, progress, getLastProgressAt, setLastProgressAt, getLastProgressText, setLastProgressText, getProgressNoticeEventId, setProgressNoticeEventId) {
+    if (!this.progressUpdatesEnabled) {
+      return;
+    }
+    const progressText = mapProgressText(progress, this.cliCompat.enabled);
+    if (!progressText) {
+      return;
+    }
+    const now = Date.now();
+    if (now - getLastProgressAt() < this.progressMinIntervalMs && progress.stage !== "turn_started") {
+      return;
+    }
+    if (progressText === getLastProgressText()) {
+      return;
+    }
+    setLastProgressAt(now);
+    setLastProgressText(progressText);
+    await this.sendProgressUpdate(
+      {
+        conversationId,
+        isDirectMessage,
+        getProgressNoticeEventId,
+        setProgressNoticeEventId
+      },
+      `[CodeHarbor] ${progressText}`
+    );
+  }
+  async finishProgress(ctx, summary) {
+    if (!this.progressUpdatesEnabled) {
+      return;
+    }
+    await this.sendProgressUpdate(ctx, `[CodeHarbor] ${summary}`);
+  }
+  async sendProgressUpdate(ctx, text) {
+    try {
+      if (ctx.isDirectMessage) {
+        await this.channel.sendNotice(ctx.conversationId, text);
+        return;
+      }
+      const eventId = await this.channel.upsertProgressNotice(
+        ctx.conversationId,
+        text,
+        ctx.getProgressNoticeEventId()
+      );
+      ctx.setProgressNoticeEventId(eventId);
+    } catch (error) {
+      this.logger.debug("Failed to send progress update", {
+        conversationId: ctx.conversationId,
+        text,
+        error
+      });
+    }
+  }
+  resolveGroupPolicy(conversationId) {
+    const override = this.roomTriggerPolicies[conversationId] ?? {};
+    return {
+      allowMention: override.allowMention ?? this.defaultGroupTriggerPolicy.allowMention,
+      allowReply: override.allowReply ?? this.defaultGroupTriggerPolicy.allowReply,
+      allowActiveWindow: override.allowActiveWindow ?? this.defaultGroupTriggerPolicy.allowActiveWindow,
+      allowPrefix: override.allowPrefix ?? this.defaultGroupTriggerPolicy.allowPrefix
+    };
+  }
+  buildExecutionPrompt(prompt, message) {
+    if (message.attachments.length === 0) {
+      return prompt;
+    }
+    const attachmentSummary = message.attachments.map((attachment) => {
+      const size = attachment.sizeBytes === null ? "unknown" : `${attachment.sizeBytes}`;
+      const mime = attachment.mimeType ?? "unknown";
+      const source = attachment.mxcUrl ?? "none";
+      const local = attachment.localPath ?? "none";
+      return `- kind=${attachment.kind} name=${attachment.name} mime=${mime} size=${size} source=${source} local=${local}`;
+    }).join("\n");
+    const promptBody = prompt.trim() ? prompt : "(no text body)";
+    return `${promptBody}
+
+[attachments]
+${attachmentSummary}
+[/attachments]`;
+  }
+  async recordCliCompatPrompt(entry) {
+    if (!this.cliCompatRecorder) {
+      return;
+    }
+    try {
+      await this.cliCompatRecorder.append({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId: entry.requestId,
+        sessionKey: entry.sessionKey,
+        conversationId: entry.conversationId,
+        senderId: entry.senderId,
+        prompt: entry.prompt,
+        imageCount: entry.imageCount
+      });
+    } catch (error) {
+      this.logger.warn("Failed to record cli compat prompt", {
+        requestId: entry.requestId,
+        error
+      });
+    }
+  }
+  getLock(key) {
+    const now = Date.now();
+    if (now - this.lastLockPruneAt >= this.lockPruneIntervalMs) {
+      this.lastLockPruneAt = now;
+      this.pruneSessionLocks(now);
+    }
+    let entry = this.sessionLocks.get(key);
+    if (!entry) {
+      entry = {
+        mutex: new import_async_mutex.Mutex(),
+        lastUsedAt: now
+      };
+      this.sessionLocks.set(key, entry);
+    }
+    entry.lastUsedAt = now;
+    return entry.mutex;
+  }
+  pruneSessionLocks(now) {
+    const expireBefore = now - this.lockTtlMs;
+    for (const [sessionKey, entry] of this.sessionLocks.entries()) {
+      if (entry.lastUsedAt >= expireBefore) {
+        continue;
+      }
+      if (entry.mutex.isLocked()) {
+        continue;
+      }
+      this.sessionLocks.delete(sessionKey);
+    }
+  }
+};
+function buildSessionKey(message) {
+  return `${message.channel}:${message.conversationId}:${message.senderId}`;
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function collectImagePaths(message) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const attachment of message.attachments) {
+    if (attachment.kind !== "image" || !attachment.localPath) {
+      continue;
+    }
+    seen.add(attachment.localPath);
+  }
+  return [...seen];
+}
+async function cleanupAttachmentFiles(imagePaths) {
+  await Promise.all(
+    imagePaths.map(async (imagePath) => {
+      try {
+        await import_promises2.default.unlink(imagePath);
+      } catch {
+      }
+    })
+  );
+}
+function mapProgressText(progress, cliCompatMode) {
+  if (progress.stage === "turn_started") {
+    return "\u5F00\u59CB\u5904\u7406\u8BF7\u6C42\uFF0C\u6B63\u5728\u601D\u8003...";
+  }
+  if (progress.stage === "reasoning" && progress.message) {
+    const normalized = progress.message.replace(/\s+/g, " ").trim();
+    if (!normalized) {
+      return null;
+    }
+    const maxLen = 180;
+    return normalized.length > maxLen ? `\u601D\u8003\u4E2D: ${normalized.slice(0, maxLen)}...` : `\u601D\u8003\u4E2D: ${normalized}`;
+  }
+  if (progress.stage === "item_completed" && progress.message) {
+    return `\u9636\u6BB5\u5B8C\u6210: ${progress.message}`;
+  }
+  if (cliCompatMode && progress.stage === "stderr" && progress.message) {
+    const text = progress.message.length > 220 ? `${progress.message.slice(0, 220)}...` : progress.message;
+    return `stderr: ${text}`;
+  }
+  if (cliCompatMode && progress.stage === "raw_event") {
+    if (!progress.message) {
+      return null;
+    }
+    return `\u4E8B\u4EF6: ${progress.message}`;
+  }
+  return null;
+}
+function parseControlCommand(text) {
+  const command = text.split(/\s+/, 1)[0].toLowerCase();
+  if (command === "/status") {
+    return "status";
+  }
+  if (command === "/stop") {
+    return "stop";
+  }
+  if (command === "/reset") {
+    return "reset";
+  }
+  return null;
+}
+function stripLeadingBotMention(text, matrixUserId) {
+  if (!matrixUserId) {
+    return text;
+  }
+  const escapedUserId = escapeRegex(matrixUserId);
+  const mentionPattern = new RegExp(`^\\s*(?:<)?${escapedUserId}(?:>)?[\\s,:\uFF0C\uFF1A-]*`, "i");
+  return text.replace(mentionPattern, "").trim();
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function formatDurationMs(durationMs) {
+  if (durationMs < 1e3) {
+    return `${durationMs}ms`;
+  }
+  if (durationMs < 6e4) {
+    return `${(durationMs / 1e3).toFixed(1)}s`;
+  }
+  const minutes = Math.floor(durationMs / 6e4);
+  const seconds = (durationMs % 6e4 / 1e3).toFixed(1);
+  return `${minutes}m${seconds}s`;
+}
+function buildRateLimitNotice(decision) {
+  if (decision.reason === "user_requests_per_window" || decision.reason === "room_requests_per_window") {
+    const retrySec = Math.max(1, Math.ceil((decision.retryAfterMs ?? 1e3) / 1e3));
+    return `[CodeHarbor] \u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u5728 ${retrySec} \u79D2\u540E\u91CD\u8BD5\u3002`;
+  }
+  return "[CodeHarbor] \u5F53\u524D\u4EFB\u52A1\u5E76\u53D1\u8F83\u9AD8\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002";
+}
+function classifyExecutionOutcome(error) {
+  if (error instanceof CodexExecutionCancelledError) {
+    return "cancelled";
+  }
+  const message = formatError(error).toLowerCase();
+  if (message.includes("timed out")) {
+    return "timeout";
+  }
+  return "failed";
+}
+function buildFailureProgressSummary(status, startedAt, error) {
+  const elapsed = formatDurationMs(Date.now() - startedAt);
+  if (status === "cancelled") {
+    return `\u5904\u7406\u5DF2\u53D6\u6D88\uFF08\u8017\u65F6 ${elapsed}\uFF09`;
+  }
+  if (status === "timeout") {
+    return `\u5904\u7406\u8D85\u65F6\uFF08\u8017\u65F6 ${elapsed}\uFF09: ${formatError(error)}`;
+  }
+  return `\u5904\u7406\u5931\u8D25\uFF08\u8017\u65F6 ${elapsed}\uFF09: ${formatError(error)}`;
+}
+
+// src/store/state-store.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path3 = __toESM(require("path"));
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+var PRUNE_INTERVAL_MS = 5 * 60 * 1e3;
+var SQLITE_MODULE_ID = `node:${"sqlite"}`;
+function loadDatabaseSync() {
+  const sqliteModule = require(SQLITE_MODULE_ID);
+  if (!sqliteModule.DatabaseSync) {
+    throw new Error(`Failed to load ${SQLITE_MODULE_ID} DatabaseSync`);
+  }
+  return sqliteModule.DatabaseSync;
+}
+var DatabaseSync = loadDatabaseSync();
+var StateStore = class {
+  dbPath;
+  legacyJsonPath;
+  maxProcessedEventsPerSession;
+  maxSessionAgeMs;
+  maxSessions;
+  db;
+  lastPruneAt = 0;
+  constructor(dbPath, legacyJsonPath, maxProcessedEventsPerSession, maxSessionAgeDays, maxSessions) {
+    this.dbPath = dbPath;
+    this.legacyJsonPath = legacyJsonPath;
+    this.maxProcessedEventsPerSession = maxProcessedEventsPerSession;
+    this.maxSessionAgeMs = maxSessionAgeDays * ONE_DAY_MS;
+    this.maxSessions = maxSessions;
+    import_node_fs2.default.mkdirSync(import_node_path3.default.dirname(this.dbPath), { recursive: true });
+    this.db = new DatabaseSync(this.dbPath);
+    this.initializeSchema();
+    this.importLegacyStateIfNeeded();
+    if (this.pruneSessions()) {
+      this.touchDatabase();
+    }
+  }
+  getCodexSessionId(sessionKey) {
+    this.maybePruneExpiredSessions();
+    const row = this.db.prepare("SELECT codex_session_id FROM sessions WHERE session_key = ?1").get(sessionKey);
+    return row?.codex_session_id ?? null;
+  }
+  setCodexSessionId(sessionKey, codexSessionId) {
+    this.maybePruneExpiredSessions();
+    this.ensureSession(sessionKey);
+    this.db.prepare(
+      "UPDATE sessions SET codex_session_id = ?2, updated_at = ?3 WHERE session_key = ?1"
+    ).run(sessionKey, codexSessionId, Date.now());
+  }
+  clearCodexSessionId(sessionKey) {
+    this.maybePruneExpiredSessions();
+    this.ensureSession(sessionKey);
+    this.db.prepare("UPDATE sessions SET codex_session_id = NULL, updated_at = ?2 WHERE session_key = ?1").run(sessionKey, Date.now());
+  }
+  isSessionActive(sessionKey, now = Date.now()) {
+    this.maybePruneExpiredSessions();
+    const row = this.db.prepare("SELECT active_until FROM sessions WHERE session_key = ?1").get(sessionKey);
+    if (!row || row.active_until === null) {
+      return false;
+    }
+    return now <= row.active_until;
+  }
+  activateSession(sessionKey, activeWindowMs) {
+    this.maybePruneExpiredSessions();
+    this.ensureSession(sessionKey);
+    const now = Date.now();
+    this.db.prepare(
+      "UPDATE sessions SET active_until = ?2, updated_at = ?3 WHERE session_key = ?1"
+    ).run(sessionKey, now + Math.max(0, activeWindowMs), now);
+  }
+  deactivateSession(sessionKey) {
+    this.maybePruneExpiredSessions();
+    this.ensureSession(sessionKey);
+    this.db.prepare("UPDATE sessions SET active_until = NULL, updated_at = ?2 WHERE session_key = ?1").run(sessionKey, Date.now());
+  }
+  getSessionStatus(sessionKey) {
+    this.maybePruneExpiredSessions();
+    const row = this.db.prepare("SELECT codex_session_id, active_until FROM sessions WHERE session_key = ?1").get(sessionKey);
+    if (!row) {
+      return {
+        hasCodexSession: false,
+        activeUntil: null,
+        isActive: false
+      };
+    }
+    const activeUntilIso = row.active_until === null ? null : new Date(row.active_until).toISOString();
+    return {
+      hasCodexSession: Boolean(row.codex_session_id),
+      activeUntil: activeUntilIso,
+      isActive: row.active_until !== null ? Date.now() <= row.active_until : false
+    };
+  }
+  hasProcessedEvent(sessionKey, eventId) {
+    this.maybePruneExpiredSessions();
+    const row = this.db.prepare("SELECT 1 FROM processed_events WHERE session_key = ?1 AND event_id = ?2").get(sessionKey, eventId);
+    return Boolean(row);
+  }
+  markEventProcessed(sessionKey, eventId) {
+    this.maybePruneExpiredSessions();
+    this.ensureSession(sessionKey);
+    this.insertProcessedEventAndTrim(sessionKey, eventId, Date.now());
+  }
+  commitExecutionSuccess(sessionKey, eventId, codexSessionId) {
+    this.maybePruneExpiredSessions();
+    const now = Date.now();
+    this.ensureSession(sessionKey);
+    this.db.exec("BEGIN");
+    try {
+      this.db.prepare("UPDATE sessions SET codex_session_id = ?2, updated_at = ?3 WHERE session_key = ?1").run(sessionKey, codexSessionId, now);
+      this.insertProcessedEventAndTrim(sessionKey, eventId, now);
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  commitExecutionHandled(sessionKey, eventId) {
+    this.maybePruneExpiredSessions();
+    this.ensureSession(sessionKey);
+    this.db.exec("BEGIN");
+    try {
+      this.insertProcessedEventAndTrim(sessionKey, eventId, Date.now());
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  async flush() {
+    this.touchDatabase();
+  }
+  insertProcessedEventAndTrim(sessionKey, eventId, now) {
+    this.db.prepare("INSERT OR IGNORE INTO processed_events (session_key, event_id, created_at) VALUES (?1, ?2, ?3)").run(sessionKey, eventId, now);
+    if (this.maxProcessedEventsPerSession > 0) {
+      this.db.prepare(
+        `DELETE FROM processed_events
+           WHERE rowid IN (
+             SELECT rowid
+             FROM processed_events
+             WHERE session_key = ?1
+             ORDER BY rowid DESC
+             LIMIT -1 OFFSET ?2
+           )`
+      ).run(sessionKey, this.maxProcessedEventsPerSession);
+    }
+    this.db.prepare("UPDATE sessions SET updated_at = ?2 WHERE session_key = ?1").run(sessionKey, now);
+  }
+  ensureSession(sessionKey) {
+    this.db.prepare(
+      "INSERT INTO sessions (session_key, codex_session_id, active_until, updated_at) VALUES (?1, NULL, NULL, ?2) ON CONFLICT(session_key) DO NOTHING"
+    ).run(sessionKey, Date.now());
+  }
+  initializeSchema() {
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA foreign_keys = ON");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        session_key TEXT PRIMARY KEY,
+        codex_session_id TEXT,
+        active_until INTEGER,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS processed_events (
+        session_key TEXT NOT NULL,
+        event_id TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY (session_key, event_id),
+        FOREIGN KEY (session_key) REFERENCES sessions(session_key) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_sessions_updated_at ON sessions(updated_at);
+      CREATE INDEX IF NOT EXISTS idx_events_created_at ON processed_events(created_at);
+    `);
+  }
+  importLegacyStateIfNeeded() {
+    if (!this.legacyJsonPath || !import_node_fs2.default.existsSync(this.legacyJsonPath)) {
+      return;
+    }
+    const countRow = this.db.prepare("SELECT COUNT(*) AS count FROM sessions").get();
+    if ((countRow?.count ?? 0) > 0) {
+      return;
+    }
+    const legacy = loadLegacyState(this.legacyJsonPath);
+    if (!legacy) {
+      return;
+    }
+    const insertSession = this.db.prepare(
+      "INSERT OR REPLACE INTO sessions (session_key, codex_session_id, active_until, updated_at) VALUES (?1, ?2, ?3, ?4)"
+    );
+    const insertEvent = this.db.prepare(
+      "INSERT OR IGNORE INTO processed_events (session_key, event_id, created_at) VALUES (?1, ?2, ?3)"
+    );
+    this.db.exec("BEGIN");
+    try {
+      for (const [sessionKey, session] of Object.entries(legacy.sessions)) {
+        const updatedAt = parseUpdatedAt(session.updatedAt);
+        const activeUntil = parseOptionalTimestamp(session.activeUntil);
+        insertSession.run(sessionKey, session.codexSessionId, activeUntil, updatedAt);
+        let eventTs = updatedAt;
+        for (const eventId of session.processedEventIds) {
+          eventTs += 1;
+          insertEvent.run(sessionKey, eventId, eventTs);
+        }
+      }
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  maybePruneExpiredSessions() {
+    const now = Date.now();
+    if (now - this.lastPruneAt < PRUNE_INTERVAL_MS) {
+      return;
+    }
+    this.lastPruneAt = now;
+    if (this.pruneSessions(now)) {
+      this.touchDatabase();
+    }
+  }
+  pruneSessions(now = Date.now()) {
+    let changed = false;
+    if (this.pruneExpiredSessions(now)) {
+      changed = true;
+    }
+    if (this.pruneExcessSessions()) {
+      changed = true;
+    }
+    return changed;
+  }
+  pruneExpiredSessions(now) {
+    if (this.maxSessionAgeMs <= 0) {
+      return false;
+    }
+    const result = this.db.prepare("DELETE FROM sessions WHERE updated_at < ?1").run(now - this.maxSessionAgeMs);
+    return (result.changes ?? 0) > 0;
+  }
+  pruneExcessSessions() {
+    if (this.maxSessions <= 0) {
+      return false;
+    }
+    const row = this.db.prepare("SELECT COUNT(*) AS count FROM sessions").get();
+    const count = row?.count ?? 0;
+    if (count <= this.maxSessions) {
+      return false;
+    }
+    const removeCount = count - this.maxSessions;
+    const result = this.db.prepare(
+      "DELETE FROM sessions WHERE session_key IN (SELECT session_key FROM sessions ORDER BY updated_at ASC LIMIT ?1)"
+    ).run(removeCount);
+    return (result.changes ?? 0) > 0;
+  }
+  touchDatabase() {
+    this.db.exec("PRAGMA wal_checkpoint(PASSIVE)");
+  }
+};
+function loadLegacyState(filePath) {
+  try {
+    const raw = import_node_fs2.default.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.sessions || typeof parsed.sessions !== "object") {
+      return null;
+    }
+    normalizeLegacyState(parsed);
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function parseUpdatedAt(updatedAt) {
+  const timestamp = Date.parse(updatedAt);
+  return Number.isFinite(timestamp) ? timestamp : Date.now();
+}
+function parseOptionalTimestamp(value) {
+  if (!value) {
+    return null;
+  }
+  const ts = Date.parse(value);
+  return Number.isFinite(ts) ? ts : null;
+}
+function normalizeLegacyState(state) {
+  for (const session of Object.values(state.sessions)) {
+    if (!Array.isArray(session.processedEventIds)) {
+      session.processedEventIds = [];
+    }
+    if (typeof session.codexSessionId !== "string" && session.codexSessionId !== null) {
+      session.codexSessionId = null;
+    }
+    if (typeof session.updatedAt !== "string") {
+      session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    if (typeof session.activeUntil !== "string" && session.activeUntil !== null) {
+      session.activeUntil = null;
+    }
+  }
+}
+
+// src/app.ts
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process2.execFile);
+var CodeHarborApp = class {
+  config;
+  logger;
+  stateStore;
+  channel;
+  orchestrator;
+  constructor(config) {
+    this.config = config;
+    this.logger = new Logger(config.logLevel);
+    this.stateStore = new StateStore(
+      config.stateDbPath,
+      config.legacyStateJsonPath,
+      config.maxProcessedEventsPerSession,
+      config.maxSessionAgeDays,
+      config.maxSessions
+    );
+    const executor = new CodexExecutor({
+      bin: config.codexBin,
+      model: config.codexModel,
+      workdir: config.codexWorkdir,
+      dangerousBypass: config.codexDangerousBypass,
+      timeoutMs: config.codexExecTimeoutMs,
+      sandboxMode: config.codexSandboxMode,
+      approvalPolicy: config.codexApprovalPolicy,
+      extraArgs: config.codexExtraArgs,
+      extraEnv: config.codexExtraEnv
+    });
+    this.channel = new MatrixChannel(config, this.logger);
+    this.orchestrator = new Orchestrator(this.channel, executor, this.stateStore, this.logger, {
+      progressUpdatesEnabled: config.matrixProgressUpdates,
+      progressMinIntervalMs: config.matrixProgressMinIntervalMs,
+      typingTimeoutMs: config.matrixTypingTimeoutMs,
+      commandPrefix: config.matrixCommandPrefix,
+      matrixUserId: config.matrixUserId,
+      sessionActiveWindowMinutes: config.sessionActiveWindowMinutes,
+      defaultGroupTriggerPolicy: config.defaultGroupTriggerPolicy,
+      roomTriggerPolicies: config.roomTriggerPolicies,
+      rateLimiterOptions: config.rateLimiter,
+      cliCompat: config.cliCompat
+    });
+  }
+  async start() {
+    this.logger.info("CodeHarbor starting", {
+      matrixHomeserver: this.config.matrixHomeserver,
+      workdir: this.config.codexWorkdir,
+      prefix: this.config.matrixCommandPrefix || "<none>"
+    });
+    await this.channel.start(this.orchestrator.handleMessage.bind(this.orchestrator));
+    this.logger.info("CodeHarbor is running.");
+  }
+  async stop() {
+    this.logger.info("CodeHarbor stopping.");
+    try {
+      await this.channel.stop();
+    } finally {
+      await this.stateStore.flush();
+    }
+  }
+};
+async function runDoctor(config) {
+  const logger = new Logger(config.logLevel);
+  logger.info("Doctor check started");
+  try {
+    const { stdout } = await execFileAsync(config.codexBin, ["--version"]);
+    logger.info("codex available", { version: stdout.trim() });
+  } catch (error) {
+    logger.error("codex unavailable", error);
+    throw error;
+  }
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), config.doctorHttpTimeoutMs);
+    timer.unref?.();
+    const response = await fetch(`${config.matrixHomeserver}/_matrix/client/versions`, {
+      signal: controller.signal
+    }).finally(() => {
+      clearTimeout(timer);
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const body = await response.json();
+    logger.info("matrix reachable", { versions: body.versions ?? [] });
+  } catch (error) {
+    logger.error("matrix unreachable", error);
+    throw error;
+  }
+  logger.info("Doctor check passed");
+}
+
+// src/config.ts
+var import_node_fs3 = __toESM(require("fs"));
+var import_node_path4 = __toESM(require("path"));
+var import_dotenv = __toESM(require("dotenv"));
+var import_zod = require("zod");
+import_dotenv.default.config();
+var configSchema = import_zod.z.object({
+  MATRIX_HOMESERVER: import_zod.z.string().url(),
+  MATRIX_USER_ID: import_zod.z.string().min(1),
+  MATRIX_ACCESS_TOKEN: import_zod.z.string().min(1),
+  MATRIX_COMMAND_PREFIX: import_zod.z.string().default("!code"),
+  CODEX_BIN: import_zod.z.string().default("codex"),
+  CODEX_MODEL: import_zod.z.string().optional(),
+  CODEX_WORKDIR: import_zod.z.string().default(process.cwd()),
+  CODEX_DANGEROUS_BYPASS: import_zod.z.string().default("false").transform((v) => v.toLowerCase() === "true"),
+  CODEX_EXEC_TIMEOUT_MS: import_zod.z.string().default("600000").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().positive()),
+  CODEX_SANDBOX_MODE: import_zod.z.string().optional(),
+  CODEX_APPROVAL_POLICY: import_zod.z.string().optional(),
+  CODEX_EXTRA_ARGS: import_zod.z.string().default(""),
+  CODEX_EXTRA_ENV_JSON: import_zod.z.string().default(""),
+  STATE_DB_PATH: import_zod.z.string().default("data/state.db"),
+  STATE_PATH: import_zod.z.string().default("data/state.json"),
+  MAX_PROCESSED_EVENTS_PER_SESSION: import_zod.z.string().default("200").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().positive()),
+  MAX_SESSION_AGE_DAYS: import_zod.z.string().default("30").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().positive()),
+  MAX_SESSIONS: import_zod.z.string().default("5000").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().positive()),
+  REPLY_CHUNK_SIZE: import_zod.z.string().default("3500").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().positive()),
+  MATRIX_PROGRESS_UPDATES: import_zod.z.string().default("true").transform((v) => v.toLowerCase() === "true"),
+  MATRIX_PROGRESS_MIN_INTERVAL_MS: import_zod.z.string().default("2500").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().positive()),
+  MATRIX_TYPING_TIMEOUT_MS: import_zod.z.string().default("10000").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().positive()),
+  SESSION_ACTIVE_WINDOW_MINUTES: import_zod.z.string().default("20").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().positive()),
+  GROUP_TRIGGER_ALLOW_MENTION: import_zod.z.string().default("true").transform((v) => v.toLowerCase() === "true"),
+  GROUP_TRIGGER_ALLOW_REPLY: import_zod.z.string().default("true").transform((v) => v.toLowerCase() === "true"),
+  GROUP_TRIGGER_ALLOW_ACTIVE_WINDOW: import_zod.z.string().default("true").transform((v) => v.toLowerCase() === "true"),
+  GROUP_TRIGGER_ALLOW_PREFIX: import_zod.z.string().default("true").transform((v) => v.toLowerCase() === "true"),
+  ROOM_TRIGGER_POLICY_JSON: import_zod.z.string().default(""),
+  RATE_LIMIT_WINDOW_SECONDS: import_zod.z.string().default("60").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().positive()),
+  RATE_LIMIT_MAX_REQUESTS_PER_USER: import_zod.z.string().default("20").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().nonnegative()),
+  RATE_LIMIT_MAX_REQUESTS_PER_ROOM: import_zod.z.string().default("120").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().nonnegative()),
+  RATE_LIMIT_MAX_CONCURRENT_GLOBAL: import_zod.z.string().default("8").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().nonnegative()),
+  RATE_LIMIT_MAX_CONCURRENT_PER_USER: import_zod.z.string().default("1").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().nonnegative()),
+  RATE_LIMIT_MAX_CONCURRENT_PER_ROOM: import_zod.z.string().default("4").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().nonnegative()),
+  CLI_COMPAT_MODE: import_zod.z.string().default("false").transform((v) => v.toLowerCase() === "true"),
+  CLI_COMPAT_PASSTHROUGH_EVENTS: import_zod.z.string().default("true").transform((v) => v.toLowerCase() === "true"),
+  CLI_COMPAT_PRESERVE_WHITESPACE: import_zod.z.string().default("true").transform((v) => v.toLowerCase() === "true"),
+  CLI_COMPAT_DISABLE_REPLY_CHUNK_SPLIT: import_zod.z.string().default("false").transform((v) => v.toLowerCase() === "true"),
+  CLI_COMPAT_PROGRESS_THROTTLE_MS: import_zod.z.string().default("300").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().nonnegative()),
+  CLI_COMPAT_FETCH_MEDIA: import_zod.z.string().default("true").transform((v) => v.toLowerCase() === "true"),
+  CLI_COMPAT_RECORD_PATH: import_zod.z.string().default(""),
+  DOCTOR_HTTP_TIMEOUT_MS: import_zod.z.string().default("10000").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().positive()),
+  LOG_LEVEL: import_zod.z.enum(["debug", "info", "warn", "error"]).default("info")
+}).transform((v) => ({
+  matrixHomeserver: v.MATRIX_HOMESERVER,
+  matrixUserId: v.MATRIX_USER_ID,
+  matrixAccessToken: v.MATRIX_ACCESS_TOKEN,
+  matrixCommandPrefix: v.MATRIX_COMMAND_PREFIX,
+  codexBin: v.CODEX_BIN,
+  codexModel: v.CODEX_MODEL?.trim() || null,
+  codexWorkdir: import_node_path4.default.resolve(v.CODEX_WORKDIR),
+  codexDangerousBypass: v.CODEX_DANGEROUS_BYPASS,
+  codexExecTimeoutMs: v.CODEX_EXEC_TIMEOUT_MS,
+  codexSandboxMode: v.CODEX_SANDBOX_MODE?.trim() || null,
+  codexApprovalPolicy: v.CODEX_APPROVAL_POLICY?.trim() || null,
+  codexExtraArgs: parseExtraArgs(v.CODEX_EXTRA_ARGS),
+  codexExtraEnv: parseExtraEnv(v.CODEX_EXTRA_ENV_JSON),
+  stateDbPath: import_node_path4.default.resolve(v.STATE_DB_PATH),
+  legacyStateJsonPath: v.STATE_PATH.trim() ? import_node_path4.default.resolve(v.STATE_PATH) : null,
+  maxProcessedEventsPerSession: v.MAX_PROCESSED_EVENTS_PER_SESSION,
+  maxSessionAgeDays: v.MAX_SESSION_AGE_DAYS,
+  maxSessions: v.MAX_SESSIONS,
+  replyChunkSize: v.REPLY_CHUNK_SIZE,
+  matrixProgressUpdates: v.MATRIX_PROGRESS_UPDATES,
+  matrixProgressMinIntervalMs: v.MATRIX_PROGRESS_MIN_INTERVAL_MS,
+  matrixTypingTimeoutMs: v.MATRIX_TYPING_TIMEOUT_MS,
+  sessionActiveWindowMinutes: v.SESSION_ACTIVE_WINDOW_MINUTES,
+  defaultGroupTriggerPolicy: {
+    allowMention: v.GROUP_TRIGGER_ALLOW_MENTION,
+    allowReply: v.GROUP_TRIGGER_ALLOW_REPLY,
+    allowActiveWindow: v.GROUP_TRIGGER_ALLOW_ACTIVE_WINDOW,
+    allowPrefix: v.GROUP_TRIGGER_ALLOW_PREFIX
+  },
+  roomTriggerPolicies: parseRoomTriggerPolicyOverrides(v.ROOM_TRIGGER_POLICY_JSON),
+  rateLimiter: {
+    windowMs: v.RATE_LIMIT_WINDOW_SECONDS * 1e3,
+    maxRequestsPerUser: v.RATE_LIMIT_MAX_REQUESTS_PER_USER,
+    maxRequestsPerRoom: v.RATE_LIMIT_MAX_REQUESTS_PER_ROOM,
+    maxConcurrentGlobal: v.RATE_LIMIT_MAX_CONCURRENT_GLOBAL,
+    maxConcurrentPerUser: v.RATE_LIMIT_MAX_CONCURRENT_PER_USER,
+    maxConcurrentPerRoom: v.RATE_LIMIT_MAX_CONCURRENT_PER_ROOM
+  },
+  cliCompat: {
+    enabled: v.CLI_COMPAT_MODE,
+    passThroughEvents: v.CLI_COMPAT_PASSTHROUGH_EVENTS,
+    preserveWhitespace: v.CLI_COMPAT_PRESERVE_WHITESPACE,
+    disableReplyChunkSplit: v.CLI_COMPAT_DISABLE_REPLY_CHUNK_SPLIT,
+    progressThrottleMs: v.CLI_COMPAT_PROGRESS_THROTTLE_MS,
+    fetchMedia: v.CLI_COMPAT_FETCH_MEDIA,
+    recordPath: v.CLI_COMPAT_RECORD_PATH.trim() ? import_node_path4.default.resolve(v.CLI_COMPAT_RECORD_PATH) : null
+  },
+  doctorHttpTimeoutMs: v.DOCTOR_HTTP_TIMEOUT_MS,
+  logLevel: v.LOG_LEVEL
+}));
+function loadConfig(env = process.env) {
+  const parsed = configSchema.safeParse(env);
+  if (!parsed.success) {
+    const message = parsed.error.issues.map((issue) => `${issue.path.join(".") || "config"}: ${issue.message}`).join("; ");
+    throw new Error(`Invalid configuration: ${message}`);
+  }
+  import_node_fs3.default.mkdirSync(import_node_path4.default.dirname(parsed.data.stateDbPath), { recursive: true });
+  if (parsed.data.legacyStateJsonPath) {
+    import_node_fs3.default.mkdirSync(import_node_path4.default.dirname(parsed.data.legacyStateJsonPath), { recursive: true });
+  }
+  return parsed.data;
+}
+function parseRoomTriggerPolicyOverrides(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    throw new Error("ROOM_TRIGGER_POLICY_JSON must be valid JSON.");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("ROOM_TRIGGER_POLICY_JSON must be an object keyed by room id.");
+  }
+  const output = {};
+  for (const [roomId, value] of Object.entries(parsed)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error(`ROOM_TRIGGER_POLICY_JSON[${roomId}] must be an object.`);
+    }
+    const item = value;
+    const override = {};
+    for (const key of ["allowMention", "allowReply", "allowActiveWindow", "allowPrefix"]) {
+      if (item[key] === void 0) {
+        continue;
+      }
+      if (typeof item[key] !== "boolean") {
+        throw new Error(`ROOM_TRIGGER_POLICY_JSON[${roomId}].${key} must be boolean.`);
+      }
+      override[key] = item[key];
+    }
+    output[roomId] = override;
+  }
+  return output;
+}
+function parseExtraArgs(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return [];
+  }
+  return trimmed.split(/\s+/).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function parseExtraEnv(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    throw new Error("CODEX_EXTRA_ENV_JSON must be valid JSON object.");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("CODEX_EXTRA_ENV_JSON must be a key/value object.");
+  }
+  const output = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (typeof value !== "string") {
+      throw new Error(`CODEX_EXTRA_ENV_JSON[${key}] must be string.`);
+    }
+    output[key] = value;
+  }
+  return output;
+}
+
+// src/cli.ts
+var program = new import_commander.Command();
+program.name("codeharbor").description("Instant-messaging bridge for Codex CLI sessions").version("0.1.0");
+program.command("start").description("Start CodeHarbor service").action(async () => {
+  const config = loadConfig();
+  const app = new CodeHarborApp(config);
+  await app.start();
+  const stop = async () => {
+    await app.stop();
+    process.exit(0);
+  };
+  process.once("SIGINT", () => {
+    void stop();
+  });
+  process.once("SIGTERM", () => {
+    void stop();
+  });
+});
+program.command("doctor").description("Check codex and matrix connectivity").action(async () => {
+  const config = loadConfig();
+  await runDoctor(config);
+});
+if (process.argv.length <= 2) {
+  process.argv.push("start");
+}
+void program.parseAsync(process.argv);