@frumu/tandem-panel 0.4.6 → 0.4.8

package/.env.example

@@ -36,6 +36,17 @@ TANDEM_PROVIDER_STREAM_IDLE_TIMEOUT_MS=90000
 TANDEM_PERMISSION_WAIT_TIMEOUT_MS=15000
 TANDEM_TOOL_EXEC_TIMEOUT_MS=45000
 TANDEM_BASH_TIMEOUT_MS=30000
+
+# Built-in websearch defaults. `auto` can try configured backends in order
+# (managed Tandem URL, SearxNG, Brave, Exa) before falling back.
+TANDEM_SEARCH_BACKEND=auto
+TANDEM_SEARCH_URL=https://search.tandem.frumu.ai
+TANDEM_SEARCH_TIMEOUT_MS=10000
+# Optional direct-provider overrides
+# TANDEM_BRAVE_SEARCH_API_KEY=
+# TANDEM_EXA_API_KEY=
+# TANDEM_SEARXNG_URL=http://127.0.0.1:8080
+
 # Bug Monitor (disabled by default)
 # TANDEM_BUG_MONITOR_ENABLED=0
 # TANDEM_BUG_MONITOR_REPO=owner/repo

package/README.md

@@ -8,6 +8,16 @@ Full web control center for Tandem Engine (non-desktop entry point).
 npm i -g @frumu/tandem-panel
 ```
 
+## Editable App Scaffold
+
+```bash
+npm create tandem-panel@latest my-panel
+```
+
+Use the global install when you want the official ready-to-run panel.
+
+Use the scaffold when you want the actual app source in your own folder so you can edit routes, pages, themes, styles, and runtime behavior without customizing files inside `node_modules`.
+
 ## Official Bootstrap
 
 ```bash
@@ -85,6 +95,15 @@ Variables:
 - `TANDEM_CONTROL_PANEL_ENGINE_TOKEN` (token injected when panel auto-starts engine)
 - `TANDEM_API_TOKEN` (backward-compatible alias for engine token)
 - `TANDEM_CONTROL_PANEL_SESSION_TTL_MINUTES` (default `1440`)
+- `TANDEM_SEARCH_BACKEND` (`auto`, `tandem`, `brave`, `exa`, `searxng`, or `none`; default official installs use `auto`)
+- `TANDEM_SEARCH_URL` (hosted Tandem search endpoint or compatible router URL)
+- `TANDEM_SEARCH_TIMEOUT_MS` (default `10000`)
+- `TANDEM_BRAVE_SEARCH_API_KEY` (optional direct Brave override when `TANDEM_SEARCH_BACKEND=brave`)
+- `TANDEM_EXA_API_KEY` (optional direct Exa override when `TANDEM_SEARCH_BACKEND=exa`)
+- `TANDEM_SEARXNG_URL` (optional self-hosted override when `TANDEM_SEARCH_BACKEND=searxng`)
+
+The desktop app now exposes these search settings directly in Settings, and the control panel exposes them under Settings -> Web Search when it is connected to a local engine host.
+
 - `TANDEM_DISABLE_TOOL_GUARD_BUDGETS` (`1` disables per-run guard budgets; default in installer/service env is `1`)
 - `TANDEM_PROMPT_CONTEXT_HOOK_TIMEOUT_MS` (default `5000`)
 - `TANDEM_PROVIDER_STREAM_CONNECT_TIMEOUT_MS` (default `30000`)
@@ -144,17 +163,32 @@ npm run build
 
 ### Repo Source Workflow (No Global npm Install)
 
-If you run from this repo directly, use:
+If you run from the repo root, use:
 
 ```bash
 node packages/tandem-control-panel/bin/cli.js init --no-service
 node packages/tandem-control-panel/bin/cli.js run
 ```
 
-Service install/ops from source:
+If you are already inside `packages/tandem-control-panel`, use:
+
+```bash
+node bin/cli.js init --no-service
+node bin/cli.js run
+```
+
+Service install/ops from source from the repo root:
 
 ```bash
 sudo node packages/tandem-control-panel/bin/cli.js service install
 node packages/tandem-control-panel/bin/cli.js service status
 sudo node packages/tandem-control-panel/bin/cli.js service restart
 ```
+
+Service install/ops from inside `packages/tandem-control-panel`:
+
+```bash
+sudo node bin/cli.js service install
+node bin/cli.js service status
+sudo node bin/cli.js service restart
+```

package/bin/setup.js

@@ -34,6 +34,10 @@ function parseDotEnv(content) {
   return out;
 }
 
+function serializeEnv(entries) {
+  return `${entries.map(([key, value]) => `${key}=${value}`).join("\n")}\n`;
+}
+
 function loadDotEnvFile(pathname) {
   if (!existsSync(pathname)) return false;
   const parsed = parseDotEnv(readFileSync(pathname, "utf8"));
@@ -43,6 +47,21 @@ function loadDotEnvFile(pathname) {
   return true;
 }
 
+function posixHomeForUser(username) {
+  const name = String(username || "").trim();
+  if (!name) return homedir();
+  try {
+    const passwd = readFileSync("/etc/passwd", "utf8");
+    for (const line of passwd.split(/\r?\n/)) {
+      if (!line || line.startsWith("#")) continue;
+      const parts = line.split(":");
+      if (parts[0] === name && parts[5]) return parts[5];
+    }
+  } catch {}
+  if (process.env.USER === name || process.env.SUDO_USER === name) return homedir();
+  return resolve("/home", name);
+}
+
 function parseCliArgs(argv) {
   const flags = new Set();
   const values = new Map();
@@ -158,6 +177,9 @@ const ENGINE_PORT = Number.parseInt(process.env.TANDEM_ENGINE_PORT || "39731", 1
 const ENGINE_URL = (
   process.env.TANDEM_ENGINE_URL || `http://${ENGINE_HOST}:${ENGINE_PORT}`
 ).replace(/\/+$/, "");
+const DEFAULT_TANDEM_SEARCH_URL = (
+  process.env.TANDEM_SEARCH_URL || "https://search.tandem.frumu.ai"
+).replace(/\/+$/, "");
 const SWARM_RUNS_PATH = resolve(homedir(), ".tandem", "control-panel", "swarm-runs.json");
 const SWARM_HIDDEN_RUNS_PATH = resolve(
   homedir(),
@@ -704,7 +726,8 @@ async function installServices() {
   const serviceGroup = serviceUser;
   const installEngine = serviceMode === "both" || serviceMode === "engine";
   const installPanel = serviceMode === "both" || serviceMode === "panel";
-  const stateDir = String(process.env.TANDEM_STATE_DIR || "/srv/tandem").trim();
+  const defaultStateDir = resolve(posixHomeForUser(serviceUser), ".local", "share", "tandem");
+  const stateDir = String(process.env.TANDEM_HOME || process.env.TANDEM_STATE_DIR || defaultStateDir).trim();
   const engineEnvPath = "/etc/tandem/engine.env";
   const panelEnvPath = "/etc/tandem/control-panel.env";
   const engineServiceName = "tandem-engine";
@@ -728,11 +751,48 @@ async function installServices() {
   const existingEngineEnv = existsSync(engineEnvPath)
     ? parseDotEnv(readFileSync(engineEnvPath, "utf8"))
     : {};
+  const { TANDEM_MEMORY_DB_PATH: _legacyMemoryDbPath, ...engineEnvBase } = existingEngineEnv;
+  const searchEnv =
+    existingEngineEnv.TANDEM_SEARCH_BACKEND ||
+    existingEngineEnv.TANDEM_SEARCH_URL ||
+    existingEngineEnv.TANDEM_SEARCH_TIMEOUT_MS ||
+    existingEngineEnv.TANDEM_BRAVE_SEARCH_API_KEY ||
+    existingEngineEnv.BRAVE_SEARCH_API_KEY ||
+    existingEngineEnv.TANDEM_EXA_API_KEY ||
+    existingEngineEnv.EXA_API_KEY ||
+    existingEngineEnv.TANDEM_SEARXNG_URL
+      ? {
+          ...(existingEngineEnv.TANDEM_SEARCH_BACKEND
+            ? { TANDEM_SEARCH_BACKEND: existingEngineEnv.TANDEM_SEARCH_BACKEND }
+            : {}),
+          ...(existingEngineEnv.TANDEM_SEARCH_URL
+            ? { TANDEM_SEARCH_URL: existingEngineEnv.TANDEM_SEARCH_URL }
+            : {}),
+          ...(existingEngineEnv.TANDEM_SEARCH_TIMEOUT_MS
+            ? { TANDEM_SEARCH_TIMEOUT_MS: existingEngineEnv.TANDEM_SEARCH_TIMEOUT_MS }
+            : {}),
+          ...(existingEngineEnv.TANDEM_BRAVE_SEARCH_API_KEY
+            ? { TANDEM_BRAVE_SEARCH_API_KEY: existingEngineEnv.TANDEM_BRAVE_SEARCH_API_KEY }
+            : {}),
+          ...(existingEngineEnv.BRAVE_SEARCH_API_KEY
+            ? { BRAVE_SEARCH_API_KEY: existingEngineEnv.BRAVE_SEARCH_API_KEY }
+            : {}),
+          ...(existingEngineEnv.TANDEM_EXA_API_KEY
+            ? { TANDEM_EXA_API_KEY: existingEngineEnv.TANDEM_EXA_API_KEY }
+            : {}),
+          ...(existingEngineEnv.EXA_API_KEY
+            ? { EXA_API_KEY: existingEngineEnv.EXA_API_KEY }
+            : {}),
+          ...(existingEngineEnv.TANDEM_SEARXNG_URL
+            ? { TANDEM_SEARXNG_URL: existingEngineEnv.TANDEM_SEARXNG_URL }
+            : {}),
+        }
+      : {};
   const engineEnv = {
-    ...existingEngineEnv,
+    ...engineEnvBase,
     TANDEM_API_TOKEN: token,
     TANDEM_STATE_DIR: stateDir,
-    TANDEM_MEMORY_DB_PATH: existingEngineEnv.TANDEM_MEMORY_DB_PATH || `${stateDir}/memory.sqlite`,
+    ...searchEnv,
     TANDEM_ENABLE_GLOBAL_MEMORY: existingEngineEnv.TANDEM_ENABLE_GLOBAL_MEMORY || "1",
     TANDEM_DISABLE_TOOL_GUARD_BUDGETS: existingEngineEnv.TANDEM_DISABLE_TOOL_GUARD_BUDGETS || "1",
     TANDEM_TOOL_ROUTER_ENABLED: existingEngineEnv.TANDEM_TOOL_ROUTER_ENABLED || "0",
@@ -951,6 +1011,127 @@ async function readJsonBody(req) {
   return JSON.parse(raw);
 }
 
+function normalizeSearchBackend(raw) {
+  switch (String(raw || "").trim().toLowerCase()) {
+    case "":
+    case "auto":
+      return "auto";
+    case "tandem":
+    case "brave":
+    case "exa":
+    case "searxng":
+      return String(raw).trim().toLowerCase();
+    case "none":
+    case "disabled":
+      return "none";
+    default:
+      return "auto";
+  }
+}
+
+function normalizeSearchUrl(raw) {
+  const value = String(raw || "").trim().replace(/\/+$/, "");
+  return value || "";
+}
+
+function getManagedEngineEnvPath() {
+  return "/etc/tandem/engine.env";
+}
+
+function readManagedSearchSettings() {
+  const envPath = getManagedEngineEnvPath();
+  const localEngine = isLocalEngineUrl(ENGINE_URL);
+  const env = existsSync(envPath) ? parseDotEnv(readFileSync(envPath, "utf8")) : {};
+  const timeoutRaw = Number.parseInt(String(env.TANDEM_SEARCH_TIMEOUT_MS || "10000"), 10);
+  const timeoutMs = Number.isFinite(timeoutRaw)
+    ? Math.min(Math.max(timeoutRaw, 1000), 120000)
+    : 10000;
+  return {
+    available: localEngine,
+    local_engine: localEngine,
+    writable: localEngine,
+    managed_env_path: envPath,
+    restart_required: false,
+    restart_hint: "Restart tandem-engine after saving search settings.",
+    settings: {
+      backend: normalizeSearchBackend(env.TANDEM_SEARCH_BACKEND || "auto"),
+      tandem_url: normalizeSearchUrl(env.TANDEM_SEARCH_URL || ""),
+      searxng_url: normalizeSearchUrl(env.TANDEM_SEARXNG_URL || ""),
+      timeout_ms: timeoutMs,
+      has_brave_key: !!String(
+        env.TANDEM_BRAVE_SEARCH_API_KEY || env.BRAVE_SEARCH_API_KEY || ""
+      ).trim(),
+      has_exa_key: !!String(env.TANDEM_EXA_API_KEY || env.EXA_API_KEY || "").trim(),
+    },
+    reason: localEngine
+      ? ""
+      : "Search settings can only be edited here when the control panel points at a local engine host.",
+  };
+}
+
+async function writeManagedSearchSettings(payload = {}) {
+  const current = readManagedSearchSettings();
+  if (!current.local_engine) {
+    const error = new Error(current.reason || "Search settings are not editable for this engine.");
+    error.statusCode = 400;
+    throw error;
+  }
+  const envPath = current.managed_env_path;
+  const existingEnv = existsSync(envPath) ? parseDotEnv(readFileSync(envPath, "utf8")) : {};
+  const nextEnv = { ...existingEnv };
+
+  nextEnv.TANDEM_SEARCH_BACKEND = normalizeSearchBackend(payload.backend || "auto");
+  const timeoutRaw = Number.parseInt(String(payload.timeout_ms || payload.timeoutMs || "10000"), 10);
+  nextEnv.TANDEM_SEARCH_TIMEOUT_MS = String(
+    Number.isFinite(timeoutRaw) ? Math.min(Math.max(timeoutRaw, 1000), 120000) : 10000
+  );
+
+  const tandemUrl = normalizeSearchUrl(payload.tandem_url || payload.tandemUrl || "");
+  if (tandemUrl) nextEnv.TANDEM_SEARCH_URL = tandemUrl;
+  else delete nextEnv.TANDEM_SEARCH_URL;
+
+  const searxngUrl = normalizeSearchUrl(payload.searxng_url || payload.searxngUrl || "");
+  if (searxngUrl) nextEnv.TANDEM_SEARXNG_URL = searxngUrl;
+  else delete nextEnv.TANDEM_SEARXNG_URL;
+
+  const braveKey = String(payload.brave_api_key || payload.braveApiKey || "").trim();
+  if (braveKey) nextEnv.TANDEM_BRAVE_SEARCH_API_KEY = braveKey;
+  else if (payload.clear_brave_key || payload.clearBraveKey) {
+    delete nextEnv.TANDEM_BRAVE_SEARCH_API_KEY;
+    delete nextEnv.BRAVE_SEARCH_API_KEY;
+  }
+
+  const exaKey = String(payload.exa_api_key || payload.exaApiKey || "").trim();
+  if (exaKey) nextEnv.TANDEM_EXA_API_KEY = exaKey;
+  else if (payload.clear_exa_key || payload.clearExaKey) {
+    delete nextEnv.TANDEM_EXA_API_KEY;
+    delete nextEnv.EXA_API_KEY;
+  }
+
+  const preferredKeys = [
+    "TANDEM_API_TOKEN",
+    "TANDEM_STATE_DIR",
+    "TANDEM_SEARCH_BACKEND",
+    "TANDEM_SEARCH_URL",
+    "TANDEM_SEARXNG_URL",
+    "TANDEM_SEARCH_TIMEOUT_MS",
+    "TANDEM_BRAVE_SEARCH_API_KEY",
+    "TANDEM_EXA_API_KEY",
+  ];
+  const ordered = [];
+  for (const key of preferredKeys) {
+    if (nextEnv[key] !== undefined) ordered.push([key, nextEnv[key]]);
+  }
+  for (const [key, value] of Object.entries(nextEnv)) {
+    if (!preferredKeys.includes(key)) ordered.push([key, value]);
+  }
+  await writeFile(envPath, serializeEnv(ordered), "utf8");
+  return {
+    ...readManagedSearchSettings(),
+    restart_required: true,
+  };
+}
+
 function sendJson(res, code, payload) {
   if (res.headersSent || res.writableEnded || res.destroyed) return;
   const body = JSON.stringify(payload);
@@ -4353,6 +4534,29 @@ async function handleApi(req, res) {
     return true;
   }
 
+  if (pathname === "/api/system/search-settings" && req.method === "GET") {
+    const session = requireSession(req, res);
+    if (!session) return true;
+    sendJson(res, 200, readManagedSearchSettings());
+    return true;
+  }
+
+  if (pathname === "/api/system/search-settings" && req.method === "PATCH") {
+    const session = requireSession(req, res);
+    if (!session) return true;
+    try {
+      const payload = await readJsonBody(req);
+      const saved = await writeManagedSearchSettings(payload);
+      sendJson(res, 200, saved);
+    } catch (error) {
+      sendJson(res, Number(error?.statusCode || 500), {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+    return true;
+  }
+
   if (pathname === "/api/auth/login" && req.method === "POST") {
     await handleAuthLogin(req, res);
     return true;