@geravant/sinain 1.0.8 → 1.0.9

package/install.js

@@ -3,40 +3,37 @@ import fs from "fs";
 import path from "path";
 import os from "os";
 import { execSync } from "child_process";
-import { randomBytes } from "crypto";
 
-const HOME       = os.homedir();
+const HOME        = os.homedir();
 const PLUGIN_DIR  = path.join(HOME, ".openclaw/extensions/sinain-hud");
 const SOURCES_DIR = path.join(HOME, ".openclaw/sinain-sources");
 const OC_JSON     = path.join(HOME, ".openclaw/openclaw.json");
 const WORKSPACE   = path.join(HOME, ".openclaw/workspace");
 
 // PKG_DIR = sinain-hud-plugin/ inside the npm package
-const PKG_DIR  = path.dirname(new URL(import.meta.url).pathname);
+const PKG_DIR    = path.dirname(new URL(import.meta.url).pathname);
 const MEMORY_SRC = path.join(PKG_DIR, "sinain-memory");
 const HEARTBEAT  = path.join(PKG_DIR, "HEARTBEAT.md");
 
 console.log("\nInstalling sinain plugin...");
 
-// 1. Copy plugin files (remove stale extensions/sinain dir if present from old installs)
-const stalePluginDir = path.join(HOME, ".openclaw/extensions/sinain");
-if (fs.existsSync(stalePluginDir)) fs.rmSync(stalePluginDir, { recursive: true, force: true });
+// 1. Stage plugin files to local ~/.openclaw (used by both paths)
 fs.mkdirSync(PLUGIN_DIR, { recursive: true });
 fs.copyFileSync(path.join(PKG_DIR, "index.ts"),             path.join(PLUGIN_DIR, "index.ts"));
 fs.copyFileSync(path.join(PKG_DIR, "openclaw.plugin.json"), path.join(PLUGIN_DIR, "openclaw.plugin.json"));
 console.log("  ✓ Plugin files copied");
 
-// 2. Copy sinain-memory from bundled package files
+// 2. Stage sinain-memory
 fs.mkdirSync(SOURCES_DIR, { recursive: true });
 const memoryDst = path.join(SOURCES_DIR, "sinain-memory");
 copyDir(MEMORY_SRC, memoryDst);
 console.log("  ✓ sinain-memory copied");
 
-// 3. Copy HEARTBEAT.md
+// 3. Stage HEARTBEAT.md
 fs.copyFileSync(HEARTBEAT, path.join(SOURCES_DIR, "HEARTBEAT.md"));
 console.log("  ✓ HEARTBEAT.md copied");
 
-// 4. Install Python deps
+// 4. Install Python deps (for local bare-metal path; harmless to run here)
 const reqFile = path.join(memoryDst, "requirements.txt");
 if (fs.existsSync(reqFile)) {
   console.log("  Installing Python dependencies...");
@@ -44,92 +41,228 @@ if (fs.existsSync(reqFile)) {
     execSync(`pip3 install -r "${reqFile}" --quiet --break-system-packages`, { stdio: "inherit" });
     console.log("  ✓ Python dependencies installed");
   } catch {
-    console.warn("  ⚠ pip3 unavailable — Python eval features disabled");
+    try {
+      execSync(`pip3 install -r "${reqFile}" --quiet`, { stdio: "inherit" });
+      console.log("  ✓ Python dependencies installed");
+    } catch {
+      console.warn("  ⚠ pip3 unavailable — Python eval features disabled");
+    }
   }
 }
 
-// 5. Patch openclaw.json
-let cfg = {};
-if (fs.existsSync(OC_JSON)) {
-  try { cfg = JSON.parse(fs.readFileSync(OC_JSON, "utf8")); } catch {}
-}
-cfg.plugins ??= {};
-cfg.plugins.entries ??= {};
-cfg.plugins.entries["sinain-hud"] = {
-  enabled: true,
-  config: {
-    heartbeatPath: path.join(SOURCES_DIR, "HEARTBEAT.md"),
-    memoryPath:    memoryDst,
-    sessionKey:    "agent:main:sinain"
-  }
-};
-// Remove stale "sinain" entry if present from a previous install
-delete cfg.plugins.entries["sinain"];
-cfg.plugins.allow ??= [];
-if (!cfg.plugins.allow.includes("sinain-hud")) cfg.plugins.allow.push("sinain-hud");
-cfg.agents ??= {};
-cfg.agents.defaults ??= {};
-cfg.agents.defaults.sandbox ??= {};
-cfg.agents.defaults.sandbox.sessionToolsVisibility = "all";
-cfg.gateway ??= {};
-cfg.gateway.mode = "local";   // required for gateway to start
-cfg.gateway.bind = "lan";     // allow remote Mac to connect
-cfg.gateway.auth ??= {};
-cfg.gateway.auth.mode ??= "token";
-if (!cfg.gateway.auth.token) {
-  cfg.gateway.auth.token = randomBytes(24).toString("hex");
+// ── Detect environment and branch ───────────────────────────────────────────
+
+const nemoClaw = detectNemoClaw();
+if (nemoClaw) {
+  await installNemoClaw(nemoClaw);
+} else {
+  await installLocal();
 }
-const authToken = cfg.gateway.auth.token;
 
-fs.mkdirSync(path.dirname(OC_JSON), { recursive: true });
-fs.writeFileSync(OC_JSON, JSON.stringify(cfg, null, 2));
-console.log("  ✓ openclaw.json patched");
+// ── NemoClaw path: upload staged files into the OpenShell sandbox ────────────
+//
+// NemoClaw runs OpenClaw inside an OpenShell sandbox pod.  The sandbox has
+// outbound network policy (npm registry is blocked at the binary level) so
+// `npx` / `npm install` cannot reach registry.npmjs.org from inside the pod.
+// Instead we:
+//   1. Stage files locally (done above — steps 1-3)
+//   2. Upload them into the sandbox via `openshell sandbox upload`
+//   3. Download sandbox openclaw.json, patch it, upload back
+//   4. Reload the openclaw gateway inside the sandbox over SSH
+//   5. Print the sandbox's auth token so setup-nemoclaw.sh can use it
+
+async function installNemoClaw({ sandboxName }) {
+  console.log(`\n  NemoClaw sandbox detected: '${sandboxName}'`);
 
-// 6. Memory restore from backup repo (if SINAIN_BACKUP_REPO is set)
-const backupUrl = process.env.SINAIN_BACKUP_REPO;
-if (backupUrl) {
+  // Ensure SSH config has an entry for this sandbox
   try {
-    await checkRepoPrivacy(backupUrl);
-    if (!fs.existsSync(path.join(WORKSPACE, ".git"))) {
-      console.log("  Restoring memory from backup repo...");
-      execSync(`git clone "${backupUrl}" "${WORKSPACE}" --quiet`, { stdio: "inherit" });
+    const sshEntry = run_capture(`openshell sandbox ssh-config ${sandboxName}`);
+    const sshFile  = path.join(HOME, ".ssh/config");
+    const existing = fs.existsSync(sshFile) ? fs.readFileSync(sshFile, "utf8") : "";
+    if (!existing.includes(`Host openshell-${sandboxName}`)) {
+      fs.mkdirSync(path.join(HOME, ".ssh"), { recursive: true, mode: 0o700 });
+      fs.appendFileSync(sshFile, "\n" + sshEntry + "\n");
+    }
+  } catch { /* ssh-config is optional; connect may still work */ }
+
+  // Upload plugin dir into sandbox
+  run(`openshell sandbox upload ${sandboxName} "${PLUGIN_DIR}" /sandbox/.openclaw/extensions/sinain-hud`);
+  console.log("  ✓ Plugin uploaded to sandbox");
+
+  // Upload sinain-sources dir into sandbox
+  run(`openshell sandbox upload ${sandboxName} "${SOURCES_DIR}" /sandbox/.openclaw/sinain-sources`);
+  console.log("  ✓ sinain-sources uploaded to sandbox");
+
+  // Download sandbox openclaw.json, patch, re-upload
+  const tmpJson = path.join(os.tmpdir(), `sinain-openclaw-${Date.now()}.json`);
+  run(`openshell sandbox download ${sandboxName} /sandbox/.openclaw/openclaw.json "${tmpJson}"`);
+
+  let cfg = {};
+  try { cfg = JSON.parse(fs.readFileSync(tmpJson, "utf8")); } catch {}
+
+  cfg.plugins ??= {};
+  cfg.plugins.entries ??= {};
+  cfg.plugins.allow   ??= [];
+  cfg.plugins.entries["sinain-hud"] = {
+    enabled: true,
+    config: {
+      heartbeatPath: "/sandbox/.openclaw/sinain-sources/HEARTBEAT.md",
+      memoryPath:    "/sandbox/.openclaw/sinain-sources/sinain-memory",
+      sessionKey:    "agent:main:sinain"
+    }
+  };
+  if (!cfg.plugins.allow.includes("sinain-hud")) cfg.plugins.allow.push("sinain-hud");
+  cfg.agents                                         ??= {};
+  cfg.agents.defaults                                ??= {};
+  cfg.agents.defaults.sandbox                        ??= {};
+  cfg.agents.defaults.sandbox.sessionToolsVisibility  = "all";
+  cfg.compaction = { mode: "safeguard", maxHistoryShare: 0.2, reserveTokensFloor: 40000 };
+  // NemoClaw: gateway bind/auth are managed by OpenShell — do not overwrite them
+
+  const token = cfg.gateway?.auth?.token ?? "(see sandbox openclaw.json)";
+
+  fs.writeFileSync(tmpJson, JSON.stringify(cfg, null, 2));
+  run(`openshell sandbox upload ${sandboxName} "${tmpJson}" /sandbox/.openclaw/openclaw.json`);
+  fs.rmSync(tmpJson, { force: true });
+  console.log("  ✓ openclaw.json patched in sandbox");
+
+  // Memory restore from backup repo (workspace lives inside sandbox)
+  const backupUrl = process.env.SINAIN_BACKUP_REPO;
+  if (backupUrl) {
+    try {
+      await checkRepoPrivacy(backupUrl);
+      run(`ssh -T openshell-${sandboxName} 'if [ ! -d /sandbox/.openclaw/workspace/.git ]; then git clone "${backupUrl}" /sandbox/.openclaw/workspace --quiet; fi'`);
       console.log("  ✓ Memory restored from", backupUrl);
-    } else {
-      execSync(`git -C "${WORKSPACE}" remote set-url origin "${backupUrl}"`, { stdio: "pipe" });
-      console.log("  ✓ Workspace git remote updated");
+    } catch (e) {
+      console.error("\n  ✗ Memory restore aborted:", e.message, "\n");
+      process.exit(1);
     }
-  } catch (e) {
-    console.error("\n  ✗ Memory restore aborted:", e.message, "\n");
-    process.exit(1);
   }
+
+  // Reload openclaw gateway inside sandbox
+  try {
+    run_capture(`ssh -T openshell-${sandboxName} 'openclaw reload'`);
+    console.log("  ✓ Gateway reloaded");
+  } catch {
+    console.warn("  ⚠ Could not reload gateway — it will pick up changes on next start");
+  }
+
+  console.log(`
+✓ sinain installed successfully.
+  Sandbox:    ${sandboxName}
+  Auth token: ${token}
+
+  Next steps:
+    1. Note the token above
+    2. Run ./setup-nemoclaw.sh on your Mac
+       NemoClaw URL:  ws://YOUR-BREV-IP:18789
+       Auth token:    ${token}
+`);
 }
 
-// 7. Start / restart gateway
-try {
-  execSync("openclaw gateway restart --background", { stdio: "pipe" });
-  console.log("  ✓ Gateway restarted");
-} catch {
+// ── Standard path: bare-metal OpenClaw (e.g. strato server) ─────────────────
+
+async function installLocal() {
+  // Patch openclaw.json
+  let cfg = {};
+  if (fs.existsSync(OC_JSON)) {
+    try { cfg = JSON.parse(fs.readFileSync(OC_JSON, "utf8")); } catch {}
+  }
+  cfg.plugins ??= {};
+  cfg.plugins.entries ??= {};
+  cfg.plugins.entries["sinain-hud"] = {
+    enabled: true,
+    config: {
+      heartbeatPath: path.join(SOURCES_DIR, "HEARTBEAT.md"),
+      memoryPath:    memoryDst,
+      sessionKey:    "agent:main:sinain"
+    }
+  };
+  cfg.agents                                         ??= {};
+  cfg.agents.defaults                                ??= {};
+  cfg.agents.defaults.sandbox                        ??= {};
+  cfg.agents.defaults.sandbox.sessionToolsVisibility  = "all";
+  cfg.compaction = { mode: "safeguard", maxHistoryShare: 0.2, reserveTokensFloor: 40000 };
+  cfg.gateway     ??= {};
+  cfg.gateway.bind  = "lan";  // allow remote Mac to connect
+
+  fs.mkdirSync(path.dirname(OC_JSON), { recursive: true });
+  fs.writeFileSync(OC_JSON, JSON.stringify(cfg, null, 2));
+  console.log("  ✓ openclaw.json patched");
+
+  // Memory restore from backup repo
+  const backupUrl = process.env.SINAIN_BACKUP_REPO;
+  if (backupUrl) {
+    try {
+      await checkRepoPrivacy(backupUrl);
+      if (!fs.existsSync(path.join(WORKSPACE, ".git"))) {
+        console.log("  Restoring memory from backup repo...");
+        execSync(`git clone "${backupUrl}" "${WORKSPACE}" --quiet`, { stdio: "inherit" });
+        console.log("  ✓ Memory restored from", backupUrl);
+      } else {
+        execSync(`git -C "${WORKSPACE}" remote set-url origin "${backupUrl}"`, { stdio: "pipe" });
+        console.log("  ✓ Workspace git remote updated");
+      }
+    } catch (e) {
+      console.error("\n  ✗ Memory restore aborted:", e.message, "\n");
+      process.exit(1);
+    }
+  }
+
+  // Reload gateway
   try {
-    execSync("openclaw gateway start --background", { stdio: "pipe" });
-    console.log("  ✓ Gateway started");
+    execSync("openclaw reload", { stdio: "pipe" });
+    console.log("  ✓ Gateway reloaded");
   } catch {
-    console.warn("  ⚠ Could not start gateway — run: openclaw gateway");
+    try {
+      execSync("openclaw stop && sleep 1 && openclaw start --background", { stdio: "pipe" });
+      console.log("  ✓ Gateway restarted");
+    } catch {
+      console.warn("  ⚠ Could not start gateway — run: openclaw gateway");
+    }
   }
+
+  console.log(`
+✓ sinain installed successfully.
+  Plugin config: ~/.openclaw/openclaw.json
+  Auth token:    check your Brev dashboard → 'Gateway Token'
+  Then run ./setup-nemoclaw.sh on your Mac.
+`);
 }
 
-console.log("\n✓ sinain installed successfully.");
-console.log("  Plugin config: ~/.openclaw/openclaw.json");
-console.log(`  Auth token:    ${authToken}`);
-console.log("  Next: run 'openclaw gateway' in a new terminal, then run ./setup-nemoclaw.sh on your Mac.\n");
+// ── Detection ────────────────────────────────────────────────────────────────
+
+function detectNemoClaw() {
+  // NemoClaw writes ~/.nemoclaw/sandboxes.json with a defaultSandbox field
+  const sandboxesJson = path.join(HOME, ".nemoclaw/sandboxes.json");
+  if (!fs.existsSync(sandboxesJson)) return null;
+  try {
+    const data = JSON.parse(fs.readFileSync(sandboxesJson, "utf8"));
+    const sandboxName = data.defaultSandbox;
+    if (!sandboxName || !data.sandboxes?.[sandboxName]) return null;
+    // Verify openshell CLI is reachable
+    try { execSync("which openshell", { stdio: "pipe" }); } catch { return null; }
+    return { sandboxName };
+  } catch {
+    return null;
+  }
+}
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
+function run(cmd) {
+  execSync(cmd, { stdio: "inherit" });
+}
+
+function run_capture(cmd) {
+  return execSync(cmd, { encoding: "utf-8", stdio: ["pipe","pipe","pipe"] }).trim();
+}
+
 function copyDir(src, dst) {
   fs.mkdirSync(dst, { recursive: true });
   for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
     const s = path.join(src, entry.name);
     const d = path.join(dst, entry.name);
-    // Skip __pycache__ and .pytest_cache to keep the deploy lean
     if (entry.name === "__pycache__" || entry.name === ".pytest_cache") continue;
     entry.isDirectory() ? copyDir(s, d) : fs.copyFileSync(s, d);
   }
@@ -164,5 +297,5 @@ async function checkRepoPrivacy(url) {
   } else if (res.status !== 404) {
     throw new Error(`Cannot verify repo privacy (HTTP ${res.status}). Aborting for safety.`);
   }
-  // 404 = private (unauthenticated can't see it) — OK
+  // 404 = private repo (unauthenticated can't see it) — OK
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geravant/sinain",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "sinain OpenClaw plugin — AI overlay for macOS",
   "type": "module",
   "bin": {

package/HEARTBEAT.md

@@ -1,62 +0,0 @@
-# HEARTBEAT.md
-
-> **Execution contract:**
-> 1. Setup → call `sinain_heartbeat_tick` → act on result → HEARTBEAT_OK
-> 2. You MUST call the tool. Do NOT skip it. Do NOT reply HEARTBEAT_OK without calling it first.
-
----
-
-## Setup
-
-1. `sessions_history({ sessionKey: "agent:main:sinain", limit: 20, includeTools: false })`
-2. Determine **IDLE** status: no user activity in the last 30 minutes
-3. Compose **SESSION_SUMMARY**: 2–3 sentences describing the current state (what the user is doing, key topics, errors seen)
-
----
-
-## Execute Tick
-
-Call the `sinain_heartbeat_tick` tool:
-
-```
-sinain_heartbeat_tick({ sessionSummary: "...", idle: true|false })
-```
-
-The tool runs all scripts (git backup, signal analysis, insight synthesis) and writes the log entry automatically.
-
----
-
-## Act on Result
-
-- If `recommendedAction.action === "sessions_spawn"` → spawn a subagent with `.task`
-- If `recommendedAction.action === "telegram_tip"` → send `.task` to Telegram (chat_id: 59835117)
-- If `output` is not null → send to Telegram (chat_id: 59835117): `Suggestion: {suggestion}\n\nInsight: {insight}`
-
----
-
-## Finish
-
-Reply **HEARTBEAT_OK**
-
----
-
-## Rules
-
-- **Proactivity quota:** on active days, at least 2 ticks MUST produce output
-- Max 2 subagents. NEVER repeat a recent action. Prefer depth over breadth.
-- Memory mining, feedback, and curation run via plugin timer — do NOT invoke manually.
-- Module management is on-demand, not per-tick — see SKILL.md for module commands.
-
----
-
-## NemoClaw Provisioning
-
-New Brev instance setup (run in Code-Server terminal):
-```
-SINAIN_BACKUP_REPO=<git-url> npx sinain
-```
-- Copies plugin files, patches `openclaw.json`, installs Python deps, restores memory from backup repo, reloads gateway
-- Token printed at end (or visible in Brev dashboard → Gateway Token)
-- Mac side: `./setup-nemoclaw.sh` → 5 prompts → overlay starts
-
-Memory is git-backed via `git_backup.sh` on every heartbeat tick. New instances restore instantly via `SINAIN_BACKUP_REPO`.