codeksei 0.1.0

package/scripts/shared-open.js

@@ -0,0 +1,46 @@
+const { spawn } = require("child_process");
+const { readPrefixedEnv } = require("../src/core/branding");
+const { resolveCodexWorkspaceRoot } = require("../src/core/workspace-alias");
+const {
+  listenUrl,
+  buildSpawnInvocation,
+  ensureSharedAppServer,
+  resolveBoundThread,
+} = require("./shared-common");
+
+async function main() {
+  const workspaceRoot = readPrefixedEnv(process.env, "WORKSPACE_ROOT") || process.cwd();
+  await ensureSharedAppServer();
+  const { threadId, workspaceRoot: resolvedWorkspaceRoot } = resolveBoundThread(workspaceRoot);
+  // Keep the session bound to the canonical workspace root, but launch the
+  // local Codex client from the ASCII alias so desktop attach does not
+  // reintroduce the non-ASCII workspace header bug on Windows.
+  const runtimeWorkspaceRoot = resolveCodexWorkspaceRoot(resolvedWorkspaceRoot);
+  const spawnSpec = buildSpawnInvocation(readPrefixedEnv(process.env, "CODEX_COMMAND") || "codex", [
+    "resume",
+    threadId,
+    "--remote",
+    listenUrl,
+    "-C",
+    runtimeWorkspaceRoot,
+    ...process.argv.slice(2),
+  ]);
+  const child = spawn(spawnSpec.command, spawnSpec.args, {
+    stdio: "inherit",
+    shell: false,
+    windowsHide: true,
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code ?? 0);
+  });
+}
+
+main().catch((error) => {
+  console.error(error.message || String(error));
+  process.exit(1);
+});

package/scripts/shared-start.js

@@ -0,0 +1,41 @@
+const {
+  listenUrl,
+  ensureManagedAppServer,
+  ensureManagedBridge,
+  ensureManagedSupervisor,
+} = require("./shared-common");
+const { readPrefixedEnv } = require("../src/core/branding");
+
+function parseIntervalMinutes() {
+  for (const rawArg of process.argv.slice(2)) {
+    if (!rawArg.startsWith("--interval-minutes=")) {
+      continue;
+    }
+    const value = Number.parseInt(rawArg.slice("--interval-minutes=".length), 10);
+    if (Number.isInteger(value) && value >= 1) {
+      return value;
+    }
+  }
+  const value = Number.parseInt(
+    String(readPrefixedEnv(process.env, "SHARED_WATCHDOG_INTERVAL_MINUTES") || "5"),
+    10
+  );
+  return Number.isInteger(value) && value >= 1 ? value : 5;
+}
+
+async function main() {
+  const appServer = await ensureManagedAppServer({ restartUnhealthy: true });
+  const appServerPidLabel = appServer.pid ? ` pid=${appServer.pid}` : "";
+  console.log(`shared app-server ${appServer.status}${appServerPidLabel} listen=${listenUrl}`);
+
+  const bridge = await ensureManagedBridge({ restartUnhealthy: true });
+  console.log(`shared codeksei ${bridge.status} pid=${bridge.pid}`);
+
+  const supervisor = await ensureManagedSupervisor({ intervalMinutes: parseIntervalMinutes() });
+  console.log(`shared supervisor ${supervisor.status} pid=${supervisor.pid}`);
+}
+
+main().catch((error) => {
+  console.error(error.message || String(error));
+  process.exit(1);
+});

package/scripts/shared-status.js

@@ -0,0 +1,74 @@
+const http = require("http");
+const {
+  listenUrl,
+  appServerPidFile,
+  bridgePidFile,
+  supervisorPidFile,
+  watchdogStateFile,
+  readPidFile,
+  isPidAlive,
+  readSharedBridgeHealth,
+  resolveReadyAppServerPid,
+  readJsonFile,
+} = require("./shared-common");
+
+async function main() {
+  const ready = await checkReadyz();
+  const readyAppServerPid = ready ? await resolveReadyAppServerPid() : 0;
+  const bridgeHealth = readSharedBridgeHealth();
+  const watchdogState = readJsonFile(watchdogStateFile) || {};
+  console.log(`listen=${listenUrl}`);
+  printPidState("shared_supervisor_pid", supervisorPidFile);
+  printPidState("shared_app_server_pid", appServerPidFile, readyAppServerPid);
+  printPidState("shared_codeksei_pid", bridgePidFile);
+  printPidState("shared_cyberboss_pid", bridgePidFile);
+  console.log(`shared_bridge_heartbeat=${bridgeHealth.classification.status}`);
+  console.log(`shared_bridge_heartbeat_at=${bridgeHealth.classification.updatedAt || "missing"}`);
+  console.log(`shared_watchdog_last_run=${normalizeText(watchdogState.lastRunAt) || "missing"}`);
+  console.log(`shared_watchdog_last_result=${normalizeText(watchdogState.result) || "missing"}`);
+  console.log(`readyz=${ready ? "ok" : "down"}`);
+}
+
+function printPidState(label, filePath, fallbackPid = 0) {
+  const pid = readPidFile(filePath) || fallbackPid;
+  if (!pid) {
+    console.log(`${label}=missing`);
+    return;
+  }
+  if (!isPidAlive(pid)) {
+    console.log(`${label}=stale`);
+    return;
+  }
+  console.log(`${label}=${pid}`);
+}
+
+function checkReadyz() {
+  return new Promise((resolve) => {
+    const req = http.get(
+      {
+        hostname: "127.0.0.1",
+        port: new URL(listenUrl).port,
+        path: "/readyz",
+        timeout: 600,
+      },
+      (res) => {
+        res.resume();
+        resolve(res.statusCode >= 200 && res.statusCode < 300);
+      }
+    );
+    req.on("error", () => resolve(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(false);
+    });
+  });
+}
+
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+main().catch((error) => {
+  console.error(error.message || String(error));
+  process.exit(1);
+});

package/scripts/shared-supervisor.js

@@ -0,0 +1,141 @@
+const {
+  ensureLogDir,
+  supervisorPidFile,
+  readPidFile,
+  writePidFile,
+  removePidFileIfMatches,
+  isPidAlive,
+  readProcessCommandLine,
+} = require("./shared-common");
+const { runWatchdogOnce } = require("./shared-watchdog");
+const { readPrefixedEnv } = require("../src/core/branding");
+
+const DEFAULT_INTERVAL_MINUTES = 5;
+
+let shuttingDown = false;
+let lastLoggedSignature = "";
+
+function parseIntervalMinutes(argv) {
+  for (const rawArg of argv) {
+    if (!rawArg.startsWith("--interval-minutes=")) {
+      continue;
+    }
+    const value = Number.parseInt(rawArg.slice("--interval-minutes=".length), 10);
+    if (Number.isInteger(value) && value >= 1) {
+      return value;
+    }
+  }
+
+  const fromEnv = Number.parseInt(
+    String(readPrefixedEnv(process.env, "SHARED_WATCHDOG_INTERVAL_MINUTES") || ""),
+    10
+  );
+  if (Number.isInteger(fromEnv) && fromEnv >= 1) {
+    return fromEnv;
+  }
+  return DEFAULT_INTERVAL_MINUTES;
+}
+
+function formatErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message || error.stack || String(error);
+  }
+  return String(error || "unknown error");
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function buildStateSignature(state) {
+  const actions = Array.isArray(state?.actions) ? state.actions.join("|") : "";
+  const error = typeof state?.error === "string" ? state.error.trim() : "";
+  const readyz = state?.after?.appServer?.ready ? "ok" : "down";
+  const heartbeat = state?.after?.bridge?.heartbeatStatus || "missing";
+  return [state?.result || "unknown", readyz, heartbeat, actions, error].join("|");
+}
+
+function logLine(message) {
+  const timestamp = new Date().toISOString();
+  console.log(`[${timestamp}] ${message}`);
+}
+
+function ensureSingleInstance() {
+  const existingPid = readPidFile(supervisorPidFile);
+  if (!existingPid || existingPid === process.pid || !isPidAlive(existingPid)) {
+    return 0;
+  }
+
+  const commandLine = readProcessCommandLine(existingPid);
+  if (String(commandLine).toLowerCase().includes("shared-supervisor.js")) {
+    return existingPid;
+  }
+  throw new Error(`refusing to reuse shared supervisor pid=${existingPid}: unexpected command line`);
+}
+
+function installSignalHandlers() {
+  const shutdown = (signal) => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    logLine(`signal=${signal} shutting_down=true`);
+  };
+
+  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP", "SIGBREAK"]) {
+    process.on(signal, () => shutdown(signal));
+  }
+
+  process.on("exit", () => {
+    removePidFileIfMatches(supervisorPidFile, process.pid);
+  });
+}
+
+async function main() {
+  ensureLogDir();
+  const existingPid = ensureSingleInstance();
+  if (existingPid) {
+    logLine(`already_running pid=${existingPid}`);
+    return;
+  }
+
+  const intervalMinutes = parseIntervalMinutes(process.argv.slice(2));
+  const intervalMs = intervalMinutes * 60_000;
+  writePidFile(supervisorPidFile, process.pid);
+  installSignalHandlers();
+
+  // Keep one long-lived background process per desktop session so healthy
+  // periods do not require Task Scheduler to spawn a fresh watchdog script
+  // every few minutes. Recovery still uses the same watchdog logic, but the
+  // idle path is now a sleeping supervisor rather than repeated task launches.
+  logLine(`started pid=${process.pid} interval_minutes=${intervalMinutes}`);
+
+  while (!shuttingDown) {
+    try {
+      const state = await runWatchdogOnce({ shouldPrintSummary: false });
+      const signature = buildStateSignature(state);
+      if (signature !== lastLoggedSignature || state.result !== "healthy") {
+        const actions = Array.isArray(state.actions) && state.actions.length
+          ? ` actions=${state.actions.join(" | ")}`
+          : "";
+        const error = state.error ? ` error=${state.error}` : "";
+        logLine(`result=${state.result} readyz=${state.after?.appServer?.ready ? "ok" : "down"} bridge=${state.after?.bridge?.heartbeatStatus || "missing"}${actions}${error}`);
+        lastLoggedSignature = signature;
+      }
+    } catch (error) {
+      logLine(`loop_error=${formatErrorMessage(error)}`);
+    }
+
+    if (!shuttingDown) {
+      await sleep(intervalMs);
+    }
+  }
+
+  removePidFileIfMatches(supervisorPidFile, process.pid);
+  logLine(`stopped pid=${process.pid}`);
+}
+
+main().catch((error) => {
+  logLine(`fatal=${formatErrorMessage(error)}`);
+  process.exit(1);
+});

package/scripts/shared-task-runner.ps1

@@ -0,0 +1,87 @@
+param(
+  [ValidateSet("Start", "Watchdog", "Supervisor")]
+  [string]$Mode = "Watchdog",
+  [int]$IntervalMinutes = 5
+)
+
+$ErrorActionPreference = "Stop"
+
+$repoRoot = Split-Path -Parent $PSScriptRoot
+Set-Location -LiteralPath $repoRoot
+
+$stateDir = if ($env:CODEKSEI_STATE_DIR) {
+  $env:CODEKSEI_STATE_DIR
+} elseif ($env:CYBERBOSS_STATE_DIR) {
+  $env:CYBERBOSS_STATE_DIR
+} else {
+  $newStateDir = Join-Path $env:USERPROFILE ".codeksei"
+  $legacyStateDir = Join-Path $env:USERPROFILE ".cyberboss"
+  if ((Test-Path -LiteralPath $newStateDir) -or -not (Test-Path -LiteralPath $legacyStateDir)) {
+    $newStateDir
+  } else {
+    $legacyStateDir
+  }
+}
+$logDir = Join-Path $stateDir "logs"
+$null = New-Item -ItemType Directory -Force -Path $logDir
+
+$logFile = if ($Mode -eq "Start") {
+  Join-Path $logDir "shared-task-start.log"
+} elseif ($Mode -eq "Supervisor") {
+  Join-Path $logDir "shared-task-supervisor.log"
+} else {
+  Join-Path $logDir "shared-task-watchdog.log"
+}
+$supervisorOutputLogFile = if ($Mode -eq "Supervisor") {
+  Join-Path $logDir "shared-supervisor.log"
+} else {
+  $null
+}
+$errorLogFile = if ($Mode -eq "Supervisor") {
+  Join-Path $logDir "shared-supervisor.stderr.log"
+} else {
+  $null
+}
+
+$node = (Get-Command node -ErrorAction Stop).Source
+$scriptPath = if ($Mode -eq "Start") {
+  Join-Path $repoRoot "scripts\shared-start.js"
+} elseif ($Mode -eq "Supervisor") {
+  Join-Path $repoRoot "scripts\shared-supervisor.js"
+} else {
+  Join-Path $repoRoot "scripts\shared-watchdog.js"
+}
+
+$nodeArgs = @($scriptPath)
+if ($Mode -eq "Supervisor" -or $Mode -eq "Start") {
+  $nodeArgs += "--interval-minutes=$IntervalMinutes"
+}
+
+$startedAt = Get-Date -Format "yyyy-MM-ddTHH:mm:ssK"
+"[$startedAt] mode=$Mode starting" | Out-File -FilePath $logFile -Encoding utf8 -Append
+
+if ($Mode -eq "Supervisor") {
+  # Start the long-lived supervisor as a detached hidden process. Running it
+  # inline under the task shell keeps it attached to the outer PowerShell/cmd
+  # host, so closing or recycling that host can propagate SIGHUP and also
+  # surface transient console windows. We only want the scheduler to launch
+  # the supervisor, not to be the supervisor's lifetime owner.
+  $process = Start-Process `
+    -FilePath $node `
+    -ArgumentList $nodeArgs `
+    -WorkingDirectory $repoRoot `
+    -WindowStyle Hidden `
+    -RedirectStandardOutput $supervisorOutputLogFile `
+    -RedirectStandardError $errorLogFile `
+    -PassThru
+  "started_pid=$($process.Id)" | Out-File -FilePath $logFile -Encoding utf8 -Append
+  $exitCode = 0
+} else {
+  & $node @nodeArgs 2>&1 | Out-File -FilePath $logFile -Encoding utf8 -Append
+  $exitCode = $LASTEXITCODE
+}
+
+$endedAt = Get-Date -Format "yyyy-MM-ddTHH:mm:ssK"
+"[$endedAt] mode=$Mode exit=$exitCode" | Out-File -FilePath $logFile -Encoding utf8 -Append
+
+exit $exitCode

package/scripts/shared-watchdog.js

@@ -0,0 +1,290 @@
+const fs = require("fs");
+const dotenv = require("dotenv");
+const path = require("path");
+const {
+  ensureCompatHomeEnv,
+  ensureStateDirectory,
+  listEnvFileCandidates,
+} = require("../src/core/branding");
+
+const ALERT_COOLDOWN_MS = 10 * 60_000;
+
+function ensureDefaultStateDirectory() {
+  ensureStateDirectory();
+}
+
+function loadEnv() {
+  ensureDefaultStateDirectory();
+  const candidates = listEnvFileCandidates();
+  for (const envPath of candidates) {
+    if (!fs.existsSync(envPath)) {
+      continue;
+    }
+    dotenv.config({ path: envPath });
+    return;
+  }
+  dotenv.config();
+}
+
+function ensureRuntimeEnv() {
+  ensureCompatHomeEnv({ fallbackRoot: path.resolve(__dirname, "..") });
+}
+
+loadEnv();
+ensureRuntimeEnv();
+
+const { createWeixinChannelAdapter } = require("../src/adapters/channel/weixin");
+const { resolveSelectedAccount } = require("../src/adapters/channel/weixin/account-store");
+const { loadPersistedContextTokens } = require("../src/adapters/channel/weixin/context-token-store");
+const { SessionStore } = require("../src/adapters/runtime/codex/session-store");
+const { readConfig } = require("../src/core/config");
+const { resolvePreferredSenderId, resolvePreferredWorkspaceRoot } = require("../src/core/default-targets");
+const {
+  appServerLogFile,
+  appServerPidFile,
+  bridgeLogFile,
+  bridgePidFile,
+  ensureLogDir,
+  ensureManagedAppServer,
+  ensureManagedBridge,
+  readJsonFile,
+  readPidFile,
+  readSharedBridgeHealth,
+  resolveReadyAppServerPid,
+  watchdogStateFile,
+  writeJsonFile,
+} = require("./shared-common");
+
+async function runWatchdogOnce({ shouldPrintSummary = true } = {}) {
+  const config = readConfig();
+  ensureLogDir();
+  const previousState = readJsonFile(watchdogStateFile) || {};
+  const before = await collectHealth();
+  const actions = [];
+  let result = "healthy";
+  let errorMessage = "";
+
+  try {
+    const appServer = await ensureManagedAppServer({ restartUnhealthy: true });
+    if (appServer.status !== "already_running") {
+      actions.push(`shared app-server ${appServer.status} pid=${appServer.pid}`);
+    }
+
+    const bridge = await ensureManagedBridge({ restartUnhealthy: true });
+    if (bridge.status !== "already_running") {
+      actions.push(`shared codeksei ${bridge.status} pid=${bridge.pid}`);
+    }
+  } catch (error) {
+    result = "failed";
+    errorMessage = formatErrorMessage(error);
+  }
+
+  const after = await collectHealth();
+  if (result !== "failed") {
+    result = actions.length ? "recovered" : "healthy";
+  }
+
+  const nextState = {
+    lastRunAt: new Date().toISOString(),
+    result,
+    actions,
+    error: errorMessage,
+    before,
+    after,
+    lastAlertAt: normalizeText(previousState.lastAlertAt),
+    lastAlertSignature: normalizeText(previousState.lastAlertSignature),
+    lastNotification: previousState.lastNotification || null,
+  };
+
+  const alert = buildAlert({ result, actions, errorMessage, after, config });
+  if (alert && shouldSendAlert(previousState, alert.signature)) {
+    const notification = await sendVisibleAlert(config, alert.text);
+    nextState.lastAlertAt = new Date().toISOString();
+    nextState.lastAlertSignature = alert.signature;
+    nextState.lastNotification = {
+      kind: alert.kind,
+      sent: notification.sent,
+      reason: normalizeText(notification.reason),
+      senderId: normalizeText(notification.senderId),
+      workspaceRoot: normalizeText(notification.workspaceRoot),
+      sentAt: new Date().toISOString(),
+    };
+  }
+
+  writeJsonFile(watchdogStateFile, nextState);
+  if (shouldPrintSummary) {
+    printSummary(nextState);
+  }
+
+  return nextState;
+}
+
+async function main() {
+  const state = await runWatchdogOnce({ shouldPrintSummary: true });
+  if (state.result === "failed") {
+    process.exit(1);
+  }
+}
+
+async function collectHealth() {
+  const appServerReadyPid = await resolveReadyAppServerPid();
+  const bridge = readSharedBridgeHealth();
+  return {
+    appServer: {
+      ready: Boolean(appServerReadyPid),
+      readyPid: appServerReadyPid,
+      pidFromFile: readPidFile(appServerPidFile),
+    },
+    bridge: {
+      pid: bridge.pid,
+      alive: bridge.alive,
+      healthy: bridge.healthy,
+      heartbeatStatus: bridge.classification.status,
+      heartbeatUpdatedAt: normalizeText(bridge.classification.updatedAt),
+      lastError: normalizeText(bridge.heartbeat?.lastError),
+      consecutiveFailures: Number(bridge.heartbeat?.consecutiveFailures || 0),
+    },
+  };
+}
+
+function buildAlert({ result, actions, errorMessage, after, config }) {
+  if (result === "recovered") {
+    return {
+      kind: "recovered",
+      signature: `recovered:${actions.join("|")}`,
+      text: [
+        "后台守护刚自动恢复了共享链路。",
+        `动作: ${actions.join("；")}`,
+        `workspace: ${normalizeText(config.workspaceRoot) || "(unknown)"}`,
+        `readyz: ${after.appServer.ready ? "ok" : "down"}`,
+        "现在可以继续直接发微信消息。",
+      ].join("\n"),
+    };
+  }
+
+  if (result === "failed") {
+    return {
+      kind: "failed",
+      signature: [
+        "failed",
+        errorMessage,
+        after.appServer.ready ? "ready" : "down",
+        after.bridge.heartbeatStatus,
+        String(after.bridge.consecutiveFailures),
+      ].join("|"),
+      text: [
+        "后台守护刚发现共享链路异常，但这轮自动恢复没有完全成功。",
+        `readyz: ${after.appServer.ready ? "ok" : "down"}`,
+        `bridge: ${after.bridge.heartbeatStatus}`,
+        after.bridge.lastError ? `bridge error: ${after.bridge.lastError}` : "",
+        errorMessage ? `watchdog error: ${errorMessage}` : "",
+        `workspace: ${normalizeText(config.workspaceRoot) || "(unknown)"}`,
+        `日志: ${appServerLogFile} | ${bridgeLogFile}`,
+      ].filter(Boolean).join("\n"),
+    };
+  }
+
+  return null;
+}
+
+function shouldSendAlert(previousState, signature) {
+  const normalizedSignature = normalizeText(signature);
+  if (!normalizedSignature) {
+    return false;
+  }
+  const previousSignature = normalizeText(previousState.lastAlertSignature);
+  const previousAlertAtMs = Date.parse(normalizeText(previousState.lastAlertAt));
+  if (normalizedSignature !== previousSignature) {
+    return true;
+  }
+  if (!Number.isFinite(previousAlertAtMs)) {
+    return true;
+  }
+  return Date.now() - previousAlertAtMs >= ALERT_COOLDOWN_MS;
+}
+
+async function sendVisibleAlert(config, text) {
+  try {
+    const account = resolveSelectedAccount(config);
+    const sessionStore = new SessionStore({ filePath: config.sessionsFile });
+    const senderId = resolvePreferredSenderId({
+      config,
+      accountId: account.accountId,
+      sessionStore,
+    });
+    const workspaceRoot = resolvePreferredWorkspaceRoot({
+      config,
+      accountId: account.accountId,
+      senderId,
+      sessionStore,
+    });
+    const contextToken = loadPersistedContextTokens(config, account.accountId)?.[senderId] || "";
+    if (!senderId || !contextToken) {
+      return {
+        sent: false,
+        reason: "missing_sender_or_context_token",
+        senderId,
+        workspaceRoot,
+      };
+    }
+
+    const channelAdapter = createWeixinChannelAdapter(config);
+    await channelAdapter.sendText({
+      userId: senderId,
+      contextToken,
+      preserveBlock: true,
+      text,
+    });
+    return {
+      sent: true,
+      reason: "",
+      senderId,
+      workspaceRoot,
+    };
+  } catch (error) {
+    return {
+      sent: false,
+      reason: formatErrorMessage(error),
+      senderId: "",
+      workspaceRoot: "",
+    };
+  }
+}
+
+function printSummary(state) {
+  console.log(`result=${state.result}`);
+  console.log(`readyz=${state.after?.appServer?.ready ? "ok" : "down"}`);
+  console.log(`shared_app_server_pid=${state.after?.appServer?.readyPid || "missing"}`);
+  console.log(`shared_codeksei_pid=${state.after?.bridge?.pid || "missing"}`);
+  console.log(`shared_cyberboss_pid=${state.after?.bridge?.pid || "missing"}`);
+  console.log(`shared_bridge_heartbeat=${state.after?.bridge?.heartbeatStatus || "missing"}`);
+  console.log(`shared_bridge_heartbeat_at=${state.after?.bridge?.heartbeatUpdatedAt || "missing"}`);
+  if (Array.isArray(state.actions) && state.actions.length) {
+    console.log(`actions=${state.actions.join(" | ")}`);
+  }
+  if (normalizeText(state.error)) {
+    console.log(`error=${state.error}`);
+  }
+}
+
+function formatErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message || error.stack || String(error);
+  }
+  return String(error || "unknown error");
+}
+
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+module.exports = {
+  runWatchdogOnce,
+};
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(formatErrorMessage(error));
+    process.exit(1);
+  });
+}