synabun 2.0.0 → 2.0.7

package/neural-interface/lib/claude-temporary.js

@@ -7,9 +7,9 @@
 // one sentence the model is told, and the plan files Claude Code writes for it
 // whatever the options say.
 
-import { lstatSync, readFileSync, realpathSync, statSync, unlinkSync } from 'node:fs';
+import { lstatSync, readFileSync, readdirSync, realpathSync, statSync, unlinkSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
 
 // Set in the environment of a temporary session's process. SynaBun's Claude
 // Code hooks read it (hooks/claude-code/shared.mjs, isTemporaryChat) and store,
@@ -386,6 +386,41 @@ export function plansDirsOf(env, { cwd = '', settings = null } = {}) {
 const real = (p) => { try { return realpathSync(p); } catch { return resolve(p); } };
 const listOf = (dirs) => (Array.isArray(dirs) ? dirs : [dirs]).filter(Boolean);
 
+// Resolve existing ancestors too, when the plans directory does not exist yet.
+function realPlanFolder(dir) {
+  const full = resolve(dir);
+  try { return realpathSync(full); } catch {
+    const parent = dirname(full);
+    return parent === full ? full : join(realPlanFolder(parent), basename(full));
+  }
+}
+
+/**
+ * Files present before the session starts. Filesystem creation timestamps can
+ * lag Date.now(), so they cannot reliably identify a newly created plan.
+ * Device/inode identities also preserve existing files after edits or renames.
+ * Missing folders start empty; unreadable folders remain unclassified.
+ */
+export function snapshotPlanFiles(plansDirs) {
+  const before = { roots: new Set(), files: new Set() };
+  for (const dir of listOf(plansDirs)) {
+    const root = realPlanFolder(dir);
+    try {
+      for (const name of readdirSync(root)) {
+        try { before.files.add(planFileIdentity(lstatSync(join(root, name)))); } catch (err) {
+          if (err?.code !== 'ENOENT' && err?.code !== 'ENOTDIR') throw err;
+        }
+      }
+      before.roots.add(root);
+    } catch (err) {
+      if (err?.code === 'ENOENT') before.roots.add(root);
+    }
+  }
+  return before;
+}
+
+const planFileIdentity = (stat) => `${stat.dev}:${stat.ino}`;
+
 /**
  * The plan file a tool call of the session names, when it is one: a Write or
  * Edit of a Markdown file directly in a plans folder, or the file an
@@ -407,12 +442,13 @@ export function planFileOfToolCall(block, plansDirs) {
  * a plans folder whatever the session's options say (`plansDirectory` only
  * moves it inside the project), so the bridge removes it once the session's
  * process has ended. Only a regular Markdown file that is really in one of the
- * plans folders and was created after the session's process started: a plan
- * that was there before is someone else's.
+ * plans folders and was absent from the pre-session snapshot: a plan that was
+ * there before is someone else's. Callers without a snapshot retain the
+ * timestamp check.
  * @returns {{ removed: string[], failed: string[] }} `failed`: still there
  *   because the removal itself did not work; the caller keeps them and tries again
  */
-export function removeTemporaryPlanFiles(paths, { plansDirs, plansDir, since }) {
+export function removeTemporaryPlanFiles(paths, { plansDirs, plansDir, since, before }) {
   const removed = [];
   const failed = [];
   const roots = new Set();
@@ -422,8 +458,11 @@ export function removeTemporaryPlanFiles(paths, { plansDirs, plansDir, since })
       if (extname(path).toLowerCase() !== '.md') continue;
       const stat = lstatSync(path);
       if (!stat.isFile()) continue; // not a link, not a folder
-      if (!roots.has(realpathSync(dirname(path)))) continue;
-      if (!(stat.birthtimeMs >= since)) continue;
+      const parent = realpathSync(dirname(path));
+      if (!roots.has(parent)) continue;
+      if (before) {
+        if (!before.roots.has(parent) || before.files.has(planFileIdentity(stat))) continue;
+      } else if (!(stat.birthtimeMs >= since)) continue;
       unlinkSync(path);
       removed.push(path);
     } catch (err) {

package/neural-interface/lib/cli-install-api.js

@@ -0,0 +1,137 @@
+// ═══════════════════════════════════════════
+// SynaBun — /api/cli/install: the side panels' Install button
+// ═══════════════════════════════════════════
+//
+//   GET  /api/cli/install         { ok, jobs: { [tool]: { state, step, code, error, log, … } } }
+//   POST /api/cli/install/:tool   NDJSON: start, step, progress, log … done (lib/cli-install.js)
+//   GET  /api/cli/git-bash        Git Bash for Claude Code on Windows (lib/git-bash/), and
+//   POST /api/cli/git-bash/install|recheck  its download and a new look (createGitBashApi below)
+//
+// Installing software is the owner's own act on this computer, so these routes
+// take the guards of SynaBun's other local mutating endpoints (lib/http-guards.js,
+// as /api/whatsapp): a loopback socket and no proxy header, a localhost Host,
+// no invite guest; a POST also its own Origin, a JSON body, X-SynaBun-UI: 1 and
+// no agent header. (`/api/cli` is admin-only in lib/request-gate.js too.) A
+// request names a tool and nothing else: what runs is fixed by
+// lib/cli-install.js for this system.
+//
+// Refusals before anything starts are JSON: 400 UNKNOWN_TOOL, 409 BUSY (that
+// tool is being installed), 422 UNSUPPORTED (no one-click method here). A tab
+// that goes away does not stop an install; its result is in GET and in the next
+// /api/system/tool-versions.
+
+import { Router } from 'express';
+import { guestForbidden, noStore, requireLocal, requireLocalHost, requireSameOriginJson, sendGuardError, uiOnly } from './http-guards.js';
+import { openNdjsonStream } from './whatsapp/api.js';
+
+export const INSTALLABLE_TOOLS = Object.freeze(['claude-code', 'codex', 'opencode']);
+
+/**
+ * @param {object} deps
+ * @param {ReturnType<import('./cli-install.js').createCliInstaller>} deps.installer
+ * @param {(req) => boolean} [deps.isGuestRequest]
+ * @param {number|(() => number)} [deps.port]  the port the page is served from (Host / Origin checks)
+ */
+function localCliRouter({ isGuestRequest = () => false, port = 3344 } = {}) {
+  const router = Router();
+  const portOf = () => Number(typeof port === 'function' ? port() : port);
+  const built = new Map();
+  const perPort = (name, factory) => (req, res, next) => {
+    const key = `${name}:${portOf()}`;
+    let guard = built.get(key);
+    if (!guard) {
+      try { guard = factory(portOf()); } catch { return sendGuardError(res, 500, 'BAD_PORT', 'The install API has no valid port.'); }
+      built.set(key, guard);
+    }
+    return guard(req, res, next);
+  };
+
+  router.use(noStore, guestForbidden(isGuestRequest), requireLocal, perPort('host', requireLocalHost));
+  const mutating = [perPort('origin', requireSameOriginJson), uiOnly];
+  return { router, mutating };
+}
+
+export function createCliInstallApi({ installer, isGuestRequest = () => false, port = 3344, log = () => {} } = {}) {
+  if (!installer) throw new Error('createCliInstallApi needs the installer');
+  const { router, mutating } = localCliRouter({ isGuestRequest, port });
+
+  router.get('/', (req, res) => {
+    res.json({ ok: true, jobs: installer.jobs() });
+  });
+
+  router.post('/:tool', ...mutating, (req, res) => {
+    const tool = String(req.params.tool || '');
+    if (!INSTALLABLE_TOOLS.includes(tool)) {
+      return res.status(400).json({ ok: false, code: 'UNKNOWN_TOOL', error: `Unknown CLI: ${tool.slice(0, 40)}` });
+    }
+    let stream = null;
+    const onEvent = (event) => {
+      if (!stream) stream = openNdjsonStream(res);
+      stream.write(event);
+      if (event?.type === 'done') stream.end();
+    };
+    let started;
+    try {
+      started = installer.start(tool, { onEvent });
+    } catch (error) {
+      const code = error?.code === 'busy' ? 'BUSY' : error?.code === 'unsupported' ? 'UNSUPPORTED' : 'INTERNAL';
+      if (code === 'INTERNAL') log(`[cli-install] ${tool} could not start: ${error?.message || error}`);
+      if (stream) return stream.end({ type: 'done', ok: false, code: 'internal', error: String(error?.message || error) });
+      return res.status(code === 'BUSY' ? 409 : code === 'UNSUPPORTED' ? 422 : 500).json({ ok: false, code, error: String(error?.message || error) });
+    }
+    if (!stream) stream = openNdjsonStream(res);
+    stream.onAbort(() => started.unsubscribe());
+  });
+
+  return router;
+}
+
+/**
+ * /api/cli/git-bash: the Git Bash every Claude Code SynaBun starts gets on Windows (lib/git-bash/manager.js),
+ * beside the CLIs' install and PATH, with the same guards.
+ *
+ *   GET  /           { ok, state: unsupported | system | ready | missing | downloading | failed, … }
+ *   POST /install    start the download of SynaBun's copy now (Settings: Download, Try again); answers at once,
+ *                    the page follows it with GET. 422 UNSUPPORTED where there is no Windows Git to fetch
+ *   POST /recheck    look again (a Git for Windows installed meanwhile), then the status
+ *
+ * A request names nothing: what is downloaded is the pinned release (lib/git-bash/pins.json), and a body is refused.
+ */
+export function createGitBashApi({ manager, onRecheck = async () => {}, isGuestRequest, port } = {}) {
+  if (!manager) throw new Error('createGitBashApi needs the Git Bash manager');
+  const { router, mutating } = localCliRouter({ isGuestRequest, port });
+  const noBody = (req, res, next) => (Object.keys(req.body || {}).length ? res.status(400).json({ ok: false, code: 'UNEXPECTED_BODY' }) : next());
+  router.get('/', (req, res) => { res.json({ ok: true, ...manager.status() }); });
+  router.post('/install', ...mutating, noBody, (req, res) => {
+    const before = manager.status();
+    if (before.state === 'unsupported') return res.status(422).json({ ok: false, code: 'UNSUPPORTED', ...before });
+    manager.ensure({ reason: 'settings' });
+    res.json({ ok: true, ...manager.status() });
+  });
+  router.post('/recheck', ...mutating, noBody, async (req, res) => {
+    manager.refresh();
+    try { await onRecheck(); } catch { /* the status says what is known */ }
+    res.json({ ok: true, ...manager.status() });
+  });
+  return router;
+}
+
+/** The same owner/localhost/Origin/UI guards as Install. Never accepts a folder. */
+export function createCliPathApi({ pathManager, resolver, diagnostics = async () => ({}), isGuestRequest, port } = {}) {
+  const { router, mutating } = localCliRouter({ isGuestRequest, port });
+  router.get('/', async (req, res) => {
+    try { res.json({ ok: true, ...await diagnostics() }); }
+    catch (error) { res.status(500).json({ ok: false, error: error.message }); }
+  });
+  router.post('/:tool', ...mutating, async (req, res) => {
+    if (!INSTALLABLE_TOOLS.includes(req.params.tool)) return res.status(400).json({ ok: false, code: 'UNKNOWN_TOOL' });
+    if (Object.keys(req.body || {}).length) return res.status(400).json({ ok: false, code: 'UNEXPECTED_BODY' });
+    try {
+      const status = await resolver.resolve(req.params.tool, { force: true });
+      const result = await pathManager.add(status);
+      if (!result.changed) return res.status(409).json({ ok: false, code: 'NOT_NEEDED', ...result });
+      res.json({ ok: true, ...result });
+    } catch (error) { res.status(error.status || 500).json({ ok: false, error: error.message }); }
+  });
+  return router;
+}