@xmarts/genius-setup 1.8.0 → 1.10.0

package/bin/genius-setup.js

@@ -123,16 +123,17 @@ function runSetup(token) {
     if (secret) { try { fs.chmodSync(p, 0o600); } catch (_) {} }
   }
 
-  // 1) ~/.genius/config.json + hook
+  // 1) ~/.genius/config.json + hook. MERGE into any existing config so state we
+  //    track across runs (e.g. managed_mcp_keys for MCP de-provisioning) survives.
   ensureDir(HOOKS_DIR);
-  const cfg = {
-    base_url: BASE,
-    token: token,
-    capture_endpoint: BASE + '/xma/genius/v1/capture/transcript',
-    inject_endpoint: BASE + '/xma/genius/v1/inject',
-  };
+  const cfgPath0 = path.join(GENIUS_DIR, 'config.json');
+  const cfg = readJson(cfgPath0);
+  cfg.base_url = BASE;
+  cfg.token = token;
+  cfg.capture_endpoint = BASE + '/xma/genius/v1/capture/transcript';
+  cfg.inject_endpoint = BASE + '/xma/genius/v1/inject';
   if (CLIENT) cfg.target_client = CLIENT;
-  writeJson(path.join(GENIUS_DIR, 'config.json'), cfg, true);  // secret: 0600
+  writeJson(cfgPath0, cfg, true);  // secret: 0600
 
   // Copy the hooks shipped alongside this script (capture + per-turn inject).
   function copyHook(fname) {
@@ -149,6 +150,7 @@ function runSetup(token) {
   const hookDst = copyHook('genius_capture.py');
   const injectDst = copyHook('genius_inject.py');
   const guardDst = copyHook('plan_committee_guard.py');
+  const presenceDst = copyHook('genius_presence.py');
 
   // 2) ~/.claude.json mcpServers (merge, no clobber)
   const claudeJsonPath = path.join(HOME, '.claude.json');
@@ -186,6 +188,18 @@ function runSetup(token) {
   // (XMA_PLAN_GUARD_MODE=block|warn|off). Unlike the fire-and-forget hooks above, this
   // one can return {"decision":"block"} — by design — but never traps a session.
   addHook('Stop', guardDst);
+  // Presence heartbeat (time-tracking "amarre"): binds worked time to THIS machine's
+  // clock — counts VSCode edits + executing loops/workflows, excludes idle-open VSCode.
+  // Unlike every hook above, this is a LONG-LIVED daemon (loops up to ~18h), so it MUST be
+  // launched DETACHED (nohup ... & disown) — never as a blocking `python3 X || true`, which
+  // would freeze every SessionStart. A single-instance lock + self-terminate make repeated
+  // SessionStart launches safe. POSIX form; mirrors the proven admin-bootstrap installer.
+  settings.hooks.SessionStart = settings.hooks.SessionStart || [];
+  if (!JSON.stringify(settings.hooks.SessionStart).includes('genius_presence.py')) {
+    const presenceCmd = 'nohup python3 ' + JSON.stringify(presenceDst) +
+      ' --cwd "${CLAUDE_PROJECT_DIR:-$PWD}" >/dev/null 2>&1 & disown 2>/dev/null; true';
+    settings.hooks.SessionStart.push({ hooks: [{ type: 'command', command: presenceCmd }] });
+  }
   writeJson(settingsPath, settings);
 
   // 4) ~/.claude/CLAUDE.md — install/refresh the Genius Protocol between auto-managed
@@ -211,12 +225,104 @@ function runSetup(token) {
     log('WARN: could not write CLAUDE.md protocol (' + e.message + ')');
   }
 
+  // 5) Fan out the consultant's OTHER MCP servers (asana, clickup, google, ...).
+  //    Their non-secret shape (manifest) + per-device secret VALUES come from the
+  //    Bearer-authed /xma/genius/v1/mcp/secrets endpoint. We write Claude Code
+  //    always and Claude Desktop only if it is installed. Fail-open: a fetch
+  //    error never breaks onboarding. Re-runs (self-update / epoch bump) converge.
+  function desktopConfigPath() {
+    try {
+      if (process.platform === 'darwin')
+        return path.join(HOME, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+      if (process.platform === 'win32')
+        return path.join(process.env.APPDATA || path.join(HOME, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+      return path.join(HOME, '.config', 'Claude', 'claude_desktop_config.json');
+    } catch (_) { return ''; }
+  }
+  function mcpEntry(srv, secrets, host) {
+    // One mcpServers entry, or null if a required secret is missing (never write a
+    // half-broken server) or it is not portable to this host.
+    const env = {};
+    let ok = true;
+    (srv.env_keys || []).forEach((k) => { if (secrets[k]) env[k] = secrets[k]; else ok = false; });
+    if (!ok) return null;
+    const isHttp = srv.transport === 'http' || srv.transport === 'sse';
+    if (host === 'desktop') {
+      if (srv.host_targets !== 'both' || srv.desktop_strategy === 'skip') return null;
+      if (isHttp) return { command: 'npx', args: ['-y', 'mcp-remote', srv.url] }; // stdio-only Desktop
+      const e = { command: srv.command, args: srv.args || [] };
+      if (Object.keys(env).length) e.env = env;
+      return e;
+    }
+    if (isHttp) return { type: srv.transport, url: srv.url };
+    const e = { type: 'stdio', command: srv.command, args: srv.args || [] };
+    if (Object.keys(env).length) e.env = env;
+    return e;
+  }
+  function writeHostMcps(cfgPath, manifest, secrets, host, prevKeys) {
+    let obj = readJson(cfgPath);
+    if (!obj || typeof obj !== 'object') obj = {};
+    backup(cfgPath);
+    obj.mcpServers = obj.mcpServers || {};
+    // De-provision: drop servers WE previously managed that are no longer granted.
+    (prevKeys || []).forEach((k) => {
+      if (obj.mcpServers[k] && !manifest.find((s) => s.key === k)) delete obj.mcpServers[k];
+    });
+    const nowKeys = [];
+    manifest.forEach((srv) => {
+      const entry = mcpEntry(srv, secrets, host);
+      if (entry) { obj.mcpServers[srv.key] = entry; nowKeys.push(srv.key); }
+      else if (obj.mcpServers[srv.key] && (prevKeys || []).includes(srv.key)) {
+        delete obj.mcpServers[srv.key]; // lost its secret / portability -> remove
+      }
+    });
+    writeJson(cfgPath, obj, true); // may carry env secrets -> 0600
+    return nowKeys;
+  }
+  function provisionMcps(token) {
+    let url;
+    try { url = new URL(BASE + '/xma/genius/v1/mcp/secrets'); } catch (_) { return; }
+    const mod = url.protocol === 'http:' ? require('http') : require('https');
+    const payload = JSON.stringify({ jsonrpc: '2.0', method: 'call', id: 1, params: {} });
+    const req = mod.request({
+      hostname: url.hostname, port: url.port || (url.protocol === 'http:' ? 80 : 443),
+      path: url.pathname, method: 'POST',
+      headers: {
+        'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload),
+        'Authorization': 'Bearer ' + token, 'User-Agent': 'XmartsGenius-Setup/1.6.0',
+      },
+      timeout: 15000,
+    }, (res) => {
+      let data = ''; res.on('data', (c) => { data += c; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data); const r = parsed.result || parsed;
+          if (!r || r.status !== 'ok' || !Array.isArray(r.manifest)) return;
+          const secrets = r.secrets || {};
+          const cfgPath = path.join(GENIUS_DIR, 'config.json');
+          const prev = (readJson(cfgPath).managed_mcp_keys) || [];
+          const managed = writeHostMcps(path.join(HOME, '.claude.json'), r.manifest, secrets, 'code', prev);
+          const dp = desktopConfigPath();
+          if (dp && (fs.existsSync(dp) || fs.existsSync(path.dirname(dp)))) {
+            try { writeHostMcps(dp, r.manifest, secrets, 'desktop', prev); } catch (_) {}
+          }
+          try { const c = readJson(cfgPath); c.managed_mcp_keys = managed; writeJson(cfgPath, c, true); } catch (_) {}
+          if (managed.length) log('  - MCP fan-out   : ' + managed.join(', '));
+        } catch (_) {}
+      });
+    });
+    req.on('error', () => {}); req.on('timeout', () => { try { req.destroy(); } catch (_) {} });
+    req.write(payload); req.end();
+  }
+  provisionMcps(token);
+
   log('');
   log('  Xmarts Genius is set up.');
   log('  - MCP server     : beesmart_genius -> ' + BASE + '/mcp/consultant');
   log('  - Capture hook   : ' + hookDst + '  (SessionEnd / PreCompact / Stop)');
   log('  - Inject hook    : ' + injectDst + '  (UserPromptSubmit / SessionStart)');
   log('  - Plan/committee : ' + guardDst + '  (Stop — enforces plan/comité → Brain; XMA_PLAN_GUARD_MODE=block|warn|off)');
+  log('  - Presence       : ' + presenceDst + '  (SessionStart, detached — honest time-tracking amarre)');
   log('  - Config         : ' + path.join(GENIUS_DIR, 'config.json'));
   log('  - Protocol       : ' + path.join(CLAUDE_DIR, 'CLAUDE.md') + '  (auto-managed)');
   if (CLIENT) log('  - Default client : ' + CLIENT);

package/hooks/genius_inject.py

@@ -25,6 +25,7 @@ TIMEOUT = 3.5
 SELF_UPDATE_TTL = 86400  # at most once/day
 SELF_UPDATE_STAMP = os.path.join(HOME, ".genius", ".last_selfupdate")
 FORCE_STAMP = os.path.join(HOME, ".genius", ".last_forced_epoch")
+MCP_EPOCH_STAMP = os.path.join(HOME, ".genius", ".last_mcp_epoch")
 
 SESSION_PRIMER = (
     "[Xmarts Genius — Brain connected]\n"
@@ -77,9 +78,10 @@ def _inject(cfg, prompt):
         result = data.get("result", data) or {}
         return ((result.get("context", "") or ""),
                 result.get("hook_force_epoch"),
-                result.get("hook_pin_version"))
+                result.get("hook_pin_version"),
+                result.get("mcp_manifest_epoch"))
     except Exception:
-        return "", None, None
+        return "", None, None, None
 
 
 # M6 (Phase-0 integrity gate): NEVER resolve `@latest`. An unsigned `npx @latest`
@@ -101,7 +103,7 @@ def _pkg_spec(pin_version):
     return "@xmarts/genius-setup@%s" % PINNED_FALLBACK
 
 
-def _maybe_self_update(cfg, force_epoch=None, pin_version=None):
+def _maybe_self_update(cfg, force_epoch=None, pin_version=None, mcp_epoch=None):
     """Keep the consultant on the SERVER-PINNED Genius package with ZERO action: at most
     once/day, silently re-run the installer in the background. New hooks, MCP
     tools, settings and the CLAUDE.md protocol then flow automatically — the
@@ -129,6 +131,18 @@ def _maybe_self_update(cfg, force_epoch=None, pin_version=None):
                 forced = fe > last
             except Exception:
                 forced = False
+        # MCP fan-out reconvergence: a newer manifest epoch forces an immediate
+        # re-run (re-provisions ~/.claude.json + Desktop), bypassing the daily TTL.
+        if not forced and mcp_epoch:
+            try:
+                me = int(mcp_epoch)
+                lastm = 0
+                if os.path.exists(MCP_EPOCH_STAMP):
+                    with open(MCP_EPOCH_STAMP) as fh:
+                        lastm = int((fh.read() or "0").strip() or 0)
+                forced = me > lastm
+            except Exception:
+                pass
         if not forced and os.path.exists(SELF_UPDATE_STAMP) and (
                 time.time() - os.path.getmtime(SELF_UPDATE_STAMP)) < SELF_UPDATE_TTL:
             return
@@ -140,6 +154,9 @@ def _maybe_self_update(cfg, force_epoch=None, pin_version=None):
             if force_epoch:
                 with open(FORCE_STAMP, "w") as fh:
                     fh.write(str(int(force_epoch)))
+            if mcp_epoch:
+                with open(MCP_EPOCH_STAMP, "w") as fh:
+                    fh.write(str(int(mcp_epoch)))
         except Exception:
             return
         env = dict(os.environ)
@@ -174,11 +191,12 @@ def main():
         _maybe_self_update(cfg)   # TTL-only on priming
         _emit("SessionStart", SESSION_PRIMER)
     else:
-        context, force_epoch, pin_version = _inject(cfg, event.get("prompt") or "")
+        context, force_epoch, pin_version, mcp_epoch = _inject(cfg, event.get("prompt") or "")
         # The inject call already round-tripped the server, so honour any
         # admin-pushed force-update epoch here (bypasses the daily TTL) and install
-        # the exact server-pinned version (never @latest).
-        _maybe_self_update(cfg, force_epoch, pin_version)
+        # the exact server-pinned version (never @latest). A newer MCP manifest
+        # epoch likewise forces an immediate re-provision of the fan-out servers.
+        _maybe_self_update(cfg, force_epoch, pin_version, mcp_epoch)
         _emit("UserPromptSubmit", context)
 
 

package/hooks/genius_presence.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""Genius presence heartbeat (amarre v2, Phase 2) — CONSERVATIVE.
+
+Emits one presence ping (~every PING_INTERVAL) to the Genius capture/presence endpoint
+ONLY when there is REAL recent activity, so it binds worked-time to the consultant's
+machine clock without counting an idle-open VSCode:
+
+  ACTIVE  := a workspace SOURCE file was edited in the last IDLE_WINDOW   (human work)
+          OR the Claude transcript / agent files grew in the last IDLE_WINDOW
+             (a /loop or Workflow is executing — counts even with no human interaction)
+  IDLE    := neither -> NO ping (VSCode open but nothing running is NOT counted)
+
+Metadata only: workspace path + git branch (for project classification + retroactive
+attribution) + machine-clock timestamp + tz. No transcript content. Never blocks, always
+exit 0. Single-instance per machine (lockfile). Self-terminates when the Claude session
+is gone (transcript dir idle > STOP_IDLE) or after MAX_LIFETIME.
+"""
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+import urllib.request
+
+HOME = os.path.expanduser("~")
+CFG = os.path.join(HOME, ".genius", "config.json")
+LOCK = os.path.join(HOME, ".genius", "presence.lock")
+STOP_FLAG = os.path.join(HOME, ".genius", "presence.stop")
+PROJECTS = os.path.join(HOME, ".claude", "projects")
+
+PING_INTERVAL = 300        # 5 min between ticks
+IDLE_WINDOW = 600          # a file touched in the last 10 min => active this tick
+STOP_IDLE = 2700           # Claude dir quiet 45 min => session over, exit
+MAX_LIFETIME = 18 * 3600   # hard stop
+SKIP_DIRS = {".git", "node_modules", "__pycache__", ".next", "dist", "build",
+             ".venv", "venv", ".mypy_cache", ".pytest_cache", "outbox"}
+
+
+def _cfg():
+    try:
+        with open(CFG) as fh:
+            return json.load(fh)
+    except Exception:
+        return {}
+
+
+def _recent(path, window_s, budget_s=2.0):
+    """True if any non-skipped file under path has mtime within window_s. Bounded by a
+    small wall-clock budget so a huge tree never stalls a tick. Early-returns."""
+    cutoff = time.time() - window_s
+    deadline = time.time() + budget_s
+    try:
+        for root, dirs, files in os.walk(path):
+            dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith(".")]
+            for f in files:
+                try:
+                    if os.path.getmtime(os.path.join(root, f)) >= cutoff:
+                        return True
+                except OSError:
+                    pass
+            if time.time() > deadline:
+                break
+    except OSError:
+        pass
+    return False
+
+
+def _project_dir(cwd):
+    """Best-effort: the ~/.claude/projects/<slug> dir for this cwd, else the most
+    recently-modified project dir (the active session)."""
+    slug = re.sub(r"[^A-Za-z0-9]+", "-", cwd)
+    cand = os.path.join(PROJECTS, slug)
+    if os.path.isdir(cand):
+        return cand
+    # fallback: most-recently-touched project dir
+    try:
+        best, best_m = None, 0
+        for d in os.listdir(PROJECTS):
+            p = os.path.join(PROJECTS, d)
+            if os.path.isdir(p):
+                m = os.path.getmtime(p)
+                if m > best_m:
+                    best, best_m = p, m
+        return best
+    except OSError:
+        return None
+
+
+def _git_branch(cwd):
+    try:
+        out = subprocess.run(["git", "-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"],
+                             capture_output=True, text=True, timeout=3)
+        b = (out.stdout or "").strip()
+        return b if b and b != "HEAD" else ""
+    except Exception:
+        return ""
+
+
+def _post(cfg, payload):
+    base = (cfg.get("base_url") or "").rstrip("/")
+    token = cfg.get("token") or ""
+    if not base or not token:
+        return False
+    url = base + "/xma/genius/v1/capture/presence"
+    body = json.dumps({"jsonrpc": "2.0", "method": "call",
+                       "params": payload, "id": 1}).encode()
+    req = urllib.request.Request(url, data=body, method="POST")
+    req.add_header("Content-Type", "application/json")
+    req.add_header("Authorization", "Bearer " + token)
+    req.add_header("User-Agent", "GeniusPresence/1.0")  # WAF blocks default Python-urllib UA
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            json.loads(resp.read().decode("utf-8", "replace") or "{}")
+        return True
+    except Exception:
+        return False
+
+
+def _work_mode(cwd, claude_dir):
+    """Label HOW the work is happening (owner: loop/workflow vs short interactions).
+    A workspace edit = the human is present -> interactive. Otherwise, if a Workflow/
+    subagent run is active -> autonomous (Claude working alone, e.g. overnight). Default
+    interactive (a normal Claude turn)."""
+    if _recent(cwd, IDLE_WINDOW):
+        return "interactive"
+    if claude_dir:
+        for sub in ("subagents", os.path.join("subagents", "workflows")):
+            if _recent(os.path.join(claude_dir, sub), IDLE_WINDOW, budget_s=1.5):
+                return "autonomous"
+    return "interactive"
+
+
+def _ping(cfg, cwd, session_ref, claude_dir):
+    payload = {
+        "session_ref": session_ref,
+        "occurred_at_epoch": time.time(),
+        "utc_offset_minutes": -int(time.timezone // 60) if not time.daylight
+                              else -int(time.altzone // 60),
+        "workspace": cwd[:256],
+        "git_branch": _git_branch(cwd)[:128],
+        "surface": "vscode",
+        "work_mode": _work_mode(cwd, claude_dir),
+    }
+    return _post(cfg, payload)
+
+
+def _is_active(cwd, claude_dir):
+    """Conservative: real work signal in the last IDLE_WINDOW — human edit OR Claude
+    execution (loop/workflow). Idle-open VSCode touches no file -> not active."""
+    if _recent(cwd, IDLE_WINDOW):
+        return True
+    if claude_dir and _recent(claude_dir, IDLE_WINDOW):
+        return True
+    return False
+
+
+def _claude_idle_too_long(claude_dir):
+    return not (claude_dir and _recent(claude_dir, STOP_IDLE, budget_s=2.0))
+
+
+def main():
+    args = sys.argv[1:]
+    once = "--once" in args
+    cwd = os.getcwd()
+    session_ref = "vscode:%s" % time.strftime("%Y-%m-%d")
+    for i, a in enumerate(args):
+        if a == "--cwd" and i + 1 < len(args):
+            cwd = args[i + 1]
+        if a == "--session" and i + 1 < len(args):
+            session_ref = args[i + 1]
+    cfg = _cfg()
+    claude_dir = _project_dir(cwd)
+
+    if once:
+        active = _is_active(cwd, claude_dir)
+        ok = _ping(cfg, cwd, session_ref, claude_dir) if active else False
+        print(json.dumps({"active": active, "posted": ok, "cwd": cwd,
+                          "claude_dir": claude_dir, "session_ref": session_ref}))
+        return
+
+    # single-instance lock
+    try:
+        if os.path.exists(LOCK):
+            with open(LOCK) as fh:
+                pid = int((fh.read() or "0").strip() or 0)
+            if pid:
+                try:
+                    os.kill(pid, 0)   # alive?
+                    return            # another daemon owns it
+                except OSError:
+                    pass
+        with open(LOCK, "w") as fh:
+            fh.write(str(os.getpid()))
+    except Exception:
+        pass
+
+    start = time.time()
+    try:
+        while True:
+            if os.path.exists(STOP_FLAG):
+                break
+            if time.time() - start > MAX_LIFETIME:
+                break
+            claude_dir = _project_dir(cwd)  # refresh (slug may resolve later)
+            if _is_active(cwd, claude_dir):
+                _ping(cfg, cwd, session_ref, claude_dir)
+            elif _claude_idle_too_long(claude_dir):
+                break  # session truly over
+            time.sleep(PING_INTERVAL)
+    finally:
+        try:
+            if os.path.exists(LOCK):
+                os.remove(LOCK)
+        except OSError:
+            pass
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        pass
+    sys.exit(0)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xmarts/genius-setup",
-  "version": "1.8.0",
-  "description": "One-command, self-updating onboarding for Xmarts Genius (Brain MCP + per-turn injection + automatic session/time capture + plan/committee→Brain enforcement + CLAUDE.md protocol). Secret-free onboarding via single-use setup-token exchange (no Bearer in the GET-able bootstrap). Installs once; self-updates daily so new tools/skills/features arrive with zero action.",
+  "version": "1.10.0",
+  "description": "One-command, self-updating onboarding for Xmarts Genius (Brain MCP + per-turn injection + automatic session/time capture + presence heartbeat for honest time-tracking 'amarre' + plan/committee→Brain enforcement + CLAUDE.md protocol + MCP fan-out: provisions the consultant's granted MCP servers into Claude Code & Claude Desktop). Secret-free onboarding via single-use setup-token exchange. Installs once; self-updates daily so new tools/skills/features arrive with zero action.",
   "bin": {
     "genius-setup": "bin/genius-setup.js"
   },
@@ -10,6 +10,7 @@
     "hooks/genius_inject.py",
     "hooks/genius_capture.py",
     "hooks/plan_committee_guard.py",
+    "hooks/genius_presence.py",
     "CLAUDE_PROTOCOL.md",
     "README.md"
   ],