@chrysb/alphaclaw 0.7.0 → 0.7.2-beta.0

package/lib/server/watchdog-terminal.js

@@ -0,0 +1,262 @@
+const crypto = require("crypto");
+const { spawn, spawnSync } = require("child_process");
+
+const kSessionIdleTtlMs = 15 * 60 * 1000;
+const kCleanupIntervalMs = 30 * 1000;
+const kMaxBufferedOutputChars = 200000;
+
+const hasScriptCommand = () => {
+  try {
+    const result = spawnSync("sh", ["-lc", "command -v script >/dev/null 2>&1"], {
+      stdio: "ignore",
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+};
+
+const createShellProcess = ({
+  shell = "/bin/bash",
+  cwd = process.cwd(),
+  env = {},
+  preferPty = false,
+} = {}) => {
+  if (preferPty && process.platform === "darwin") {
+    return spawn("script", ["-q", "/dev/null", shell, "-i"], {
+      cwd,
+      env: { ...env, TERM: env.TERM || "xterm-256color" },
+      stdio: "pipe",
+    });
+  }
+  if (preferPty) {
+    return spawn("script", ["-q", "-f", "-c", `${shell} -i`, "/dev/null"], {
+      cwd,
+      env: { ...env, TERM: env.TERM || "xterm-256color" },
+      stdio: "pipe",
+    });
+  }
+  return spawn(shell, ["-i"], {
+    cwd,
+    env: { ...env, TERM: env.TERM || "xterm-256color" },
+    stdio: "pipe",
+  });
+};
+
+const createWatchdogTerminalService = ({
+  cwd = process.cwd(),
+  shell = process.env.SHELL || "/bin/bash",
+  env = process.env,
+} = {}) => {
+  let session = null;
+  const preferPty = hasScriptCommand();
+
+  const notifySubscribers = (event) => {
+    if (!session?.subscribers?.size) return;
+    session.subscribers.forEach((subscriber) => {
+      try {
+        subscriber(event);
+      } catch {}
+    });
+  };
+
+  const appendOutput = (chunk = "") => {
+    if (!session || !chunk) return;
+    const chunkText = String(chunk);
+    session.output += chunkText;
+    session.endCursor += chunkText.length;
+    if (session.output.length > kMaxBufferedOutputChars) {
+      const trimCount = session.output.length - kMaxBufferedOutputChars;
+      session.output = session.output.slice(trimCount);
+      session.startCursor += trimCount;
+    }
+    notifySubscribers({ type: "output", data: chunkText });
+  };
+
+  const markActive = () => {
+    if (!session) return;
+    session.lastActiveAtMs = Date.now();
+  };
+
+  const createOrReuseSession = () => {
+    if (session && !session.ended) {
+      markActive();
+      return {
+        id: session.id,
+        shell,
+        cwd,
+        ended: false,
+      };
+    }
+    if (session && session.ended) session = null;
+
+    const proc = createShellProcess({ shell, cwd, env, preferPty });
+    const sessionId = crypto.randomUUID();
+    session = {
+      id: sessionId,
+      proc,
+      output: "",
+      startCursor: 0,
+      endCursor: 0,
+      ended: false,
+      exitCode: null,
+      signal: null,
+      lastActiveAtMs: Date.now(),
+      subscribers: new Set(),
+    };
+
+    proc.stdout.setEncoding("utf8");
+    proc.stderr.setEncoding("utf8");
+    proc.stdout.on("data", (chunk) => appendOutput(chunk));
+    proc.stderr.on("data", (chunk) => appendOutput(chunk));
+    proc.on("close", (code, signal) => {
+      if (!session || session.id !== sessionId) return;
+      session.ended = true;
+      session.exitCode = code;
+      session.signal = signal;
+      const endLine = `\r\n[terminal exited${code != null ? ` with code ${code}` : ""}${signal ? ` (${signal})` : ""}]\r\n`;
+      appendOutput(endLine);
+      notifySubscribers({
+        type: "exit",
+        code,
+        signal,
+      });
+    });
+
+    return {
+      id: session.id,
+      shell,
+      cwd,
+      ended: false,
+    };
+  };
+
+  const subscribe = ({
+    sessionId = "",
+    onEvent = () => {},
+    replayBuffer = true,
+    tailLines = 0,
+  } = {}) => {
+    if (!session || String(session.id) !== String(sessionId || "")) {
+      return {
+        ok: false,
+        error: "Terminal session not found",
+        unsubscribe: () => {},
+      };
+    }
+    markActive();
+    const subscriber = (event) => onEvent(event);
+    session.subscribers.add(subscriber);
+    if (replayBuffer && session.output) {
+      onEvent({ type: "output", data: session.output });
+    } else if (!replayBuffer && Number(tailLines || 0) > 0 && !session.ended) {
+      const lines = String(session.output || "").split("\n");
+      const count = Math.max(1, Math.floor(Number(tailLines || 0)));
+      const tail = lines.slice(-count).join("\n");
+      if (tail.trim()) onEvent({ type: "output", data: tail });
+    }
+    if (session.ended) {
+      onEvent({
+        type: "exit",
+        code: session.exitCode,
+        signal: session.signal,
+      });
+    }
+    return {
+      ok: true,
+      unsubscribe: () => {
+        if (!session) return;
+        session.subscribers.delete(subscriber);
+      },
+    };
+  };
+
+  const readOutput = ({ sessionId = "", cursor = 0 } = {}) => {
+    if (!session || String(session.id) !== String(sessionId || "")) {
+      return {
+        found: false,
+        output: "",
+        cursor: 0,
+        startCursor: 0,
+        endCursor: 0,
+        ended: true,
+      };
+    }
+    markActive();
+    const requestedCursor = Number(cursor);
+    const safeCursor = Number.isFinite(requestedCursor)
+      ? Math.max(0, Math.floor(requestedCursor))
+      : 0;
+    const effectiveCursor =
+      safeCursor < session.startCursor || safeCursor > session.endCursor
+        ? session.startCursor
+        : safeCursor;
+    const sliceIndex = Math.max(0, effectiveCursor - session.startCursor);
+    return {
+      found: true,
+      output: session.output.slice(sliceIndex),
+      cursor: session.endCursor,
+      startCursor: session.startCursor,
+      endCursor: session.endCursor,
+      ended: !!session.ended,
+      exitCode: session.exitCode,
+      signal: session.signal,
+    };
+  };
+
+  const writeInput = ({ sessionId = "", input = "" } = {}) => {
+    if (!session || String(session.id) !== String(sessionId || "")) {
+      return { ok: false, error: "Terminal session not found" };
+    }
+    if (session.ended || !session.proc.stdin.writable) {
+      return { ok: false, error: "Terminal session has ended" };
+    }
+    markActive();
+    session.proc.stdin.write(String(input || ""));
+    return { ok: true };
+  };
+
+  const closeSession = ({ sessionId = "" } = {}) => {
+    if (!session || String(session.id) !== String(sessionId || "")) {
+      return { ok: true };
+    }
+    const targetProc = session.proc;
+    session = null;
+    try {
+      targetProc.kill("SIGTERM");
+    } catch {}
+    return { ok: true };
+  };
+
+  const disposeSession = () => {
+    if (!session) return;
+    const targetProc = session.proc;
+    session = null;
+    try {
+      targetProc.kill("SIGTERM");
+    } catch {}
+  };
+
+  const cleanupTimer = setInterval(() => {
+    if (!session || session.ended) return;
+    const idleForMs = Date.now() - Number(session.lastActiveAtMs || 0);
+    if (idleForMs < kSessionIdleTtlMs) return;
+    try {
+      session.proc.kill("SIGTERM");
+    } catch {}
+  }, kCleanupIntervalMs);
+  cleanupTimer.unref?.();
+
+  return {
+    createOrReuseSession,
+    subscribe,
+    readOutput,
+    writeInput,
+    closeSession,
+    disposeSession,
+  };
+};
+
+module.exports = {
+  createWatchdogTerminalService,
+};

package/lib/server.js

@@ -107,39 +107,36 @@ const { createDiscordApi } = require("./server/discord-api");
 const { createSlackApi } = require("./server/slack-api");
 const { createWatchdogNotifier } = require("./server/watchdog-notify");
 const { createWatchdog } = require("./server/watchdog");
+const { createWatchdogTerminalService } = require("./server/watchdog-terminal");
+const {
+  createWatchdogTerminalWsBridge,
+} = require("./server/watchdog-terminal-ws");
 const { createDoctorService } = require("./server/doctor/service");
 const { createAgentsService } = require("./server/agents/service");
 const { createOperationEventsService } = require("./server/operation-events");
 const { runOnboardedBootSequence } = require("./server/startup");
 const { createCronService } = require("./server/cron-service");
-
-const { registerAuthRoutes } = require("./server/routes/auth");
-const { registerPageRoutes } = require("./server/routes/pages");
-const { registerModelRoutes } = require("./server/routes/models");
-const { registerOnboardingRoutes } = require("./server/routes/onboarding");
-const { registerSystemRoutes } = require("./server/routes/system");
-const { registerPairingRoutes } = require("./server/routes/pairings");
-const { registerCodexRoutes } = require("./server/routes/codex");
-const { registerGoogleRoutes } = require("./server/routes/google");
-const { registerBrowseRoutes } = require("./server/routes/browse");
-const { registerProxyRoutes } = require("./server/routes/proxy");
-const { registerTelegramRoutes } = require("./server/routes/telegram");
-const { registerWebhookRoutes } = require("./server/routes/webhooks");
-const { registerWatchdogRoutes } = require("./server/routes/watchdog");
-const { registerUsageRoutes } = require("./server/routes/usage");
-const { registerGmailRoutes } = require("./server/routes/gmail");
-const { registerDoctorRoutes } = require("./server/routes/doctor");
-const { registerAgentRoutes } = require("./server/routes/agents");
-const { registerCronRoutes } = require("./server/routes/cron");
+const {
+  initializeServerRuntime,
+  initializeServerDatabases,
+} = require("./server/init/runtime-init");
+const {
+  registerServerRoutes,
+} = require("./server/init/register-server-routes");
+const {
+  startServerLifecycle,
+  registerServerShutdown,
+} = require("./server/init/server-lifecycle");
 
 const { PORT, kTrustProxyHops, SETUP_API_PREFIXES } = constants;
 
-startEnvWatcher();
-attachGatewaySignalHandlers();
-cleanupStaleImportTempDirs();
-migrateManagedInternalFiles({
+initializeServerRuntime({
   fs,
-  openclawDir: constants.OPENCLAW_DIR,
+  constants,
+  startEnvWatcher,
+  attachGatewaySignalHandlers,
+  cleanupStaleImportTempDirs,
+  migrateManagedInternalFiles,
 });
 
 const app = express();
@@ -194,118 +191,19 @@ const cronService = createCronService({
   getSessionUsageByKeyPattern,
 });
 
-const { requireAuth, isAuthorizedRequest } = registerAuthRoutes({
-  app,
-  loginThrottle,
-});
 app.use(express.static(path.join(__dirname, "public")));
-initWebhooksDb({
-  rootDir: constants.kRootDir,
-  pruneDays: constants.kWebhookPruneDays,
-});
-initWatchdogDb({
-  rootDir: constants.kRootDir,
-  pruneDays: constants.kWatchdogLogRetentionDays,
-});
-initUsageDb({
-  rootDir: constants.kRootDir,
-});
-initDoctorDb({
-  rootDir: constants.kRootDir,
+initializeServerDatabases({
+  constants,
+  initWebhooksDb,
+  initWatchdogDb,
+  initUsageDb,
+  initDoctorDb,
 });
 const webhookMiddleware = createWebhookMiddleware({
   getGatewayUrl,
   insertRequest,
   maxPayloadBytes: constants.kMaxPayloadBytes,
 });
-
-registerPageRoutes({ app, requireAuth, isGatewayRunning });
-registerModelRoutes({
-  app,
-  shellCmd,
-  gatewayEnv,
-  parseJsonFromNoisyOutput,
-  normalizeOnboardingModels,
-  authProfiles,
-  readEnvFile,
-  writeEnvFile,
-  reloadEnv,
-});
-registerOnboardingRoutes({
-  app,
-  fs,
-  constants,
-  shellCmd,
-  gatewayEnv,
-  readEnvFile,
-  writeEnvFile,
-  reloadEnv,
-  isOnboarded,
-  resolveGithubRepoUrl,
-  resolveModelProvider,
-  hasCodexOauthProfile: authProfiles.hasCodexOauthProfile,
-  authProfiles,
-  ensureGatewayProxyConfig,
-  getBaseUrl,
-  startGateway,
-});
-registerSystemRoutes({
-  app,
-  fs,
-  readEnvFile,
-  writeEnvFile,
-  reloadEnv,
-  kKnownVars: constants.kKnownVars,
-  kKnownKeys: constants.kKnownKeys,
-  kSystemVars: constants.kSystemVars,
-  syncChannelConfig,
-  isGatewayRunning,
-  isOnboarded,
-  getChannelStatus,
-  openclawVersionService,
-  alphaclawVersionService,
-  clawCmd,
-  restartGateway,
-  OPENCLAW_DIR: constants.OPENCLAW_DIR,
-  restartRequiredState,
-  topicRegistry,
-  authProfiles,
-});
-registerBrowseRoutes({
-  app,
-  fs,
-  kRootDir: constants.OPENCLAW_DIR,
-});
-registerPairingRoutes({ app, clawCmd, isOnboarded });
-registerCodexRoutes({
-  app,
-  createPkcePair,
-  parseCodexAuthorizationInput,
-  getCodexAccountId,
-  authProfiles,
-});
-registerGoogleRoutes({
-  app,
-  fs,
-  isGatewayRunning,
-  gogCmd,
-  getBaseUrl,
-  readGoogleCredentials,
-  getApiEnableUrl,
-  constants,
-});
-const gmailWatchService = registerGmailRoutes({
-  app,
-  fs,
-  constants,
-  gogCmd,
-  getBaseUrl,
-  readGoogleCredentials,
-  readEnvFile,
-  writeEnvFile,
-  reloadEnv,
-  restartRequiredState,
-});
 const telegramApi = createTelegramApi(() => process.env.TELEGRAM_BOT_TOKEN);
 const discordApi = createDiscordApi(() => process.env.DISCORD_BOT_TOKEN);
 const slackApi = createSlackApi(() => process.env.SLACK_BOT_TOKEN);
@@ -320,6 +218,9 @@ const watchdog = createWatchdog({
   reloadEnv,
   resolveSetupUrl,
 });
+const watchdogTerminal = createWatchdogTerminalService({
+  cwd: constants.OPENCLAW_DIR,
+});
 const doctorService = createDoctorService({
   clawCmd,
   listDoctorRuns,
@@ -353,116 +254,89 @@ const doSyncPromptFiles = () => {
   });
   installGogCliSkill({ fs, openclawDir: constants.OPENCLAW_DIR });
 };
-registerTelegramRoutes({
-  app,
-  telegramApi,
-  syncPromptFiles: doSyncPromptFiles,
-  shellCmd,
-});
-registerWebhookRoutes({
+const { isAuthorizedRequest, gmailWatchService } = registerServerRoutes({
   app,
   fs,
   constants,
-  getBaseUrl,
+  loginThrottle,
   shellCmd,
-  webhooksDb: {
-    getRequests,
-    getRequestById,
-    getHookSummaries,
-    deleteRequestsByHook,
-  },
+  clawCmd,
+  gogCmd,
+  gatewayEnv,
+  parseJsonFromNoisyOutput,
+  normalizeOnboardingModels,
+  authProfiles,
+  readEnvFile,
+  writeEnvFile,
+  reloadEnv,
+  isOnboarded,
+  isGatewayRunning,
+  resolveGithubRepoUrl,
+  resolveModelProvider,
+  ensureGatewayProxyConfig,
+  getBaseUrl,
+  startGateway,
+  syncChannelConfig,
+  getChannelStatus,
+  openclawVersionService,
+  alphaclawVersionService,
+  restartGateway,
   restartRequiredState,
-});
-registerWatchdogRoutes({
-  app,
-  requireAuth,
+  topicRegistry,
+  createPkcePair,
+  parseCodexAuthorizationInput,
+  getCodexAccountId,
+  readGoogleCredentials,
+  getApiEnableUrl,
+  telegramApi,
+  doSyncPromptFiles,
+  getRequests,
+  getRequestById,
+  getHookSummaries,
+  deleteRequestsByHook,
   watchdog,
   getRecentEvents,
   readLogTail,
-});
-registerUsageRoutes({
-  app,
-  requireAuth,
+  watchdogTerminal,
   getDailySummary,
   getSessionsList,
   getSessionDetail,
   getSessionTimeSeries,
-});
-registerCronRoutes({
-  app,
-  requireAuth,
   cronService,
-});
-registerDoctorRoutes({
-  app,
-  requireAuth,
   doctorService,
-});
-registerAgentRoutes({
-  app,
   agentsService,
-  restartRequiredState,
   operationEvents,
-});
-registerProxyRoutes({
-  app,
   proxy,
   getGatewayUrl,
   SETUP_API_PREFIXES,
-  requireAuth,
   webhookMiddleware,
 });
 
 const server = http.createServer(app);
-server.on("upgrade", (req, socket, head) => {
-  const requestUrl = new URL(
-    req.url || "/",
-    `http://${req.headers.host || "localhost"}`,
-  );
-  if (requestUrl.pathname.startsWith("/openclaw")) {
-    const upgradeReq = {
-      headers: req.headers,
-      path: requestUrl.pathname,
-      query: Object.fromEntries(requestUrl.searchParams.entries()),
-    };
-    if (!isAuthorizedRequest(upgradeReq)) {
-      socket.write(
-        "HTTP/1.1 401 Unauthorized\r\nContent-Type: text/plain\r\nConnection: close\r\n\r\nUnauthorized",
-      );
-      socket.destroy();
-      return;
-    }
-  }
-  proxy.ws(req, socket, head, { target: getGatewayUrl() });
-});
-
-server.listen(PORT, "0.0.0.0", () => {
-  console.log(`[alphaclaw] Express listening on :${PORT}`);
-  if (isOnboarded()) {
-    runOnboardedBootSequence({
-      doSyncPromptFiles,
-      reloadEnv,
-      syncChannelConfig,
-      readEnvFile,
-      ensureGatewayProxyConfig,
-      resolveSetupUrl,
-      startGateway,
-      watchdog,
-      gmailWatchService,
-    });
-  } else {
-    console.log("[alphaclaw] Awaiting onboarding via Setup UI");
-  }
+createWatchdogTerminalWsBridge({
+  server,
+  proxy,
+  getGatewayUrl,
+  isAuthorizedRequest,
+  watchdogTerminal,
 });
 
-const shutdownGmailWatchService = async () => {
-  try {
-    await gmailWatchService.stop();
-  } catch {}
-};
-process.on("SIGTERM", () => {
-  shutdownGmailWatchService();
+startServerLifecycle({
+  server,
+  PORT,
+  isOnboarded,
+  runOnboardedBootSequence,
+  doSyncPromptFiles,
+  reloadEnv,
+  syncChannelConfig,
+  readEnvFile,
+  ensureGatewayProxyConfig,
+  resolveSetupUrl,
+  startGateway,
+  watchdog,
+  gmailWatchService,
 });
-process.on("SIGINT", () => {
-  shutdownGmailWatchService();
+registerServerShutdown({
+  gmailWatchService,
+  watchdogTerminal,
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.7.0",
+  "version": "0.7.2-beta.0",
   "publishConfig": {
     "access": "public"
   },
@@ -31,7 +31,8 @@
   "dependencies": {
     "express": "^4.21.0",
     "http-proxy": "^1.18.1",
-    "openclaw": "2026.3.11"
+    "openclaw": "2026.3.11",
+    "ws": "^8.19.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.18",