code-workspace-zhuiyi 0.1.0-beta.1

package/src/monitor/i18n/locales/en-US.js

@@ -0,0 +1,85 @@
+module.exports = {
+  code: "en-US",
+  label: "English",
+  default: true,
+  messages: {
+    title: "Code Workspace Monitor",
+    eyebrow: "Local runtime center",
+    language: "Language",
+    summary: "Monitor summary",
+    workspaces: "Workspaces",
+    sessions: "Sessions",
+    turns: "Turns",
+    active: "Active sessions",
+    execution: "Execution",
+    signals: "Live signals",
+    waitingData: "Waiting for data",
+    nodes: "{count} nodes",
+    pending: " · {count} to review",
+    events: "{count} events",
+    updated: "Updated {value}",
+    never: "never",
+    justNow: "just now",
+    seconds: "{count} seconds ago",
+    minutes: "{count} minutes ago",
+    hours: "{count} hours ago",
+    workspaceMeta: "{active} active / {sessions} total sessions · {signals} signals · {updated}",
+    approval: "Approval {count}",
+    complete: "Complete {count}",
+    actions: "actions",
+    removeWorkspace: "Remove workspace",
+    removeSession: "Delete session",
+    emptyWorkspaces: "No workspace signals yet",
+    waitingAgent: "Waiting for Agent signals",
+    waitingAgentDetail:
+      "Enable monitoring in a workspace and trust its Codex hooks.",
+    session: "Session",
+    lastSignal: "Last signal {value}",
+    inactiveReason: "No signal received for more than 10 minutes",
+    turn: "Turn",
+    tool: "Tool",
+    signalsCount: "{count} signals",
+    noSessions: "No session records.",
+    noTurns: "No turn details yet.",
+    noEvents: "No events",
+    soundUnavailable: "Notification sound unavailable",
+    soundWarning: "Unable to enable monitor sound:",
+    soundLoadingTitle: "Loading notification sound",
+    soundFirstUse:
+      "Sound is on; interact with the page once to enable playback",
+    soundDisable: "Disable notification sound",
+    soundEnable: "Enable notification sound",
+    soundLoading: "Loading sound",
+    soundOn: "Sound on",
+    soundOff: "Sound off",
+    removeConfirm:
+      "Remove “{name}” from the monitor? It will return automatically when a new signal arrives.",
+    removeSessionConfirm:
+      "Delete session “{id}” and its related signals?",
+    removeActiveSessionConfirm:
+      "Session “{id}” is still active. Delete it? It will return when a new signal arrives.",
+    live: "Live",
+    connecting: "Connecting",
+    reconnecting: "Reconnecting",
+    status: {
+      IDLE: "Idle",
+      RUNNING: "Running",
+      WAITING_APPROVAL: "Waiting approval",
+      RECENT_COMPLETE: "Just completed",
+      STOPPED: "Stopped",
+      ACTIVE: "Active",
+      INACTIVE: "Inactive",
+      ENDED: "Ended",
+      SESSION_ENDED: "Session ended",
+    },
+    event: {
+      "turn.started": "Turn started",
+      "approval.requested": "Approval requested",
+      "tool.completed": "Tool completed",
+      "subagent.started": "Subagent started",
+      "subagent.stopped": "Subagent stopped",
+      "turn.stopped": "Turn completed",
+      "session.ended": "Session ended",
+    },
+  },
+};

package/src/monitor/i18n/locales/zh-CN.js

@@ -0,0 +1,79 @@
+module.exports = {
+  code: "zh-CN",
+  label: "中文（简体）",
+  messages: {
+    title: "Code Workspace 监控",
+    eyebrow: "本地运行中心",
+    language: "语言",
+    summary: "监控汇总",
+    workspaces: "工作区",
+    sessions: "会话",
+    turns: "轮次",
+    active: "活跃会话",
+    execution: "执行视图",
+    signals: "实时信号",
+    waitingData: "等待数据",
+    nodes: "{count} 个节点",
+    pending: " · {count} 个待查看",
+    events: "{count} 条事件",
+    updated: "更新于 {value}",
+    never: "从未",
+    justNow: "刚刚",
+    seconds: "{count} 秒前",
+    minutes: "{count} 分钟前",
+    hours: "{count} 小时前",
+    workspaceMeta: "活跃 {active} / 总计 {sessions} 个会话 · {signals} 条信号 · {updated}",
+    approval: "待授权 {count}",
+    complete: "已完成 {count}",
+    actions: "操作",
+    removeWorkspace: "移除工作区",
+    removeSession: "删除会话",
+    emptyWorkspaces: "暂无工作区信号",
+    waitingAgent: "等待 Agent 信号",
+    waitingAgentDetail: "请在工作区中启用监控，并信任其 Codex hooks。",
+    session: "会话",
+    lastSignal: "最后信号 {value}",
+    inactiveReason: "超过 10 分钟未收到信号",
+    turn: "轮次",
+    tool: "工具",
+    signalsCount: "{count} 条信号",
+    noSessions: "暂无会话记录。",
+    noTurns: "暂无轮次详情。",
+    noEvents: "暂无事件",
+    soundUnavailable: "提示音不可用",
+    soundWarning: "无法启用监控提示音：",
+    soundLoadingTitle: "正在加载事件提示音",
+    soundFirstUse: "声音默认开启；首次操作页面后即可播放",
+    soundDisable: "关闭事件提示音",
+    soundEnable: "启用事件提示音",
+    soundLoading: "正在加载声音",
+    soundOn: "声音已开启",
+    soundOff: "声音已关闭",
+    removeConfirm: "确定从监控中移除“{name}”吗？收到新信号后它会自动恢复。",
+    removeSessionConfirm: "确定删除会话“{id}”及其关联信号吗？",
+    removeActiveSessionConfirm: "会话“{id}”仍处于活跃状态。确定删除吗？收到新信号后它会重新出现。",
+    live: "实时连接",
+    connecting: "连接中",
+    reconnecting: "正在重连",
+    status: {
+      IDLE: "空闲",
+      RUNNING: "执行中",
+      WAITING_APPROVAL: "等待授权",
+      RECENT_COMPLETE: "刚完成",
+      STOPPED: "已停止",
+      ACTIVE: "活跃",
+      INACTIVE: "非活跃",
+      ENDED: "已结束",
+      SESSION_ENDED: "会话结束",
+    },
+    event: {
+      "turn.started": "轮次开始",
+      "approval.requested": "请求授权",
+      "tool.completed": "工具完成",
+      "subagent.started": "子 Agent 启动",
+      "subagent.stopped": "子 Agent 停止",
+      "turn.stopped": "轮次完成",
+      "session.ended": "会话结束",
+    },
+  },
+};

package/src/monitor/index.js

@@ -0,0 +1,344 @@
+const http = require("node:http");
+const { randomUUID } = require("node:crypto");
+const fs = require("node:fs");
+const path = require("node:path");
+const { renderMonitorPage } = require("./page");
+
+const DEFAULT_MONITOR_HOST = "127.0.0.1";
+const DEFAULT_MONITOR_PORT = 3211;
+const DEFAULT_SESSION_INACTIVITY_MS = 10 * 60 * 1000;
+const MONITOR_ASSETS = new Map([
+  ["/assets/request_tip.mp3", { file: path.join(__dirname, "..", "..", "assets", "request_tip.mp3"), type: "audio/mpeg" }],
+  ["/assets/session_finish.mp3", { file: path.join(__dirname, "..", "..", "assets", "session_finish.mp3"), type: "audio/mpeg" }],
+  ["/assets/logo-vector.svg", { file: path.join(__dirname, "..", "..", "assets", "logo-vector.svg"), type: "image/svg+xml; charset=utf-8" }],
+  ["/assets/i18n-icon.svg", { file: path.join(__dirname, "..", "..", "assets", "i18n-icon.svg"), type: "image/svg+xml; charset=utf-8" }],
+]);
+
+const EVENT_DEFINITIONS = {
+  UserPromptSubmit: ["turn.started", "RUNNING"],
+  PermissionRequest: ["approval.requested", "WAITING_APPROVAL"],
+  PostToolUse: ["tool.completed", "RUNNING"],
+  SubagentStart: ["subagent.started", "RUNNING"],
+  SubagentStop: ["subagent.stopped", "RUNNING"],
+  Stop: ["turn.stopped", "STOPPED"],
+  SessionEnd: ["session.ended", "SESSION_ENDED"],
+};
+
+function validatePort(value, options = {}) {
+  const port = Number(value ?? DEFAULT_MONITOR_PORT);
+  const minimum = options.allowZero ? 0 : 1;
+  if (!Number.isInteger(port) || port < minimum || port > 65535) throw new Error("Monitor port must be between 1 and 65535");
+  return port;
+}
+
+function normalizeHookEvent(input, config) {
+  const definition = EVENT_DEFINITIONS[input?.hook_event_name];
+  if (!definition || typeof input.session_id !== "string") return null;
+  return {
+    schemaVersion: 1,
+    eventId: randomUUID(),
+    source: "codex",
+    eventType: definition[0],
+    status: definition[1],
+    timestamp: new Date().toISOString(),
+    workspace: { uuid: config.workspace.uuid, name: config.workspace.name },
+    session: { id: input.session_id },
+    turn: input.turn_id ? { id: input.turn_id } : null,
+    context: {
+      cwd: input.cwd || null,
+      model: input.model || null,
+      permissionMode: input.permission_mode || null,
+    },
+    tool: input.tool_name ? { name: input.tool_name, useId: input.tool_use_id || null } : null,
+    subagent: input.agent_id ? { id: input.agent_id, type: input.agent_type || null } : null,
+  };
+}
+
+function validEvent(event) {
+  return Boolean(
+    event?.schemaVersion === 1 &&
+    typeof event.eventId === "string" &&
+    typeof event.eventType === "string" &&
+    typeof event.status === "string" &&
+    typeof event.workspace?.uuid === "string" &&
+    typeof event.workspace?.name === "string" &&
+    typeof event.session?.id === "string"
+  );
+}
+
+function createMonitorStore(options = {}) {
+  const maxEvents = Number(options.maxEvents || 1000);
+  if (!Number.isInteger(maxEvents) || maxEvents < 1) throw new Error("maxEvents must be a positive integer");
+  const sessionInactivityMs = Number(options.sessionInactivityMs ?? DEFAULT_SESSION_INACTIVITY_MS);
+  if (!Number.isInteger(sessionInactivityMs) || sessionInactivityMs < 1) {
+    throw new Error("sessionInactivityMs must be a positive integer");
+  }
+  const clock = typeof options.now === "function" ? options.now : () => new Date();
+  const events = [];
+  const workspaces = new Map();
+  const subscribers = new Set();
+
+  function nowIso() {
+    const value = clock();
+    const date = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(date.getTime())) throw new Error("monitor clock returned an invalid date");
+    return date.toISOString();
+  }
+
+  function publish(message) {
+    const payload = `event: update\ndata: ${JSON.stringify(message)}\n\n`;
+    for (const response of subscribers) response.write(payload);
+  }
+
+  function accept(event) {
+    if (!validEvent(event)) throw new Error("invalid event payload");
+    if (events.some((current) => current.eventId === event.eventId)) return { duplicate: true };
+    const receivedAt = nowIso();
+    const storedEvent = { ...event, timestamp: event.timestamp || receivedAt };
+    const previous = workspaces.get(event.workspace.uuid) || {
+      uuid: event.workspace.uuid,
+      name: event.workspace.name,
+      sessions: {},
+      eventCount: 0,
+      firstSeenAt: receivedAt,
+    };
+    const session = previous.sessions[event.session.id] || {
+      id: event.session.id,
+      turns: {},
+      status: "ACTIVE",
+      firstSeenAt: receivedAt,
+    };
+    const turnId = event.turn?.id;
+    if (turnId) {
+      const turn = session.turns[turnId] || { id: turnId, eventCount: 0, startedAt: receivedAt };
+      turn.status = event.status;
+      turn.eventCount += 1;
+      turn.updatedAt = receivedAt;
+      turn.tool = event.tool;
+      turn.subagent = event.subagent;
+      session.turns[turnId] = turn;
+    }
+    if (event.status === "SESSION_ENDED") session.status = "ENDED";
+    session.eventCount = (session.eventCount || 0) + 1;
+    session.lastSignalAt = receivedAt;
+    session.updatedAt = receivedAt;
+    previous.name = event.workspace.name;
+    previous.sessions[event.session.id] = session;
+    previous.eventCount += 1;
+    previous.updatedAt = receivedAt;
+    workspaces.set(previous.uuid, previous);
+    events.unshift(storedEvent);
+    if (events.length > maxEvents) events.length = maxEvents;
+    publish({ event: storedEvent, workspace: previous });
+    return { duplicate: false, workspaceUuid: previous.uuid };
+  }
+
+  function removeWorkspace(uuid) {
+    if (!workspaces.delete(uuid)) return { removed: false, workspaceUuid: uuid };
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+      if (events[index].workspace.uuid === uuid) events.splice(index, 1);
+    }
+    publish({ workspaceRemoved: uuid });
+    return { removed: true, workspaceUuid: uuid };
+  }
+
+  function removeSession(workspaceUuid, sessionId) {
+    const workspace = workspaces.get(workspaceUuid);
+    if (!workspace || !workspace.sessions[sessionId]) {
+      return { removed: false, workspaceUuid, sessionId };
+    }
+    const session = workspace.sessions[sessionId];
+    delete workspace.sessions[sessionId];
+    let removedEvents = 0;
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+      if (events[index].workspace.uuid === workspaceUuid && events[index].session.id === sessionId) {
+        events.splice(index, 1);
+        removedEvents += 1;
+      }
+    }
+    workspace.eventCount = Math.max(0, workspace.eventCount - (session.eventCount || removedEvents));
+    const remainingSessions = Object.values(workspace.sessions);
+    workspace.updatedAt = remainingSessions.reduce(
+      (latest, session) => latest > session.updatedAt ? latest : session.updatedAt,
+      workspace.firstSeenAt
+    );
+    publish({ sessionRemoved: { workspaceUuid, sessionId } });
+    return { removed: true, workspaceUuid, sessionId, removedEvents };
+  }
+
+  function effectiveSessionStatus(session, serverTime) {
+    if (session.status === "ENDED") return "ENDED";
+    const lastSignalAt = session.lastSignalAt || session.updatedAt || session.firstSeenAt;
+    const elapsed = new Date(serverTime).getTime() - new Date(lastSignalAt).getTime();
+    return Number.isFinite(elapsed) && elapsed >= sessionInactivityMs ? "INACTIVE" : "ACTIVE";
+  }
+
+  function snapshot() {
+    const serverTime = nowIso();
+    const summary = { workspaces: workspaces.size, sessions: 0, activeSessions: 0, turns: 0 };
+    const projectedWorkspaces = [...workspaces.values()].map((workspace) => {
+      const sessions = {};
+      let activeSessionCount = 0;
+      for (const session of Object.values(workspace.sessions)) {
+        const status = effectiveSessionStatus(session, serverTime);
+        if (status === "ACTIVE") activeSessionCount += 1;
+        summary.sessions += 1;
+        summary.turns += Object.keys(session.turns).length;
+        sessions[session.id] = { ...session, status };
+      }
+      summary.activeSessions += activeSessionCount;
+      return {
+        ...workspace,
+        sessions,
+        sessionCount: Object.keys(sessions).length,
+        activeSessionCount,
+      };
+    });
+    return {
+      workspaces: projectedWorkspaces.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)),
+      events: events.slice(),
+      serverTime,
+      summary,
+    };
+  }
+
+  return { accept, events, removeSession, removeWorkspace, snapshot, subscribers, workspaces };
+}
+
+async function readJson(request, limit = 256_000) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    size += chunk.length;
+    if (size > limit) throw new Error("request body is too large");
+    chunks.push(chunk);
+  }
+  return JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
+}
+
+function sendJson(response, status, body) {
+  response.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+  response.end(JSON.stringify(body));
+}
+
+function sendHtml(response, body) {
+  response.writeHead(200, {
+    "content-type": "text/html; charset=utf-8",
+    "cache-control": "no-store",
+    "content-security-policy": "default-src 'self'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; connect-src 'self'; media-src 'self'",
+    "x-content-type-options": "nosniff",
+  });
+  response.end(body);
+}
+
+function sendAsset(response, asset) {
+  const body = fs.readFileSync(asset.file);
+  response.writeHead(200, {
+    "content-type": asset.type,
+    "content-length": body.length,
+    "cache-control": "public, max-age=3600",
+    "x-content-type-options": "nosniff",
+  });
+  response.end(body);
+}
+
+function createMonitorServer(options = {}) {
+  const host = options.host || DEFAULT_MONITOR_HOST;
+  const port = validatePort(options.port, { allowZero: options.allowZero === true });
+  const store = options.store || createMonitorStore(options);
+  const server = http.createServer(async (request, response) => {
+    const url = new URL(request.url, `http://${request.headers.host || `${host}:${port}`}`);
+    try {
+      if (request.method === "GET" && url.pathname === "/") return sendHtml(response, renderMonitorPage());
+      if (request.method === "GET" && MONITOR_ASSETS.has(url.pathname)) return sendAsset(response, MONITOR_ASSETS.get(url.pathname));
+      if (request.method === "GET" && url.pathname === "/api/v1/health") return sendJson(response, 200, { ok: true });
+      if (request.method === "GET" && url.pathname === "/api/v1/snapshot") return sendJson(response, 200, store.snapshot());
+      if (request.method === "GET" && url.pathname === "/api/v1/workspaces") return sendJson(response, 200, { workspaces: store.snapshot().workspaces });
+      if (request.method === "GET" && url.pathname === "/api/v1/events") return sendJson(response, 200, { events: store.snapshot().events });
+      const sessionRoute = url.pathname.match(/^\/api\/v1\/workspaces\/([^/]+)\/sessions\/([^/]+)$/);
+      if (request.method === "DELETE" && sessionRoute) {
+        const uuid = decodeURIComponent(sessionRoute[1]);
+        const sessionId = decodeURIComponent(sessionRoute[2]);
+        if (!uuid || !sessionId || uuid.includes("/") || sessionId.includes("/")) {
+          return sendJson(response, 404, { error: "not found" });
+        }
+        const result = store.removeSession(uuid, sessionId);
+        return sendJson(response, result.removed ? 200 : 404, result.removed ? result : { error: "session not found" });
+      }
+      const workspaceRoute = url.pathname.match(/^\/api\/v1\/workspaces\/([^/]+)$/);
+      if (request.method === "DELETE" && workspaceRoute) {
+        const uuid = decodeURIComponent(workspaceRoute[1]);
+        if (!uuid || uuid.includes("/")) return sendJson(response, 404, { error: "not found" });
+        const result = store.removeWorkspace(uuid);
+        return sendJson(response, result.removed ? 200 : 404, result.removed ? result : { error: "workspace not found" });
+      }
+      if (request.method === "GET" && url.pathname === "/api/v1/stream") {
+        response.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" });
+        response.write(": connected\n\n");
+        store.subscribers.add(response);
+        request.on("close", () => store.subscribers.delete(response));
+        return;
+      }
+      if (request.method === "POST" && url.pathname === "/api/v1/events") {
+        const result = store.accept(await readJson(request));
+        return sendJson(response, result.duplicate ? 200 : 202, { accepted: true, ...result });
+      }
+      return sendJson(response, 404, { error: "not found" });
+    } catch (error) {
+      return sendJson(response, 400, { error: error.message });
+    }
+  });
+  return { host, port, server, store };
+}
+
+function startMonitor(options = {}) {
+  const monitor = createMonitorServer(options);
+  return new Promise((resolve, reject) => {
+    const onError = (error) => {
+      monitor.server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      monitor.server.off("error", onError);
+      resolve(monitor);
+    };
+    monitor.server.once("error", onError);
+    monitor.server.once("listening", onListening);
+    monitor.server.listen(monitor.port, monitor.host);
+  });
+}
+
+async function reportHookEvent(input, config, options = {}) {
+  if (!config.monitor?.enable || !config.workspace) return { action: "skip", reason: "monitor disabled" };
+  const event = normalizeHookEvent(input, config);
+  if (!event) return { action: "skip", reason: "unsupported event" };
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeoutMs || 300);
+  try {
+    const response = await (options.fetch || fetch)(`${config.monitor.url}/api/v1/events`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(event),
+      signal: controller.signal,
+    });
+    return { action: response.ok ? "report" : "skip", status: response.status, event };
+  } catch {
+    return { action: "skip", reason: "monitor unavailable", event };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+module.exports = {
+  DEFAULT_MONITOR_HOST,
+  DEFAULT_MONITOR_PORT,
+  DEFAULT_SESSION_INACTIVITY_MS,
+  EVENT_DEFINITIONS,
+  createMonitorServer,
+  createMonitorStore,
+  normalizeHookEvent,
+  reportHookEvent,
+  startMonitor,
+  validatePort,
+  validEvent,
+};