claude-smart 0.2.48 → 0.2.50

package/plugin/scripts/codex-hook.js

@@ -3,18 +3,31 @@
 
 const { spawn, spawnSync } = require("node:child_process");
 const fs = require("node:fs");
-const http = require("node:http");
 const os = require("node:os");
 const path = require("node:path");
 
 const HOME = os.homedir();
 const STATE_DIR = path.join(HOME, ".claude-smart");
 const REFLEXIO_DIR = path.join(HOME, ".reflexio");
-const DEFAULT_BACKEND_PORT = 8071;
-const FALLBACK_BACKEND_PORT = 8072;
-const DASHBOARD_PORT = 3001;
+const SERVICE_SCRIPT_TIMEOUT_MS = parsePositiveInteger(
+  process.env.CLAUDE_SMART_SERVICE_SCRIPT_TIMEOUT_MS,
+  45_000,
+);
+const DEFAULT_BACKEND_PORT = parsePort(process.env.BACKEND_PORT, 8071);
+const DEFAULT_EMBEDDING_PORT = parsePort(process.env.EMBEDDING_PORT, 8072);
+const DASHBOARD_PORT = parsePort(process.env.DASHBOARD_PORT, parsePort(process.env.PORT, 3001));
 const LOG_MAX_BYTES = 10000000;
 
+function parsePort(value, fallback) {
+  const port = Number(value);
+  return Number.isInteger(port) && port > 0 && port <= 65535 ? port : fallback;
+}
+
+function parsePositiveInteger(value, fallback) {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+
 function emitOk() {
   process.stdout.write('{"continue":true}\n');
 }
@@ -207,27 +220,10 @@ function uvPath() {
   return commandPath(process.platform === "win32" ? ["uv.exe", "uv"] : ["uv"]);
 }
 
-function npmPath() {
-  return commandPath(process.platform === "win32" ? ["npm.cmd", "npm.exe", "npm"] : ["npm"]);
-}
-
 function bashPath() {
   return commandPath(process.platform === "win32" ? ["bash.exe", "bash"] : ["bash"]);
 }
 
-function stateFile(name) {
-  return path.join(STATE_DIR, name);
-}
-
-function backendUrlFile() {
-  return stateFile("backend-url");
-}
-
-function writeBackendUrl(port) {
-  ensureDir(STATE_DIR);
-  fs.writeFileSync(backendUrlFile(), `http://localhost:${port}/\n`);
-}
-
 function unquoteEnvValue(value) {
   const trimmed = String(value || "").trim();
   if (trimmed.length >= 2) {
@@ -279,12 +275,6 @@ function loadReflexioEnv() {
   }
 }
 
-function reflexioUrlIsRemote() {
-  const url = process.env.REFLEXIO_URL || "";
-  if (!url) return false;
-  return !/^http:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])(?::\d+)?\/?$/i.test(url);
-}
-
 function codexCompatPath(root) {
   const filename = process.platform === "win32"
     ? "codex-claude-compat.cmd"
@@ -294,69 +284,9 @@ function codexCompatPath(root) {
 
 function readBackendUrl() {
   if (process.env.REFLEXIO_URL) return process.env.REFLEXIO_URL;
-  try {
-    const value = fs.readFileSync(backendUrlFile(), "utf8").trim();
-    if (value) return value;
-  } catch {
-    // Fall through to default.
-  }
   return `http://localhost:${DEFAULT_BACKEND_PORT}/`;
 }
 
-function healthOk(port, pathname, markerHeader) {
-  return new Promise((resolve) => {
-    const req = http.request(
-      {
-        host: "127.0.0.1",
-        port,
-        path: pathname,
-        method: "GET",
-        timeout: 1200,
-      },
-      (res) => {
-        const ok = res.statusCode && res.statusCode >= 200 && res.statusCode < 400;
-        const markerOk = markerHeader ? Boolean(res.headers[markerHeader]) : true;
-        res.resume();
-        resolve(Boolean(ok && markerOk));
-      },
-    );
-    req.on("timeout", () => req.destroy());
-    req.on("error", () => resolve(false));
-    req.end();
-  });
-}
-
-function portOccupied(port) {
-  return new Promise((resolve) => {
-    const req = http.request(
-      {
-        host: "127.0.0.1",
-        port,
-        path: "/",
-        method: "GET",
-        timeout: 900,
-      },
-      (res) => {
-        res.resume();
-        resolve(true);
-      },
-    );
-    req.on("timeout", () => req.destroy());
-    req.on("error", (err) => {
-      resolve(err && err.code !== "ECONNREFUSED");
-    });
-    req.end();
-  });
-}
-
-async function waitForHealth(port, pathname, markerHeader, attempts) {
-  for (let i = 0; i < attempts; i += 1) {
-    if (await healthOk(port, pathname, markerHeader)) return true;
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-  }
-  return false;
-}
-
 function detached(command, args, options = {}) {
   const child = spawn(command, args, {
     cwd: options.cwd,
@@ -386,167 +316,87 @@ function startInstallerDetached(root, reason) {
   return true;
 }
 
-function readPid(file) {
-  try {
-    const value = fs.readFileSync(file, "utf8").trim();
-    return value ? Number(value) : null;
-  } catch {
-    return null;
+function runServiceScript(root, scriptName, action, logName) {
+  trimLog(path.join(STATE_DIR, logName));
+  const bash = bashPath();
+  const script = path.join(root, "scripts", scriptName);
+  if (!bash || !fs.existsSync(script)) {
+    appendLog(
+      logName,
+      `[claude-smart] codex hook: cannot run ${scriptName}; bash or script missing`,
+    );
+    emitOk();
+    return 0;
   }
-}
-
-function pidAlive(pid) {
-  if (!pid || Number.isNaN(pid)) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
+  const result = spawnSync(bash, [script, action], {
+    cwd: root,
+    env: {
+      ...process.env,
+      PLUGIN_ROOT: root,
+      CLAUDE_PLUGIN_ROOT: root,
+      CLAUDE_SMART_HOST: "codex",
+      CLAUDE_SMART_CLI_PATH: process.env.CLAUDE_SMART_CLI_PATH || codexCompatPath(root),
+      BACKEND_PORT: String(DEFAULT_BACKEND_PORT),
+      EMBEDDING_PORT: String(DEFAULT_EMBEDDING_PORT),
+      DASHBOARD_PORT: String(DASHBOARD_PORT),
+      PORT: String(DASHBOARD_PORT),
+      REFLEXIO_URL: readBackendUrl(),
+    },
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: SERVICE_SCRIPT_TIMEOUT_MS,
+    windowsHide: true,
+  });
+  const stderr = String(result.stderr || "").trim();
+  if (stderr) appendLog(logName, stderr);
+  if (result.error) {
+    appendLog(
+      logName,
+      `[claude-smart] codex hook: ${scriptName} ${action} failed: ${result.error.message}`,
+    );
   }
-}
-
-function writePid(file, pid) {
-  ensureDir(path.dirname(file));
-  fs.writeFileSync(file, `${pid}\n`);
+  if (result.signal) {
+    appendLog(
+      logName,
+      `[claude-smart] codex hook: ${scriptName} ${action} terminated by ${result.signal}`,
+    );
+  }
+  emitNormalizedHookOutput(result.stdout);
+  return typeof result.status === "number" ? result.status : 0;
 }
 
 function ensurePluginRoot(root) {
   ensureDir(REFLEXIO_DIR);
   const link = path.join(REFLEXIO_DIR, "plugin-root");
+  const metadata = path.join(REFLEXIO_DIR, "plugin-root.txt");
+  let blocked = false;
   try {
-    fs.rmSync(link, { recursive: true, force: true });
-  } catch {
-    // Ignore and try to recreate below.
+    const existing = fs.lstatSync(link);
+    if (existing.isSymbolicLink() || existing.isFile()) {
+      fs.rmSync(link, { recursive: true, force: true });
+    } else {
+      blocked = true;
+    }
+  } catch (err) {
+    if (!err || err.code !== "ENOENT") blocked = true;
+  }
+  if (blocked) {
+    fs.writeFileSync(metadata, `${root}\n`);
+    return;
   }
   try {
     fs.symlinkSync(root, link, process.platform === "win32" ? "junction" : "dir");
+    fs.writeFileSync(metadata, `${root}\n`);
   } catch {
-    fs.writeFileSync(path.join(REFLEXIO_DIR, "plugin-root.txt"), `${root}\n`);
+    fs.writeFileSync(metadata, `${root}\n`);
   }
 }
 
 async function startBackend(root) {
-  trimLog(path.join(STATE_DIR, "backend.log"));
-  if (process.env.CLAUDE_SMART_BACKEND_AUTOSTART === "0") {
-    emitOk();
-    return;
-  }
-  if (reflexioUrlIsRemote()) {
-    appendLog("backend.log", "[claude-smart] backend: remote REFLEXIO_URL configured; skipping local backend start");
-    emitOk();
-    return;
-  }
-  const pidFile = path.join(STATE_DIR, "backend.pid");
-  for (const port of [DEFAULT_BACKEND_PORT, FALLBACK_BACKEND_PORT]) {
-    if (pidAlive(readPid(pidFile)) && await healthOk(port, "/health")) {
-      writeBackendUrl(port);
-      emitOk();
-      return;
-    }
-    if (await healthOk(port, "/health")) {
-      writeBackendUrl(port);
-      emitOk();
-      return;
-    }
-  }
-  const uv = uvPath();
-  if (!uv) {
-    startInstallerDetached(root, "backend: uv not on PATH");
-  }
-  const readyUv = uvPath();
-  if (!readyUv) {
-    appendLog("backend.log", "[claude-smart] backend: uv not on PATH; installer recovery scheduled; skipping");
-    emitOk();
-    return;
-  }
-  let selectedPort = DEFAULT_BACKEND_PORT;
-  if (await portOccupied(DEFAULT_BACKEND_PORT)) {
-    appendLog("backend.log", "[claude-smart] backend: port 8071 occupied; trying 8072");
-    selectedPort = FALLBACK_BACKEND_PORT;
-  }
-  const backendUrl = `http://localhost:${selectedPort}/`;
-  const env = {
-    ...process.env,
-    BACKEND_PORT: String(selectedPort),
-    REFLEXIO_URL: backendUrl,
-    CLAUDE_SMART_USE_LOCAL_CLI: process.env.CLAUDE_SMART_USE_LOCAL_CLI || "1",
-    CLAUDE_SMART_USE_LOCAL_EMBEDDING: process.env.CLAUDE_SMART_USE_LOCAL_EMBEDDING || "1",
-    CLAUDE_SMART_HOST: "codex",
-    CLAUDE_SMART_CLI_PATH: process.env.CLAUDE_SMART_CLI_PATH || codexCompatPath(root),
-    INTERACTION_CLEANUP_THRESHOLD: process.env.INTERACTION_CLEANUP_THRESHOLD || "500",
-    INTERACTION_CLEANUP_DELETE_COUNT: process.env.INTERACTION_CLEANUP_DELETE_COUNT || "200",
-  };
-  const pid = detached(
-    readyUv,
-    [
-      "run",
-      "--project",
-      root,
-      "--quiet",
-      "reflexio",
-      "services",
-      "start",
-      "--only",
-      "backend",
-      "--no-reload",
-    ],
-    { cwd: root, env },
-  );
-  writePid(pidFile, pid);
-  if (await waitForHealth(selectedPort, "/health", null, 10)) {
-    writeBackendUrl(selectedPort);
-  }
-  emitOk();
+  runServiceScript(root, "backend-service.sh", "start", "backend.log");
 }
 
 async function startDashboard(root) {
-  if (process.env.CLAUDE_SMART_DASHBOARD_AUTOSTART === "0") {
-    emitOk();
-    return;
-  }
-  const dashboard = path.join(root, "dashboard");
-  if (!fs.existsSync(dashboard)) {
-    emitOk();
-    return;
-  }
-  const pidFile = path.join(STATE_DIR, "dashboard.pid");
-  if (
-    pidAlive(readPid(pidFile)) &&
-    await healthOk(DASHBOARD_PORT, "/api/health", "x-claude-smart-dashboard")
-  ) {
-    emitOk();
-    return;
-  }
-  const npm = npmPath();
-  if (!npm) {
-    startInstallerDetached(root, "dashboard: npm not on PATH");
-  }
-  const readyNpm = npmPath();
-  if (!readyNpm) {
-    appendLog("dashboard.log", "[claude-smart] dashboard: npm not on PATH; installer recovery scheduled; skipping");
-    emitOk();
-    return;
-  }
-  if (!fs.existsSync(path.join(dashboard, ".next"))) {
-    const buildPidFile = path.join(STATE_DIR, "dashboard-build.pid");
-    if (!pidAlive(readPid(buildPidFile))) {
-      const pid = detached(readyNpm, ["run", "build"], { cwd: dashboard });
-      writePid(buildPidFile, pid);
-      appendLog("dashboard.log", "[claude-smart] dashboard: .next missing; started background build");
-    }
-    emitOk();
-    return;
-  }
-  const env = {
-    ...process.env,
-    PORT: String(DASHBOARD_PORT),
-    REFLEXIO_URL: readBackendUrl(),
-    CLAUDE_SMART_DASHBOARD_WORKSPACE: process.cwd(),
-  };
-  const pid = detached(readyNpm, ["run", "start"], { cwd: dashboard, env });
-  writePid(pidFile, pid);
-  await waitForHealth(DASHBOARD_PORT, "/api/health", "x-claude-smart-dashboard", 5);
-  emitOk();
+  runServiceScript(root, "dashboard-service.sh", "start", "dashboard.log");
 }
 
 function runHook(root, event) {

package/plugin/scripts/dashboard-open.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # Start backend + dashboard (idempotent), wait briefly for dashboard to come
-# up, print statuses, then open http://localhost:3001 in the default browser.
+# up, print statuses, then open the dashboard in the default browser.
 #
 # Exists so the /claude-smart:dashboard slash command can invoke a single
 # plain `bash <script>` with no inline $(...) or ${...:-...} expansion in
@@ -18,6 +18,8 @@ STATE_DIR="$HOME/.claude-smart"
 BACKEND_LOG="$STATE_DIR/backend.log"
 DASHBOARD_LOG="$STATE_DIR/dashboard.log"
 DASHBOARD_UNAVAILABLE="$(claude_smart_dashboard_unavailable_marker)"
+BACKEND_PORT="${BACKEND_PORT:-8071}"
+DASHBOARD_PORT="${DASHBOARD_PORT:-${PORT:-3001}}"
 
 # Capture start-command output so we can surface fatal errors (e.g. uv/npm
 # missing, port collisions, .next not built) rather than silently swallow
@@ -64,7 +66,7 @@ failed=0
 if [ "$backend_status" = "not running" ]; then
     failed=1
     echo ""
-    echo "ERROR: backend failed to start on http://localhost:8071"
+    echo "ERROR: backend failed to start on http://localhost:$BACKEND_PORT"
     [ -n "$backend_start_out" ] && echo "$backend_start_out"
     show_log_tail "backend" "$BACKEND_LOG"
 fi
@@ -75,7 +77,7 @@ if [ "$dashboard_status" = "not running" ]; then
     if claude_smart_pid_alive_file "$BUILD_PID_FILE"; then
         echo "dashboard: still building (first-run cost, ~1-2 min). Re-run /claude-smart:dashboard in a minute."
     else
-        echo "ERROR: dashboard failed to start on http://localhost:3001"
+        echo "ERROR: dashboard failed to start on http://localhost:$DASHBOARD_PORT"
         [ -n "$dashboard_start_out" ] && echo "$dashboard_start_out"
         if [ -f "$DASHBOARD_UNAVAILABLE" ]; then
             echo ""
@@ -92,7 +94,7 @@ if [ "$failed" = "1" ]; then
     exit 1
 fi
 
-URL="http://localhost:3001"
+URL="http://localhost:$DASHBOARD_PORT"
 PY_BIN=$(claude_smart_resolve_python || true)
 if [ -n "$PY_BIN" ] && "$PY_BIN" -m webbrowser "$URL"; then
     echo "Opened $URL"