@chrysb/alphaclaw 0.7.0 → 0.7.1

package/lib/public/js/components/watchdog-tab/terminal/use-terminal.js

@@ -0,0 +1,263 @@
+import { useEffect, useRef, useState } from "https://esm.sh/preact/hooks";
+import { closeWatchdogTerminalSession } from "../../../lib/api.js";
+import { showToast } from "../../toast.js";
+import {
+  ensureXtermStylesheet,
+  fitTerminalWhenVisible,
+  kWatchdogTerminalWsPath,
+  loadXtermModules,
+} from "../helpers.js";
+
+export const useWatchdogTerminal = ({
+  active = false,
+  panelRef = null,
+  hostRef = null,
+} = {}) => {
+  const [connectingTerminal, setConnectingTerminal] = useState(false);
+  const [terminalConnected, setTerminalConnected] = useState(false);
+  const [terminalEnded, setTerminalEnded] = useState(false);
+  const [terminalStatusText, setTerminalStatusText] = useState("");
+  const [terminalUiSettling, setTerminalUiSettling] = useState(false);
+  const [terminalSessionId, setTerminalSessionId] = useState("");
+  const [terminalReconnectToken, setTerminalReconnectToken] = useState(0);
+  const terminalInstanceRef = useRef(null);
+  const terminalFitAddonRef = useRef(null);
+  const terminalSocketRef = useRef(null);
+  const terminalSessionIdRef = useRef("");
+
+  useEffect(() => {
+    terminalSessionIdRef.current = String(terminalSessionId || "");
+  }, [terminalSessionId]);
+
+  useEffect(() => {
+    if (!active) return;
+    let cancelled = false;
+    let resizeTimer = null;
+    const setupTerminal = async () => {
+      try {
+        setConnectingTerminal(true);
+        ensureXtermStylesheet();
+        const [{ Terminal }, { FitAddon }] = await loadXtermModules();
+        if (cancelled) return;
+        if (!terminalInstanceRef.current && hostRef?.current) {
+          const terminal = new Terminal({
+            cursorBlink: true,
+            fontFamily:
+              "ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, Liberation Mono, monospace",
+            fontSize: 12,
+            lineHeight: 1.2,
+            letterSpacing: 0,
+            convertEol: false,
+            theme: {
+              background: "rgba(0, 0, 0, 0)",
+              foreground: "#d1d5db",
+              cursor: "#67e8f9",
+            },
+          });
+          const fitAddon = new FitAddon();
+          terminal.loadAddon(fitAddon);
+          terminal.open(hostRef.current);
+          fitAddon.fit();
+          terminal.attachCustomKeyEventHandler((event) => {
+            if (event.type !== "keydown") return true;
+            const pressedKey = String(event.key || "").toLowerCase();
+            if (
+              !event.metaKey ||
+              event.ctrlKey ||
+              event.altKey ||
+              event.shiftKey
+            ) {
+              return true;
+            }
+            if (pressedKey !== "k") return true;
+            event.preventDefault();
+            terminal.clear();
+            return false;
+          });
+          window.setTimeout(() => {
+            terminalFitAddonRef.current?.fit();
+          }, 120);
+          terminal.focus();
+          terminal.onData((data) => {
+            const socket = terminalSocketRef.current;
+            if (!socket || socket.readyState !== 1) return;
+            socket.send(
+              JSON.stringify({
+                type: "input",
+                data,
+              }),
+            );
+          });
+          terminalInstanceRef.current = terminal;
+          terminalFitAddonRef.current = fitAddon;
+        }
+
+        const existingSocket = terminalSocketRef.current;
+        if (existingSocket && existingSocket.readyState <= 1) {
+          setConnectingTerminal(false);
+          setTerminalUiSettling(false);
+          fitTerminalWhenVisible({
+            panel: panelRef?.current,
+            fitAddon: terminalFitAddonRef.current,
+          });
+          terminalInstanceRef.current?.focus();
+          return;
+        }
+
+        const protocol = window.location.protocol === "https:" ? "wss" : "ws";
+        const socket = new WebSocket(
+          `${protocol}://${window.location.host}${kWatchdogTerminalWsPath}`,
+        );
+        terminalSocketRef.current = socket;
+        socket.onopen = () => {
+          if (cancelled) return;
+          setConnectingTerminal(false);
+          setTerminalUiSettling(false);
+          setTerminalConnected(true);
+          setTerminalEnded(false);
+          setTerminalStatusText("Connected");
+          fitTerminalWhenVisible({
+            panel: panelRef?.current,
+            fitAddon: terminalFitAddonRef.current,
+          });
+          terminalInstanceRef.current?.focus();
+        };
+        socket.onmessage = (event) => {
+          let payload = null;
+          try {
+            payload = JSON.parse(String(event.data || ""));
+          } catch {
+            return;
+          }
+          const type = String(payload?.type || "");
+          if (type === "session") {
+            const sessionId = String(payload?.session?.id || "");
+            if (sessionId) setTerminalSessionId(sessionId);
+            setTerminalStatusText("Connected");
+            return;
+          }
+          if (type === "output") {
+            terminalInstanceRef.current?.write(String(payload?.data || ""));
+            return;
+          }
+          if (type === "exit") {
+            setTerminalEnded(true);
+            setTerminalConnected(false);
+            setTerminalStatusText("Session ended");
+          }
+        };
+        socket.onclose = () => {
+          if (cancelled) return;
+          setConnectingTerminal(false);
+          setTerminalUiSettling(false);
+          setTerminalConnected(false);
+          if (!terminalEnded) setTerminalStatusText("Disconnected");
+        };
+        socket.onerror = () => {
+          if (cancelled) return;
+          setConnectingTerminal(false);
+          setTerminalUiSettling(false);
+          setTerminalConnected(false);
+          setTerminalStatusText("Connection error");
+          showToast("Watchdog terminal connection failed", "error");
+        };
+      } catch {
+        if (cancelled) return;
+        setConnectingTerminal(false);
+        setTerminalUiSettling(false);
+        setTerminalConnected(false);
+        setTerminalStatusText("Terminal failed to load");
+        showToast("Could not initialize terminal", "error");
+      }
+    };
+    setupTerminal();
+
+    const onResize = () => {
+      if (resizeTimer) window.clearTimeout(resizeTimer);
+      resizeTimer = window.setTimeout(() => {
+        fitTerminalWhenVisible({
+          panel: panelRef?.current,
+          fitAddon: terminalFitAddonRef.current,
+        });
+      }, 60);
+    };
+    window.addEventListener("resize", onResize);
+    return () => {
+      cancelled = true;
+      if (resizeTimer) window.clearTimeout(resizeTimer);
+      window.removeEventListener("resize", onResize);
+    };
+  }, [active, terminalEnded, terminalReconnectToken, panelRef, hostRef]);
+
+  useEffect(
+    () => () => {
+      const activeSessionId = String(terminalSessionIdRef.current || "");
+      if (activeSessionId) {
+        closeWatchdogTerminalSession(activeSessionId).catch(() => {});
+      }
+      const socket = terminalSocketRef.current;
+      if (socket && socket.readyState <= 1) socket.close();
+      terminalSocketRef.current = null;
+      terminalFitAddonRef.current = null;
+      if (terminalInstanceRef.current) {
+        terminalInstanceRef.current.dispose();
+      }
+      terminalInstanceRef.current = null;
+    },
+    [],
+  );
+
+  const prepareForActivate = () => {
+    const hasOpenSocket =
+      !!terminalSocketRef.current && terminalSocketRef.current.readyState <= 1;
+    if (hasOpenSocket && terminalConnected) {
+      setTerminalUiSettling(false);
+      setConnectingTerminal(false);
+      return;
+    }
+    setTerminalUiSettling(true);
+    setConnectingTerminal(true);
+  };
+
+  const clearSettling = () => {
+    setTerminalUiSettling(false);
+  };
+
+  const restartSession = () => {
+    const activeSessionId = String(terminalSessionId || "");
+    if (activeSessionId) {
+      closeWatchdogTerminalSession(activeSessionId).catch(() => {});
+    }
+    const socket = terminalSocketRef.current;
+    if (socket && socket.readyState <= 1) socket.close();
+    terminalSocketRef.current = null;
+    terminalInstanceRef.current?.clear();
+    setConnectingTerminal(true);
+    setTerminalUiSettling(true);
+    setTerminalEnded(false);
+    setTerminalConnected(false);
+    setTerminalSessionId("");
+    setTerminalStatusText("Connecting...");
+    setTerminalReconnectToken((value) => value + 1);
+  };
+
+  const fitNow = () => {
+    fitTerminalWhenVisible({
+      panel: panelRef?.current,
+      fitAddon: terminalFitAddonRef.current,
+    });
+  };
+
+  return {
+    connectingTerminal,
+    terminalConnected,
+    terminalEnded,
+    terminalStatusText,
+    terminalUiSettling,
+    terminalInstanceRef,
+    fitNow,
+    prepareForActivate,
+    clearSettling,
+    restartSession,
+  };
+};

package/lib/public/js/components/watchdog-tab/use-watchdog-tab.js

@@ -0,0 +1,55 @@
+import { useWatchdogConsole } from "./console/use-console.js";
+import { useWatchdogIncidents } from "./incidents/use-incidents.js";
+import { useWatchdogResources } from "./resources/use-resources.js";
+import { useWatchdogSettings } from "./settings/use-settings.js";
+
+export const useWatchdogTab = ({
+  watchdogStatus = null,
+  onRefreshStatuses = () => {},
+  restartSignal = 0,
+} = {}) => {
+  const currentWatchdogStatus = watchdogStatus || {};
+  const incidents = useWatchdogIncidents({
+    restartSignal,
+    onRefreshStatuses,
+  });
+  const resources = useWatchdogResources();
+  const settings = useWatchdogSettings({
+    watchdogStatus: currentWatchdogStatus,
+    onRefreshStatuses,
+    onRefreshIncidents: incidents.refreshEvents,
+  });
+  const consoleState = useWatchdogConsole();
+
+  return {
+    currentWatchdogStatus,
+    events: incidents.events,
+    refreshEvents: incidents.refreshEvents,
+    resources: resources.resources,
+    memoryExpanded: resources.memoryExpanded,
+    setMemoryExpanded: resources.setMemoryExpanded,
+    settings: settings.settings,
+    savingSettings: settings.savingSettings,
+    onToggleAutoRepair: settings.onToggleAutoRepair,
+    onToggleNotifications: settings.onToggleNotifications,
+    onRepair: settings.onRepair,
+    isRepairInProgress: settings.isRepairInProgress,
+    logs: consoleState.logs,
+    loadingLogs: consoleState.loadingLogs,
+    stickToBottom: consoleState.stickToBottom,
+    setStickToBottom: consoleState.setStickToBottom,
+    activeConsoleTab: consoleState.activeConsoleTab,
+    handleSelectConsoleTab: consoleState.handleSelectConsoleTab,
+    connectingTerminal: consoleState.connectingTerminal,
+    terminalConnected: consoleState.terminalConnected,
+    terminalEnded: consoleState.terminalEnded,
+    terminalStatusText: consoleState.terminalStatusText,
+    terminalUiSettling: consoleState.terminalUiSettling,
+    onRestartTerminalSession: consoleState.onRestartTerminalSession,
+    logsPanelHeightPx: consoleState.logsPanelHeightPx,
+    logsRef: consoleState.logsRef,
+    terminalPanelRef: consoleState.terminalPanelRef,
+    terminalHostRef: consoleState.terminalHostRef,
+    terminalInstanceRef: consoleState.terminalInstanceRef,
+  };
+};

package/lib/public/js/lib/api.js

@@ -365,6 +365,45 @@ export async function fetchWatchdogLogs(tail = 65536) {
   return res.text();
 }
 
+export async function createWatchdogTerminalSession() {
+  const res = await authFetch("/api/watchdog/terminal/session", {
+    method: "POST",
+  });
+  return parseJsonOrThrow(res, "Could not start watchdog terminal");
+}
+
+export async function fetchWatchdogTerminalOutput(sessionId, cursor = 0) {
+  const params = new URLSearchParams({
+    sessionId: String(sessionId || ""),
+    cursor: String(cursor || 0),
+  });
+  const res = await authFetch(`/api/watchdog/terminal/output?${params.toString()}`);
+  return parseJsonOrThrow(res, "Could not read watchdog terminal output");
+}
+
+export async function sendWatchdogTerminalInput(sessionId, input = "") {
+  const res = await authFetch("/api/watchdog/terminal/input", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      sessionId: String(sessionId || ""),
+      input: String(input || ""),
+    }),
+  });
+  return parseJsonOrThrow(res, "Could not send watchdog terminal input");
+}
+
+export async function closeWatchdogTerminalSession(sessionId) {
+  const res = await authFetch("/api/watchdog/terminal/close", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      sessionId: String(sessionId || ""),
+    }),
+  });
+  return parseJsonOrThrow(res, "Could not close watchdog terminal");
+}
+
 export async function triggerWatchdogRepair() {
   const res = await authFetch("/api/watchdog/repair", { method: "POST" });
   return parseJsonOrThrow(res, "Could not trigger watchdog repair");

package/lib/server/init/register-server-routes.js

@@ -0,0 +1,239 @@
+const { registerAuthRoutes } = require("../routes/auth");
+const { registerPageRoutes } = require("../routes/pages");
+const { registerModelRoutes } = require("../routes/models");
+const { registerOnboardingRoutes } = require("../routes/onboarding");
+const { registerSystemRoutes } = require("../routes/system");
+const { registerPairingRoutes } = require("../routes/pairings");
+const { registerCodexRoutes } = require("../routes/codex");
+const { registerGoogleRoutes } = require("../routes/google");
+const { registerBrowseRoutes } = require("../routes/browse");
+const { registerProxyRoutes } = require("../routes/proxy");
+const { registerTelegramRoutes } = require("../routes/telegram");
+const { registerWebhookRoutes } = require("../routes/webhooks");
+const { registerWatchdogRoutes } = require("../routes/watchdog");
+const { registerUsageRoutes } = require("../routes/usage");
+const { registerGmailRoutes } = require("../routes/gmail");
+const { registerDoctorRoutes } = require("../routes/doctor");
+const { registerAgentRoutes } = require("../routes/agents");
+const { registerCronRoutes } = require("../routes/cron");
+
+const registerServerRoutes = ({
+  app,
+  fs,
+  constants,
+  loginThrottle,
+  shellCmd,
+  clawCmd,
+  gogCmd,
+  gatewayEnv,
+  parseJsonFromNoisyOutput,
+  normalizeOnboardingModels,
+  authProfiles,
+  readEnvFile,
+  writeEnvFile,
+  reloadEnv,
+  isOnboarded,
+  isGatewayRunning,
+  resolveGithubRepoUrl,
+  resolveModelProvider,
+  ensureGatewayProxyConfig,
+  getBaseUrl,
+  startGateway,
+  syncChannelConfig,
+  getChannelStatus,
+  openclawVersionService,
+  alphaclawVersionService,
+  restartGateway,
+  restartRequiredState,
+  topicRegistry,
+  createPkcePair,
+  parseCodexAuthorizationInput,
+  getCodexAccountId,
+  readGoogleCredentials,
+  getApiEnableUrl,
+  telegramApi,
+  doSyncPromptFiles,
+  getRequests,
+  getRequestById,
+  getHookSummaries,
+  deleteRequestsByHook,
+  watchdog,
+  getRecentEvents,
+  readLogTail,
+  watchdogTerminal,
+  getDailySummary,
+  getSessionsList,
+  getSessionDetail,
+  getSessionTimeSeries,
+  cronService,
+  doctorService,
+  agentsService,
+  operationEvents,
+  proxy,
+  getGatewayUrl,
+  SETUP_API_PREFIXES,
+  webhookMiddleware,
+}) => {
+  const { requireAuth, isAuthorizedRequest } = registerAuthRoutes({
+    app,
+    loginThrottle,
+  });
+
+  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,
+  });
+  registerTelegramRoutes({
+    app,
+    telegramApi,
+    syncPromptFiles: doSyncPromptFiles,
+    shellCmd,
+  });
+  registerWebhookRoutes({
+    app,
+    fs,
+    constants,
+    getBaseUrl,
+    shellCmd,
+    webhooksDb: {
+      getRequests,
+      getRequestById,
+      getHookSummaries,
+      deleteRequestsByHook,
+    },
+    restartRequiredState,
+  });
+  registerWatchdogRoutes({
+    app,
+    requireAuth,
+    watchdog,
+    getRecentEvents,
+    readLogTail,
+    watchdogTerminal,
+  });
+  registerUsageRoutes({
+    app,
+    requireAuth,
+    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,
+  });
+
+  return {
+    requireAuth,
+    isAuthorizedRequest,
+    gmailWatchService,
+  };
+};
+
+module.exports = {
+  registerServerRoutes,
+};

package/lib/server/init/runtime-init.js

@@ -0,0 +1,44 @@
+const initializeServerRuntime = ({
+  fs,
+  constants,
+  startEnvWatcher,
+  attachGatewaySignalHandlers,
+  cleanupStaleImportTempDirs,
+  migrateManagedInternalFiles,
+}) => {
+  startEnvWatcher();
+  attachGatewaySignalHandlers();
+  cleanupStaleImportTempDirs();
+  migrateManagedInternalFiles({
+    fs,
+    openclawDir: constants.OPENCLAW_DIR,
+  });
+};
+
+const initializeServerDatabases = ({
+  constants,
+  initWebhooksDb,
+  initWatchdogDb,
+  initUsageDb,
+  initDoctorDb,
+}) => {
+  initWebhooksDb({
+    rootDir: constants.kRootDir,
+    pruneDays: constants.kWebhookPruneDays,
+  });
+  initWatchdogDb({
+    rootDir: constants.kRootDir,
+    pruneDays: constants.kWatchdogLogRetentionDays,
+  });
+  initUsageDb({
+    rootDir: constants.kRootDir,
+  });
+  initDoctorDb({
+    rootDir: constants.kRootDir,
+  });
+};
+
+module.exports = {
+  initializeServerRuntime,
+  initializeServerDatabases,
+};

package/lib/server/init/server-lifecycle.js

@@ -0,0 +1,55 @@
+const startServerLifecycle = ({
+  server,
+  PORT,
+  isOnboarded,
+  runOnboardedBootSequence,
+  doSyncPromptFiles,
+  reloadEnv,
+  syncChannelConfig,
+  readEnvFile,
+  ensureGatewayProxyConfig,
+  resolveSetupUrl,
+  startGateway,
+  watchdog,
+  gmailWatchService,
+}) => {
+  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");
+    }
+  });
+};
+
+const registerServerShutdown = ({ gmailWatchService, watchdogTerminal }) => {
+  const shutdownGmailWatchService = async () => {
+    try {
+      await gmailWatchService.stop();
+    } catch {}
+    watchdogTerminal.disposeSession();
+  };
+
+  process.on("SIGTERM", () => {
+    shutdownGmailWatchService();
+  });
+  process.on("SIGINT", () => {
+    shutdownGmailWatchService();
+  });
+};
+
+module.exports = {
+  startServerLifecycle,
+  registerServerShutdown,
+};