@arthovlabs/liber 0.7.2 → 0.7.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arthovlabs/liber",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "LiBER — autonomous agent orchestrator with a machine-enforced grounding gate and a skill library",
   "bin": {
     "liber": "bin/liber",

package/src/daemon/core/tools/terminal-tool.js

@@ -301,43 +301,88 @@ function containerPolicy() {
   };
 }
 
-let _dockerCache = null;
-/** Is a Docker daemon reachable? Cached for a minute; the check costs ~50ms. */
-function containerAvailable(force = false) {
-  if (!force && _dockerCache && Date.now() - _dockerCache.at < 60_000) return _dockerCache.ok;
-  let ok = false;
-  try {
-    const out = require('child_process').execFileSync('docker', ['version', '--format', '{{.Server.Version}}'],
-      { timeout: 8000, windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'] });
-    ok = String(out).trim().length > 0;
-  } catch { ok = false; }
-  _dockerCache = { ok, at: Date.now() };
-  return ok;
+let _dockerCache = { ok: false, at: 0, checked: false, version: null };
+let _wslCache = { ok: false, at: 0, checked: false };
+
+/**
+ * Cached answer only — never probes. The probe is a synchronous child process and
+ * blocks the whole daemon: this used to cost 8 s per call, so a single /sandbox poll
+ * made /workspace look like it took 12 s and the UI piled requests on top of it.
+ */
+function containerAvailable() {
+  return _dockerCache.checked && _dockerCache.ok;
+}
+
+/** Last probe result, without touching the runtime. */
+function containerSnapshot() {
+  return { ..._dockerCache };
+}
+
+/**
+ * Probe docker (and wsl) asynchronously and cache the result. Safe to call on every
+ * /sandbox: within the TTL it returns immediately, and it never blocks the event loop.
+ */
+async function probeContainers({ force = false } = {}) {
+  const TTL = 60_000;
+  if (!force && _dockerCache.checked && Date.now() - _dockerCache.at < TTL) return containerSnapshot();
+
+  const { execFile } = require('child_process');
+  const run = (file, args, timeout) => new Promise((resolve) => {
+    execFile(file, args, { timeout, windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'] },
+      (err, stdout) => resolve(err ? null : String(stdout || '').trim()));
+  });
+
+  const version = await run('docker', ['version', '--format', '{{.Server.Version}}'], 1500);
+  _dockerCache = { ok: !!version, at: Date.now(), checked: true, version: version || null };
+
+  if (!_dockerCache.ok) {
+    _runCache = { ok: false, image: (_runCache && _runCache.image) || 'alpine:latest', at: Date.now(), error: 'docker daemon not reachable' };
+  }
+
+  const wsl = process.platform === 'win32' ? await run('wsl.exe', ['-l', '-q'], 2000) : '';
+  _wslCache = { ok: !!wsl && wsl.replace(/\0/g, '').trim().length > 0, at: Date.now(), checked: true };
+
+  return containerSnapshot();
+}
+
+function wslAvailable() {
+  return _wslCache.checked && _wslCache.ok;
 }
 
 let _runCache = null;
 /**
  * Can this machine actually START a container with the configured image?
- * A reachable daemon is not the same thing: a CI runner can have the CLI and a
- * server version and still refuse to run (no image, no permissions). Checking by
- * running is the only honest answer, and it is cached because it costs ~1s.
+ * Reads the cache only; `probeContainers()` is what fills it, including the far more
+ * expensive "run something" check (a reachable daemon can still refuse to run).
  */
 function containerUsable(force = false, image = 'alpine:latest') {
-  if (!force && _runCache && _runCache.image === image && Date.now() - _runCache.at < 300_000) return _runCache;
-  if (!containerAvailable(force)) {
+  if (_runCache && _runCache.image === image && Date.now() - _runCache.at < 300_000) return _runCache;
+  if (!containerAvailable()) {
     _runCache = { ok: false, image, at: Date.now(), error: 'docker daemon not reachable' };
     return _runCache;
   }
-  let ok = false;
-  let error = null;
+  // Daemon is up but nothing has proven it can run this image yet: probe in the
+  // background and fail closed for now rather than blocking the caller.
+  probeRun(image).catch(() => {});
+  _runCache = { ok: false, image, at: Date.now(), error: 'container run not verified yet' };
+  return _runCache;
+}
+
+let _probingRun = false;
+async function probeRun(image = 'alpine:latest') {
+  if (_probingRun) return _runCache;
+  _probingRun = true;
   try {
-    require('child_process').execFileSync('docker', ['run', '--rm', '--network', 'none', image, 'true'],
-      { timeout: 60000, windowsHide: true, stdio: ['ignore', 'ignore', 'pipe'] });
-    ok = true;
-  } catch (e) {
-    error = String(e.stderr || e.message || 'container run failed').slice(0, 200);
+    const { execFile } = require('child_process');
+    const ok = await new Promise((resolve) => {
+      execFile('docker', ['run', '--rm', '--network', 'none', image, 'true'],
+        { timeout: 20000, windowsHide: true, stdio: ['ignore', 'ignore', 'pipe'] },
+        (err) => resolve(!err));
+    });
+    _runCache = { ok, image, at: Date.now(), error: ok ? null : 'container run failed' };
+  } finally {
+    _probingRun = false;
   }
-  _runCache = { ok, image, at: Date.now(), error };
   return _runCache;
 }
 
@@ -516,5 +561,8 @@ module.exports = {
   sandboxEnv,
   containerPolicy,
   containerAvailable,
+  containerSnapshot,
+  probeContainers,
+  wslAvailable,
   containerUsable
 };

package/src/daemon/core/workspace.js

@@ -42,10 +42,19 @@ function branch() {
  */
 function changedFiles(limit = 40) {
   if (!isGitRepo()) return [];
-  const status = sh('git', ['status', '--porcelain=v1', '--untracked-files=all']);
-  if (!status) return [];
+  // --untracked-files=all walked the entire parent repository on every poll (the
+  // data directory lives inside the user's home repo). Cap it in time and breadth:
+  // a workspace view needs the shape of the change, not an exhaustive census.
+  const status = sh('git', ['status', '--porcelain=v1', '--untracked-files=normal'], { timeout: 1500 });
+  if (!status) {
+    // Timed out: this directory sits in a repository too large to walk per request.
+    // Remember that, so the next polls hit the cache instead of stalling again.
+    _slowRepo = true;
+    return [];
+  }
+  _slowRepo = false;
 
-  const numstat = sh('git', ['diff', '--numstat', 'HEAD']) || '';
+  const numstat = sh('git', ['diff', '--numstat', 'HEAD'], { timeout: 1500 }) || '';
   const stats = new Map();
   for (const line of numstat.split('\n')) {
     const m = line.match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
@@ -78,12 +87,24 @@ function changedFiles(limit = 40) {
 }
 
 function summary(limit = 40) {
+  // Polled every 20 s by the shell. On a machine whose data directory sits inside a
+  // large parent repository (a home directory that happens to be a git repo), the
+  // status walk cost seconds per poll and starved every other request. Cache it.
+  const now = Date.now();
+  // A repository too large to walk gets a much longer TTL: the view is cached for a
+  // minute instead of four seconds, and says it was truncated rather than pretending.
+  const ttl = _slowRepo ? 60000 : 4000;
+  // Keyed by directory: a workspace switch (or a test) must not read the previous
+  // repository's answer from the cache.
+  if (_summaryCache.value && _summaryCache.cwd === process.cwd() && now - _summaryCache.at < ttl) return _summaryCache.value;
+
   const files = changedFiles(limit);
   const git = isGitRepo();
-  return {
+  const value = {
     cwd: process.cwd(),
     is_git: git,
     branch: git ? branch() : null,
+    truncated: _slowRepo,
     changed_files: files,
     totals: {
       files: files.length,
@@ -91,7 +112,11 @@ function summary(limit = 40) {
       deletions: files.reduce((a, f) => a + (f.deletions || 0), 0)
     }
   };
+  _summaryCache = { at: now, cwd: process.cwd(), value };
+  return value;
 }
+let _summaryCache = { at: 0, value: null };
+let _slowRepo = false;
 
 /** Record one tool step the engine actually ran (fed from turn events). */
 function record(event) {

package/src/daemon/liberd.js

@@ -17,6 +17,22 @@ const guard = require('./core/http-guard');
 
 // ceiling for the routes that answer without a token
 const unauth = guard.createThrottle();
+
+// A shell that polls without a token used to write one log line per request: 12,239
+// of them in a day. Keep the signal, drop the flood.
+const authFailLog = new Map();
+function logAuthFailure(endpoint, ip) {
+  const key = endpoint + '|' + ip;
+  const now = Date.now();
+  const prev = authFailLog.get(key) || { at: 0, count: 0 };
+  if (now - prev.at > 60000) {
+    logger.warn('SYSTEM', 'AUTH_FAILED', { endpoint, ip, suppressed_since_last: prev.count });
+    authFailLog.set(key, { at: now, count: 0 });
+  } else {
+    prev.count += 1;
+    authFailLog.set(key, prev);
+  }
+}
 const policy = require('./core/policy');
 const journal = require('./core/journal');
 const modelSwitch = require('./core/model-switch');
@@ -249,6 +265,9 @@ class LiberDaemon {
       const bind = () => {
         this.server.listen(this.port, host, () => {
           logger.info('SYSTEM', 'DAEMON_START', { port: this.port, host, cwd: process.cwd() });
+          // Warm the sandbox probe so the first /sandbox (the shell asks on boot) does
+          // not have to wait for docker to answer — or for it to time out.
+          try { require('./core/tools/terminal-tool').probeContainers().catch(() => {}); } catch { /* tool not loaded */ }
         });
       };
       this.server.on('error', (err) => {
@@ -415,7 +434,7 @@ class LiberDaemon {
         success: false,
         error: 'Unauthorized. Send Authorization: Bearer <token>. The desktop token lives in .liber/daemon.token; other clients get their own from /clients (scope admin).'
       }));
-      logger.warn('SYSTEM', 'AUTH_FAILED', { endpoint, ip: req.socket.remoteAddress });
+      logAuthFailure(endpoint, req.socket.remoteAddress);
       auth.audit({ client: null, ip: req.socket.remoteAddress, method: req.method, endpoint, decision: 'deny', reason: 'bad token' });
       return;
     }
@@ -933,18 +952,13 @@ class LiberDaemon {
         if (req.method === 'GET') {
           const term = policy.terminalConfig();
           const terminalTool = require('./core/tools/terminal-tool');
-          const dockerOk = terminalTool.containerAvailable(true);
-          let dockerVersion = null;
-          if (dockerOk) {
-            try {
-              dockerVersion = String(require('child_process').execFileSync('docker', ['version', '--format', '{{.Server.Version}}'], { timeout: 8000, windowsHide: true })).trim();
-            } catch { dockerVersion = null; }
-          }
-          let wsl = false;
-          try {
-            const out = require('child_process').execFileSync('wsl.exe', ['-l', '-q'], { timeout: 8000, windowsHide: true });
-            wsl = String(out).replace(/\0/g, '').trim().length > 0;
-          } catch { wsl = false; }
+          // Probing docker synchronously here used to block the whole daemon for 8 s
+          // (plus 8 s for wsl), which made every other poll look stalled. The probe is
+          // now async and cached; on a warm cache this returns in microseconds.
+          const snap = await terminalTool.probeContainers();
+          const dockerOk = snap.ok;
+          const dockerVersion = snap.version;
+          const wsl = terminalTool.wslAvailable();
           res.end(JSON.stringify({
             success: true,
             backend: term.backend,