codeksei 0.1.0

package/src/core/system-message-dispatcher.js

@@ -0,0 +1,68 @@
+class SystemMessageDispatcher {
+  constructor({ queueStore, config, accountId }) {
+    this.queueStore = queueStore;
+    this.config = config;
+    this.accountId = accountId;
+  }
+
+  hasPending() {
+    return this.queueStore.hasPendingForAccount(this.accountId);
+  }
+
+  drainPending() {
+    return this.queueStore.drainForAccount(this.accountId);
+  }
+
+  requeue(message) {
+    return this.queueStore.enqueue(message);
+  }
+
+  resolveWorkspaceRoot(message) {
+    return normalizeText(message?.workspaceRoot) || normalizeText(this.config.workspaceRoot);
+  }
+
+  buildPreparedMessage(message, contextToken = "") {
+    return {
+      provider: "system",
+      workspaceId: this.config.workspaceId,
+      accountId: this.accountId,
+      chatId: message.senderId,
+      threadKey: `system:${message.senderId}`,
+      senderId: message.senderId,
+      messageId: message.id,
+      text: buildSystemInboundText(message?.text, this.config),
+      attachments: [],
+      command: "message",
+      contextToken,
+      receivedAt: normalizeIsoTime(message?.createdAt) || new Date().toISOString(),
+      workspaceRoot: this.resolveWorkspaceRoot(message),
+    };
+  }
+}
+
+function buildSystemInboundText(text, config = {}) {
+  const body = normalizeText(text);
+  const userName = normalizeText(config?.userName) || "用户";
+  if (!body) {
+    return `System trigger.\nThis message is not visible to ${userName}.`;
+  }
+  return `System trigger.\nThis message is not visible to ${userName}.\n${body}`;
+}
+
+function normalizeIsoTime(value) {
+  const normalized = normalizeText(value);
+  if (!normalized) {
+    return "";
+  }
+  const parsed = Date.parse(normalized);
+  if (!Number.isFinite(parsed)) {
+    return "";
+  }
+  return new Date(parsed).toISOString();
+}
+
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+module.exports = { SystemMessageDispatcher };

package/src/core/system-message-queue-store.js

@@ -0,0 +1,128 @@
+const fs = require("fs");
+const path = require("path");
+
+class SystemMessageQueueStore {
+  constructor({ filePath }) {
+    this.filePath = filePath;
+    this.state = { messages: [] };
+    this.ensureParentDirectory();
+    this.load();
+  }
+
+  ensureParentDirectory() {
+    fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+  }
+
+  load() {
+    try {
+      const raw = fs.readFileSync(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      const messages = Array.isArray(parsed?.messages) ? parsed.messages : [];
+      this.state = {
+        messages: messages
+          .map(normalizeSystemMessage)
+          .filter(Boolean)
+          .sort(compareSystemMessages),
+      };
+    } catch {
+      this.state = { messages: [] };
+    }
+  }
+
+  save() {
+    fs.writeFileSync(this.filePath, JSON.stringify(this.state, null, 2));
+  }
+
+  enqueue(message) {
+    this.load();
+    const normalized = normalizeSystemMessage(message);
+    if (!normalized) {
+      throw new Error("invalid system message");
+    }
+    this.state.messages.push(normalized);
+    this.state.messages.sort(compareSystemMessages);
+    this.save();
+    return normalized;
+  }
+
+  drainForAccount(accountId) {
+    this.load();
+    const normalizedAccountId = normalizeText(accountId);
+    const drained = [];
+    const pending = [];
+
+    for (const message of this.state.messages) {
+      if (message.accountId === normalizedAccountId) {
+        drained.push(message);
+      } else {
+        pending.push(message);
+      }
+    }
+
+    if (drained.length) {
+      this.state.messages = pending;
+      this.save();
+    }
+
+    return drained;
+  }
+
+  hasPendingForAccount(accountId) {
+    this.load();
+    const normalizedAccountId = normalizeText(accountId);
+    return this.state.messages.some((message) => message.accountId === normalizedAccountId);
+  }
+}
+
+function normalizeSystemMessage(message) {
+  if (!message || typeof message !== "object") {
+    return null;
+  }
+
+  const id = normalizeText(message.id);
+  const accountId = normalizeText(message.accountId);
+  const senderId = normalizeText(message.senderId);
+  const workspaceRoot = normalizeText(message.workspaceRoot);
+  const text = normalizeText(message.text);
+  const createdAt = normalizeIsoTime(message.createdAt);
+
+  if (!id || !accountId || !senderId || !workspaceRoot || !text) {
+    return null;
+  }
+
+  return {
+    id,
+    accountId,
+    senderId,
+    workspaceRoot,
+    text,
+    createdAt: createdAt || new Date().toISOString(),
+  };
+}
+
+function normalizeIsoTime(value) {
+  const normalized = normalizeText(value);
+  if (!normalized) {
+    return "";
+  }
+  const parsed = Date.parse(normalized);
+  if (!Number.isFinite(parsed)) {
+    return "";
+  }
+  return new Date(parsed).toISOString();
+}
+
+function compareSystemMessages(left, right) {
+  const leftTime = Date.parse(left?.createdAt || "") || 0;
+  const rightTime = Date.parse(right?.createdAt || "") || 0;
+  if (leftTime !== rightTime) {
+    return leftTime - rightTime;
+  }
+  return String(left?.id || "").localeCompare(String(right?.id || ""));
+}
+
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+module.exports = { SystemMessageQueueStore };

package/src/core/thread-state-store.js

@@ -0,0 +1,135 @@
+class ThreadStateStore {
+  constructor() {
+    this.stateByThreadId = new Map();
+    this.latestUsage = null;
+  }
+
+  applyRuntimeEvent(event) {
+    if (event?.type === "runtime.usage.updated") {
+      this.latestUsage = {
+        ...event.payload,
+        updatedAt: new Date().toISOString(),
+      };
+      return;
+    }
+    if (!event || !event.payload || !event.payload.threadId) {
+      return;
+    }
+
+    const threadId = event.payload.threadId;
+    const current = this.stateByThreadId.get(threadId) || createEmptyThreadState(threadId);
+    const next = {
+      ...current,
+      updatedAt: new Date().toISOString(),
+    };
+
+    switch (event.type) {
+      case "runtime.turn.started":
+        next.status = "running";
+        next.turnId = event.payload.turnId || next.turnId;
+        next.lastError = "";
+        break;
+      case "runtime.reply.delta":
+        next.status = "running";
+        next.turnId = event.payload.turnId || next.turnId;
+        next.lastReplyText = event.payload.text || next.lastReplyText;
+        break;
+      case "runtime.reply.completed":
+        next.status = "running";
+        next.turnId = event.payload.turnId || next.turnId;
+        next.lastReplyText = event.payload.text || next.lastReplyText;
+        break;
+      case "runtime.approval.requested":
+        next.status = "waiting_approval";
+        next.pendingApproval = {
+          requestId: event.payload.requestId ?? null,
+          reason: event.payload.reason || "",
+          command: event.payload.command || "",
+          commandTokens: Array.isArray(event.payload.commandTokens) ? event.payload.commandTokens : [],
+        };
+        break;
+      case "runtime.turn.completed":
+        next.status = "idle";
+        next.turnId = event.payload.turnId || next.turnId;
+        next.pendingApproval = null;
+        break;
+      case "runtime.turn.failed":
+        next.status = "failed";
+        next.turnId = event.payload.turnId || next.turnId;
+        next.lastError = event.payload.text || "执行失败";
+        next.pendingApproval = null;
+        break;
+      default:
+        break;
+    }
+
+    this.stateByThreadId.set(threadId, next);
+  }
+
+  getThreadState(threadId) {
+    return this.stateByThreadId.get(threadId) || null;
+  }
+
+  resolveApproval(threadId, status = "running") {
+    const current = this.stateByThreadId.get(threadId);
+    if (!current) {
+      return null;
+    }
+    const next = {
+      ...current,
+      status,
+      pendingApproval: null,
+      updatedAt: new Date().toISOString(),
+    };
+    this.stateByThreadId.set(threadId, next);
+    return next;
+  }
+
+  markTurnFailed(threadId, turnId, message = "执行失败") {
+    const normalizedThreadId = normalizeText(threadId);
+    const normalizedTurnId = normalizeText(turnId);
+    if (!normalizedThreadId) {
+      return null;
+    }
+    const current = this.stateByThreadId.get(normalizedThreadId) || createEmptyThreadState(normalizedThreadId);
+    if (normalizedTurnId && normalizeText(current.turnId) && normalizeText(current.turnId) !== normalizedTurnId) {
+      return current;
+    }
+    const next = {
+      ...current,
+      status: "failed",
+      turnId: normalizedTurnId || current.turnId,
+      lastError: normalizeText(message) || "执行失败",
+      pendingApproval: null,
+      updatedAt: new Date().toISOString(),
+    };
+    this.stateByThreadId.set(normalizedThreadId, next);
+    return next;
+  }
+
+  snapshot() {
+    return Array.from(this.stateByThreadId.values()).map((entry) => ({ ...entry }));
+  }
+
+  getLatestUsage() {
+    return this.latestUsage ? { ...this.latestUsage } : null;
+  }
+}
+
+function createEmptyThreadState(threadId) {
+  return {
+    threadId,
+    turnId: "",
+    status: "idle",
+    lastReplyText: "",
+    lastError: "",
+    pendingApproval: null,
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+module.exports = { ThreadStateStore };

package/src/core/timeline-screenshot-queue-store.js

@@ -0,0 +1,134 @@
+const fs = require("fs");
+const path = require("path");
+
+class TimelineScreenshotQueueStore {
+  constructor({ filePath }) {
+    this.filePath = filePath;
+    this.state = { jobs: [] };
+    this.ensureParentDirectory();
+    this.load();
+  }
+
+  ensureParentDirectory() {
+    fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+  }
+
+  load() {
+    try {
+      const raw = fs.readFileSync(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      const jobs = Array.isArray(parsed?.jobs) ? parsed.jobs : [];
+      this.state = {
+        jobs: jobs
+          .map(normalizeTimelineScreenshotJob)
+          .filter(Boolean)
+          .sort(compareTimelineScreenshotJobs),
+      };
+    } catch {
+      this.state = { jobs: [] };
+    }
+  }
+
+  save() {
+    fs.writeFileSync(this.filePath, JSON.stringify(this.state, null, 2));
+  }
+
+  enqueue(job) {
+    this.load();
+    const normalized = normalizeTimelineScreenshotJob(job);
+    if (!normalized) {
+      throw new Error("invalid timeline screenshot job");
+    }
+    this.state.jobs.push(normalized);
+    this.state.jobs.sort(compareTimelineScreenshotJobs);
+    this.save();
+    return normalized;
+  }
+
+  drainForAccount(accountId) {
+    this.load();
+    const normalizedAccountId = normalizeText(accountId);
+    const drained = [];
+    const pending = [];
+
+    for (const job of this.state.jobs) {
+      if (job.accountId === normalizedAccountId) {
+        drained.push(job);
+      } else {
+        pending.push(job);
+      }
+    }
+
+    if (drained.length) {
+      this.state.jobs = pending;
+      this.save();
+    }
+
+    return drained;
+  }
+
+  hasPendingForAccount(accountId) {
+    this.load();
+    const normalizedAccountId = normalizeText(accountId);
+    return this.state.jobs.some((job) => job.accountId === normalizedAccountId);
+  }
+}
+
+function normalizeTimelineScreenshotJob(job) {
+  if (!job || typeof job !== "object") {
+    return null;
+  }
+
+  const id = normalizeText(job.id);
+  const accountId = normalizeText(job.accountId);
+  const senderId = normalizeText(job.senderId);
+  const outputFile = normalizeText(job.outputFile);
+  const createdAt = normalizeIsoTime(job.createdAt);
+  const args = normalizeArgs(job.args);
+
+  if (!id || !accountId || !senderId) {
+    return null;
+  }
+
+  return {
+    id,
+    accountId,
+    senderId,
+    outputFile,
+    args,
+    createdAt: createdAt || new Date().toISOString(),
+  };
+}
+
+function normalizeArgs(args) {
+  return Array.isArray(args)
+    ? args.map((value) => normalizeText(value)).filter(Boolean)
+    : [];
+}
+
+function normalizeIsoTime(value) {
+  const normalized = normalizeText(value);
+  if (!normalized) {
+    return "";
+  }
+  const parsed = Date.parse(normalized);
+  if (!Number.isFinite(parsed)) {
+    return "";
+  }
+  return new Date(parsed).toISOString();
+}
+
+function compareTimelineScreenshotJobs(left, right) {
+  const leftTime = Date.parse(left?.createdAt || "") || 0;
+  const rightTime = Date.parse(right?.createdAt || "") || 0;
+  if (leftTime !== rightTime) {
+    return leftTime - rightTime;
+  }
+  return String(left?.id || "").localeCompare(String(right?.id || ""));
+}
+
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+module.exports = { TimelineScreenshotQueueStore };

package/src/core/workspace-alias.js

@@ -0,0 +1,163 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const DEFAULT_ALIAS_MANIFEST = path.join(os.homedir(), ".codex", "windows-ascii-alias", "aliases.json");
+
+function resolveCodexWorkspaceRoot(workspaceRoot, options = {}) {
+  const normalized = normalizeWorkspaceRoot(workspaceRoot);
+  if (!normalized) {
+    return "";
+  }
+  if (isAscii(normalized)) {
+    return normalized;
+  }
+
+  const mapping = resolveAliasMappingForPath(normalized, options);
+  if (!mapping) {
+    return normalized;
+  }
+
+  const converted = convertRootedPath(normalized, mapping.fromRoot, mapping.toRoot);
+  if (!converted) {
+    return normalized;
+  }
+  // Alias roots are only a compatibility shim for Codex transport quirks. If
+  // the manifest drifts or the junction disappears, prefer the real workspace
+  // root over a synthetic cwd that would otherwise trigger os error 267.
+  return isReadableDirectory(converted) ? converted : normalized;
+}
+
+function resolveAliasMappingForPath(workspaceRoot, options = {}) {
+  const normalized = normalizeWorkspaceRoot(workspaceRoot);
+  if (!normalized) {
+    return null;
+  }
+
+  const mappings = loadAliasMappings(options);
+  let bestMatch = null;
+  let bestLength = -1;
+
+  for (const mapping of mappings) {
+    for (const candidate of [
+      { kind: "target", root: mapping.targetPath, toRoot: mapping.aliasPath },
+      { kind: "alias", root: mapping.aliasPath, toRoot: mapping.aliasPath },
+    ]) {
+      if (!isPathWithinRoot(normalized, candidate.root)) {
+        continue;
+      }
+      if (candidate.root.length <= bestLength) {
+        continue;
+      }
+      bestMatch = {
+        slug: mapping.slug,
+        kind: candidate.kind,
+        fromRoot: candidate.root,
+        toRoot: candidate.toRoot,
+      };
+      bestLength = candidate.root.length;
+    }
+  }
+
+  return bestMatch;
+}
+
+function loadAliasMappings(options = {}) {
+  const manifestPath = typeof options.manifestPath === "string" && options.manifestPath.trim()
+    ? options.manifestPath.trim()
+    : DEFAULT_ALIAS_MANIFEST;
+  try {
+    const raw = fs.readFileSync(manifestPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const mappings = Array.isArray(parsed?.mappings) ? parsed.mappings : [];
+    return mappings
+      .map((mapping) => ({
+        slug: normalizeText(mapping?.slug),
+        targetPath: normalizeWorkspaceRoot(mapping?.target_path),
+        aliasPath: normalizeWorkspaceRoot(mapping?.alias_path),
+      }))
+      .filter((mapping) => mapping.slug && mapping.targetPath && mapping.aliasPath);
+  } catch {
+    return [];
+  }
+}
+
+function convertRootedPath(pathValue, fromRoot, toRoot) {
+  const normalizedPath = normalizeWorkspaceRoot(pathValue);
+  const normalizedFromRoot = normalizeWorkspaceRoot(fromRoot);
+  const normalizedToRoot = normalizeWorkspaceRoot(toRoot);
+  if (!normalizedPath || !normalizedFromRoot || !normalizedToRoot) {
+    return "";
+  }
+  if (!isPathWithinRoot(normalizedPath, normalizedFromRoot)) {
+    return "";
+  }
+  if (normalizedPath === normalizedFromRoot) {
+    return normalizedToRoot;
+  }
+  return `${normalizedToRoot}${normalizedPath.slice(normalizedFromRoot.length)}`;
+}
+
+function isPathWithinRoot(pathValue, rootValue) {
+  const normalizedPath = normalizeWorkspaceRoot(pathValue);
+  const normalizedRoot = normalizeWorkspaceRoot(rootValue);
+  if (!normalizedPath || !normalizedRoot) {
+    return false;
+  }
+  if (normalizedPath === normalizedRoot) {
+    return true;
+  }
+  if (normalizedPath.length <= normalizedRoot.length) {
+    return false;
+  }
+  if (!normalizedPath.toLowerCase().startsWith(normalizedRoot.toLowerCase())) {
+    return false;
+  }
+  const nextChar = normalizedPath[normalizedRoot.length];
+  return nextChar === "/" || nextChar === "\\";
+}
+
+function isReadableDirectory(pathValue) {
+  const normalized = normalizeWorkspaceRoot(pathValue);
+  if (!normalized) {
+    return false;
+  }
+  try {
+    return fs.statSync(path.resolve(normalized)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function normalizeWorkspaceRoot(value) {
+  const normalized = normalizeText(value).replace(/\\/g, "/");
+  if (!normalized) {
+    return "";
+  }
+  if (normalized.length > 3) {
+    return normalized.replace(/\/+$/g, "");
+  }
+  return normalized;
+}
+
+function isAscii(value) {
+  for (const char of String(value || "")) {
+    if (char.charCodeAt(0) > 127) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+module.exports = {
+  DEFAULT_ALIAS_MANIFEST,
+  convertRootedPath,
+  loadAliasMappings,
+  normalizeWorkspaceRoot,
+  resolveAliasMappingForPath,
+  resolveCodexWorkspaceRoot,
+};