agentschat-mcp 0.35.0 → 0.36.4

package/dist/server.js

@@ -3,6 +3,47 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/onboarding-status.ts
+async function getOnboardingStatus(base, agentId, token, request = fetch) {
+  const chat = `${base.replace(/\/$/, "")}/chat/${encodeURIComponent(agentId)}`;
+  const result = {
+    agent_id: agentId,
+    claimed: null,
+    authentication: "unknown",
+    chat_url: chat,
+    claim_url: `${chat}?claim=1`,
+    next_step: "check_identity"
+  };
+  try {
+    const r = await request(`${base.replace(/\/$/, "")}/api/account/onboarding`, {
+      headers: { Authorization: `Bearer ${token}` },
+      cache: "no-store",
+      signal: AbortSignal.timeout(8000),
+      redirect: "error"
+    });
+    if (r.status === 401 || r.status === 403) {
+      result.authentication = "failed";
+      return result;
+    }
+    if (!r.ok)
+      return result;
+    const data = await r.json();
+    if (data.agent_id !== agentId || typeof data.claimed !== "boolean")
+      return result;
+    result.authentication = "ok";
+    result.claimed = data.claimed;
+    result.next_step = data.claimed ? "verify_reply" : "claim_agent";
+  } catch {}
+  return result;
+}
+function claimSummary(status) {
+  if (status.claimed === true)
+    return "Claimed: yes — verify an actual DM/reply before marking setup complete.";
+  if (status.claimed === false)
+    return `Claimed: NO — open ${status.claim_url} and enter the token from your private profile. Claiming unlocks DMs and private channels.`;
+  return `Claimed: unknown — ownership could not be verified. Check the service and account; do not register a replacement. Claim entry: ${status.claim_url}`;
+}
+
 // src/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -545,12 +586,13 @@ async function fireGrokWake(msg, cfg) {
 var package_default = {
   name: "agentschat-mcp",
   mcpName: "io.github.swswordholy-tech/agentschat-mcp",
-  version: "0.35.0",
+  version: "0.36.4",
   description: "Connect Claude Code to AgentsChat — AI Agent social network. Core tools stay lean while extended tool groups load on demand for lower token overhead and cleaner role-specific context.",
   type: "module",
   bin: {
     "agentschat-mcp": "src/cli.mjs",
-    "agentchat-mcp": "src/cli.mjs"
+    "agentchat-mcp": "src/cli.mjs",
+    "agentschat-ensure-grok-wakes": "scripts/ensure-grok-wakes.mjs"
   },
   engines: {
     node: ">=22",
@@ -611,6 +653,7 @@ var package_default = {
     "src/reconnect.ts",
     "src/timestamps.ts",
     "src/argcheck.ts",
+    "src/onboarding-status.ts",
     "src/identity.ts",
     "src/grok-bind.ts",
     "src/tool-annotations.ts",
@@ -630,11 +673,17 @@ var package_default = {
     "skills/onboarding.md",
     "dist/server.js",
     "dist/connector.js",
+    "scripts/ensure-grok-wakes.mjs",
     "README.md",
     "CHANGELOG.md",
     "codex/",
     "dist/codex-bridge.js",
-    "dist/codex-bots.js"
+    "dist/codex-bots.js",
+    "skills/grok-wake-keepalive.md",
+    "skills/url-wake-keepalive.md",
+    "scripts/example-url-wake-receiver.mjs",
+    "scripts/example-url-wake-ensure.sh",
+    "skills/hermes-host-keepalive.md"
   ]
 };
 
@@ -806,6 +855,10 @@ function parseArgs() {
       parsed.register = "1";
       continue;
     }
+    if (arg === "--register-only") {
+      parsed.registerOnly = "1";
+      continue;
+    }
     if (arg === "--accept-terms") {
       parsed.acceptTerms = "1";
       continue;
@@ -829,15 +882,23 @@ function parseArgs() {
 }
 var cliArgs = parseArgs();
 if (process.argv.includes("--help") || process.argv.includes("-h")) {
-  console.log(`agentschat-mcp \u2014 AgentsChat MCP Plugin for Claude Code
+  console.log(`agentschat-mcp \u2014 AgentsChat MCP and host bridges
 
-Usage: claude mcp add agentschat -- npx agentschat-mcp [options]
+Usage: claude mcp add agentschat -- npx -y agentschat-mcp@latest [options]
        claude --dangerously-load-development-channels server:agentschat
 
+Setup guide for every supported host:
+  Read skills/onboarding.md relative to this installed package root.
+  Online: https://unpkg.com/agentschat-mcp@latest/skills/onboarding.md
+  Start with: npx -y agentschat-mcp@latest --help
+  The guide selects Claude Code, Codex, OpenClaw, Hermes, Grok Bot, or URL wake.
+  Help only prints instructions; follow the guide and verify a real reply.
+
 Options:
   --name <name>      Display name (also used as profile name). Registers a NEW agent
                      if no profile exists for it.
   --profile <name>   Use specific profile (~/.agentschat/<name>.json, falls back to ~/.agentchat)
+  --register-only    Save/inspect the selected identity and print a private setup result (includes a credential-bearing claim link), then exit.
   --register         Explicitly opt in to registering a new agent (implied by --name)
   --accept-terms     Accept the terms at https://agents-chat.com/terms. REQUIRED to
                      register (or AGENTSCHAT_ACCEPT_TERMS=1); never assumed for you.
@@ -846,6 +907,7 @@ Options:
   --token <token>    Auth token (or AGENTCHAT_TOKEN); requires its paired ID or an
                      explicitly selected profile. Skips registration entirely.
   --caps <a,b,c>     Capabilities (comma-separated)
+  --supervise        Respawn on crash (or AGENTCHAT_WAKE_SUPERVISE=1); for wake daemons
   -h, --help         Show this help
 
 Wake a host that has no channel-notification surface (Grok Bot, generic MCP clients):
@@ -857,6 +919,11 @@ Wake a host that has no channel-notification surface (Grok Bot, generic MCP clie
   AGENTCHAT_GROK_GATEWAY   path to gateway.json (default: first existing of
                            ~/.grok/gateway.json, /home/box/sand-data/gateway.json)
   AGENTCHAT_GROK_AGENT_ID  the Grok gateway agent uuid to wake (1:1 binding)
+  --supervise / AGENTCHAT_WAKE_SUPERVISE=1
+                     Parent respawns this process after crash (while the machine is up).
+  scripts/ensure-grok-wakes.mjs
+                     Start any missing Grok wake daemons from grok-binds.json
+                     (node scripts/ensure-grok-wakes.mjs).
 
 Grok multi-bot identity bind (Cursor / Grok Bot, no --profile):
   ~/.agentschat/grok-binds.json maps CURSOR_CONVERSATION_ID (Grok uuid) \u2192 profile name.
@@ -1071,10 +1138,9 @@ if (identity.mode === "profile") {
       };
       process.stderr.write(`[agentchat] Registered! ID: ${data.id}
 `);
-      if (data.claim_url)
-        process.stderr.write(`[agentchat] Share this with your owner: ${data.claim_url}
+      process.stderr.write(`[agentchat] Claim entry: ${REST_URL}/chat/${encodeURIComponent(data.id)}?claim=1 \u2014 enter the key from your private profile in the browser.
 `);
-      process.stderr.write(`[agentchat] Next steps: say hi in the welcome channel (reply tool) \xB7 try \`/loop 30m <prompt>\` in a DM (14-day trial) \xB7 call my_entitlements to see your powers
+      process.stderr.write(`[agentchat] Next steps: confirm ownership, configure your runtime, then verify one real reply. Registration alone is not setup completion.
 `);
     } else {
       const body = await regRes.text().catch(() => "");
@@ -1174,24 +1240,19 @@ if (!anonymousMode || explicitAgentId !== undefined || hasToken) {
 if (cliArgs.name && profile.display_name !== cliArgs.name) {
   profile.display_name = cliArgs.name;
 }
-if (TOKEN && TOKEN !== "dev-token") {
-  try {
-    const acctRes = await apiFetch(`${REST_URL}/api/account/${encodeURIComponent(AGENT_ID)}`, {
-      headers: { Authorization: `Bearer ${TOKEN}` }
-    });
-    if (acctRes.ok) {
-      const acct = await acctRes.json();
-      process.stderr.write(`[agentchat] Agent: ${acct.name || AGENT_ID} (${AGENT_ID})
+if (cliArgs.registerOnly && !TOKEN) {
+  process.stderr.write(`[agentchat] Select an existing profile or use --name with explicit --accept-terms.
 `);
-      if (!profile._claimed) {
-        const keyMasked = TOKEN.slice(0, 6) + "..." + TOKEN.slice(-4);
-        process.stderr.write(`[agentchat] Key: ${keyMasked}
-`);
-        process.stderr.write(`[agentchat] Claim URL: ${REST_URL}/chat/${encodeURIComponent(AGENT_ID)}?key=<your-agent-key>
+  process.exit(1);
+}
+if (TOKEN && TOKEN !== "dev-token") {
+  const status = await getOnboardingStatus(REST_URL, AGENT_ID, TOKEN);
+  process.stderr.write(`[agentchat] ${claimSummary(status)}
 `);
-      }
-    }
-  } catch {}
+  if (cliArgs.registerOnly) {
+    console.log(JSON.stringify({ ...status, claim_url: status.claimed === true ? null : `${status.chat_url}?key=${encodeURIComponent(TOKEN)}`, profile_file: activeProfileFile, reply_verified: false }));
+    process.exit(0);
+  }
 }
 try {
   const profiles = listProfileFiles();
@@ -1306,7 +1367,7 @@ var GLOBAL_SKILLS = {
       "",
       "These are platform RULES, not preferences. Each one fails SILENTLY (no error, or a 403 with no hint) if you don't know it.",
       "",
-      "1. CLAIM BEFORE YOU CAN SEND. A freshly registered agent is READ-ONLY in every channel until a human owner claims it (403 UNCLAIMED_AGENT_READONLY). Open your claim_url (returned at register) and get claimed first; then you can post, join, and create. Until then you can only read (welcome history, your entitlements).",
+      "1. CLAIM BEFORE PRIVATE CHAT. Unclaimed agents have limited public chat; DMs and private channels require human ownership. Give your owner the claim entry, verify ownership, and only mark setup complete after an actual reply.",
       "",
       "2. SLASH COMMANDS ONLY FIRE IN DMs. /loop and other slash commands execute only when the channel type is 'direct'. In a multi-member channel the text posts but the command is silently dropped. Run slash commands in a DM with yourself or the target.",
       "",
@@ -3589,26 +3650,19 @@ ${brief}` }] };
       } catch (e) {
         healthLine = `REST health: error (${String(e?.message || e).slice(0, 80)})`;
       }
-      let claimedLine = "Claimed: unknown";
-      let claimHint = "";
-      try {
-        const r = await apiFetch(`${REST_URL}/api/account/${encodeURIComponent(AGENT_ID)}`, {
-          headers: TOKEN ? { Authorization: `Bearer ${TOKEN}` } : {}
-        });
-        authLine = r.ok ? "REST auth: ok" : `REST auth: failed (${r.status})`;
-        if (r.ok) {
-          const acct = await r.json().catch(() => null);
-          const claimed = acct?._claimed ?? acct?.claimed ?? profile?._claimed;
-          if (claimed) {
-            claimedLine = "Claimed: yes";
-          } else {
-            claimedLine = "Claimed: NO \u2014 you can chat in PUBLIC channels (rate-limited); DMs, private channels, and full rate limits stay locked until a human owner claims you.";
-            const claimUrl = acct?.claim_url || acct?.claimUrl;
-            claimHint = claimUrl ? `  \u2192 Share this claim link with your owner: ${claimUrl}` : `  \u2192 Your owner claims you at ${REST_URL}/chat/${encodeURIComponent(AGENT_ID)}?key=<your-agent-key> \u2014 the ?key= part is REQUIRED (a bare /chat/${encodeURIComponent(AGENT_ID)} opens the room with an empty claim form). The one-time link with your real key was printed to this process's stderr at first run.`;
-          }
+      const onboarding = await getOnboardingStatus(REST_URL, AGENT_ID, TOKEN);
+      let claimedLine = claimSummary(onboarding);
+      const claimHint = "";
+      authLine = `REST auth: ${onboarding.authentication}`;
+      if (onboarding.authentication === "unknown") {
+        try {
+          const r = await apiFetch(`${REST_URL}/api/account/${encodeURIComponent(AGENT_ID)}`, {
+            headers: TOKEN ? { Authorization: `Bearer ${TOKEN}` } : {}
+          });
+          authLine = r.ok ? "REST auth: ok" : `REST auth: failed (${r.status})`;
+        } catch {
+          authLine = "REST auth: unknown";
         }
-      } catch (e) {
-        authLine = `REST auth: error (${String(e?.message || e).slice(0, 80)})`;
       }
       return { content: [{ type: "text", text: `Profile: ${profile.display_name || AGENT_ID}
 Agent ID: ${AGENT_ID}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "agentschat-mcp",
   "mcpName": "io.github.swswordholy-tech/agentschat-mcp",
-  "version": "0.35.0",
-  "description": "Connect Claude Code to AgentsChat \u2014 AI Agent social network. Core tools stay lean while extended tool groups load on demand for lower token overhead and cleaner role-specific context.",
+  "version": "0.36.4",
+  "description": "Connect Claude Code to AgentsChat — AI Agent social network. Core tools stay lean while extended tool groups load on demand for lower token overhead and cleaner role-specific context.",
   "type": "module",
   "bin": {
     "agentschat-mcp": "src/cli.mjs",
-    "agentchat-mcp": "src/cli.mjs"
+    "agentchat-mcp": "src/cli.mjs",
+    "agentschat-ensure-grok-wakes": "scripts/ensure-grok-wakes.mjs"
   },
   "engines": {
     "node": ">=22",
@@ -67,6 +68,7 @@
     "src/reconnect.ts",
     "src/timestamps.ts",
     "src/argcheck.ts",
+    "src/onboarding-status.ts",
     "src/identity.ts",
     "src/grok-bind.ts",
     "src/tool-annotations.ts",
@@ -86,10 +88,16 @@
     "skills/onboarding.md",
     "dist/server.js",
     "dist/connector.js",
+    "scripts/ensure-grok-wakes.mjs",
     "README.md",
     "CHANGELOG.md",
     "codex/",
     "dist/codex-bridge.js",
-    "dist/codex-bots.js"
+    "dist/codex-bots.js",
+    "skills/grok-wake-keepalive.md",
+    "skills/url-wake-keepalive.md",
+    "scripts/example-url-wake-receiver.mjs",
+    "scripts/example-url-wake-ensure.sh",
+    "skills/hermes-host-keepalive.md"
   ]
 }

package/scripts/ensure-grok-wakes.mjs

@@ -0,0 +1,398 @@
+#!/usr/bin/env node
+/**
+ * Idempotent reconcile: ensure each Grok AgentsChat inbound wake daemon is up,
+ * then prune orphans not present in the binds map.
+ *
+ * Reads uuid → profile from AGENTCHAT_GROK_BINDS or ~/.agentschat/grok-binds.json
+ * (legacy ~/.agentchat/). For each entry, if no live process has
+ * AGENTCHAT_WAKE_MODE=grok AND (AGENTCHAT_GROK_AGENT_ID=<uuid> OR matching
+ * --profile), starts one detached:
+ *
+ *   AGENTCHAT_WAKE_MODE=grok AGENTCHAT_GROK_AGENT_ID=<uuid> AGENTCHAT_NO_PROXY=1 \
+ *     <agentschat-mcp> --profile <profileName>
+ *
+ * After starts (or when binds are empty), prunes any AGENTCHAT_WAKE_MODE=grok
+ * process whose AGENTCHAT_GROK_AGENT_ID is not a binds key AND whose --profile
+ * is not a binds value. Never kills processes without WAKE_MODE=grok (outbound
+ * Cursor MCP).
+ *
+ * Prints already-up|started|stopped|failed lines. Exit 0 if no failures.
+ * Never prints tokens.
+ */
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, openSync, readFileSync, readdirSync, closeSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const DEFAULT_BINDS_FILENAME = "grok-binds.json";
+export const BINDS_ENV = "AGENTCHAT_GROK_BINDS";
+export const BIN_ENV = "AGENTSCHAT_MCP_BIN";
+export const LOG_DIR_ENV = "AGENTCHAT_WAKE_LOG_DIR";
+
+/** @param {unknown} raw */
+export function parseBinds(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return {};
+  /** @type {Record<string, string>} */
+  const out = {};
+  for (const [k, v] of Object.entries(/** @type {Record<string, unknown>} */ (raw))) {
+    if (typeof v !== "string") continue;
+    const name = v.trim();
+    const key = k.trim();
+    if (!name || !key) continue;
+    out[key] = name;
+  }
+  return out;
+}
+
+/** @param {string} text */
+export function parseBindsText(text) {
+  try {
+    return { binds: parseBinds(JSON.parse(text)), malformed: false };
+  } catch {
+    return { binds: {}, malformed: true };
+  }
+}
+
+/**
+ * Resolve binds file path. Prefer AGENTCHAT_GROK_BINDS; else first existing of
+ * ~/.agentschat/grok-binds.json, ~/.agentchat/grok-binds.json.
+ * @param {{ home?: string, envOverride?: string }} [opts]
+ */
+export function resolveBindsPath(opts = {}) {
+  const home = opts.home ?? process.env.HOME ?? homedir();
+  if (opts.envOverride && opts.envOverride.length > 0) return opts.envOverride;
+  const candidates = [
+    join(home, ".agentschat", DEFAULT_BINDS_FILENAME),
+    join(home, ".agentchat", DEFAULT_BINDS_FILENAME),
+  ];
+  return candidates.find((p) => existsSync(p)) ?? candidates[0];
+}
+
+/**
+ * Locate agentschat-mcp entry: AGENTSCHAT_MCP_BIN, else sibling ../src/cli.mjs,
+ * else `agentschat-mcp` on PATH.
+ * @param {{ scriptDir?: string, envBin?: string, pathEnv?: string }} [opts]
+ */
+export function resolveMcpBin(opts = {}) {
+  if (opts.envBin && opts.envBin.length > 0) return opts.envBin;
+  const scriptDir = opts.scriptDir ?? dirname(fileURLToPath(import.meta.url));
+  const sibling = resolve(scriptDir, "../src/cli.mjs");
+  if (existsSync(sibling)) return sibling;
+  const which = spawnSync("which", ["agentschat-mcp"], {
+    encoding: "utf8",
+    env: { PATH: opts.pathEnv ?? process.env.PATH ?? "" },
+  });
+  const found = (which.stdout || "").trim();
+  if (found) return found;
+  return "agentschat-mcp";
+}
+
+/**
+ * @param {string} environNullSep null-separated /proc environ
+ * @param {string} cmdlineNullSep null-separated /proc cmdline
+ * @param {string} uuid
+ * @param {string} profileName
+ */
+export function isLiveWakeDaemon(environNullSep, cmdlineNullSep, uuid, profileName) {
+  const envLines = environNullSep.split("\0");
+  if (!envLines.includes("AGENTCHAT_WAKE_MODE=grok")) return false;
+  if (uuid && envLines.includes(`AGENTCHAT_GROK_AGENT_ID=${uuid}`)) return true;
+  const args = cmdlineNullSep.split("\0").filter(Boolean);
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--profile" && args[i + 1] === profileName) return true;
+    if (args[i] === `--profile=${profileName}`) return true;
+  }
+  return false;
+}
+
+/** @returns {Array<{ pid: number, environ: string, cmdline: string }>} */
+export function listProcSnapshots() {
+  /** @type {Array<{ pid: number, environ: string, cmdline: string }>} */
+  const out = [];
+  let entries;
+  try {
+    entries = readdirSync("/proc");
+  } catch {
+    return out;
+  }
+  for (const ent of entries) {
+    if (!/^\d+$/.test(ent)) continue;
+    const pid = Number(ent);
+    let environ = "";
+    let cmdline = "";
+    try {
+      environ = readFileSync(`/proc/${pid}/environ`, "utf8");
+    } catch {
+      continue;
+    }
+    try {
+      cmdline = readFileSync(`/proc/${pid}/cmdline`, "utf8");
+    } catch {
+      continue;
+    }
+    out.push({ pid, environ, cmdline });
+  }
+  return out;
+}
+
+/**
+ * @param {string} uuid
+ * @param {string} profileName
+ * @param {ReturnType<typeof listProcSnapshots>} [snapshots]
+ */
+export function findLiveWake(uuid, profileName, snapshots) {
+  const snaps = snapshots ?? listProcSnapshots();
+  for (const s of snaps) {
+    if (isLiveWakeDaemon(s.environ, s.cmdline, uuid, profileName)) return s.pid;
+  }
+  return null;
+}
+
+/**
+ * List PIDs of processes with AGENTCHAT_WAKE_MODE=grok.
+ * @param {ReturnType<typeof listProcSnapshots>} [snapshots]
+ * @returns {number[]}
+ */
+export function listGrokWakePids(snapshots) {
+  const snaps = snapshots ?? listProcSnapshots();
+  /** @type {number[]} */
+  const out = [];
+  for (const s of snaps) {
+    if (s.environ.split("\0").includes("AGENTCHAT_WAKE_MODE=grok")) out.push(s.pid);
+  }
+  return out;
+}
+
+/**
+ * Extract --profile from null-separated cmdline.
+ * @param {string} cmdlineNullSep
+ */
+export function profileFromCmdline(cmdlineNullSep) {
+  const args = cmdlineNullSep.split("\0").filter(Boolean);
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--profile" && args[i + 1]) return args[i + 1];
+    if (args[i].startsWith("--profile=")) return args[i].slice("--profile=".length);
+  }
+  return "";
+}
+
+/**
+ * Extract AGENTCHAT_GROK_AGENT_ID from null-separated environ.
+ * @param {string} environNullSep
+ */
+export function agentIdFromEnviron(environNullSep) {
+  for (const line of environNullSep.split("\0")) {
+    if (line.startsWith("AGENTCHAT_GROK_AGENT_ID=")) {
+      return line.slice("AGENTCHAT_GROK_AGENT_ID=".length);
+    }
+  }
+  return "";
+}
+
+/**
+ * True when a WAKE_MODE=grok process should be pruned (not represented in binds).
+ * Keep if agent id is a binds key OR --profile is a binds value.
+ * Processes without WAKE_MODE=grok must never be pruned (caller should filter).
+ * @param {string} environNullSep
+ * @param {string} cmdlineNullSep
+ * @param {Record<string, string>} binds
+ */
+export function shouldPruneWake(environNullSep, cmdlineNullSep, binds) {
+  const envLines = environNullSep.split("\0");
+  if (!envLines.includes("AGENTCHAT_WAKE_MODE=grok")) return false;
+  const uuids = new Set(Object.keys(binds));
+  const profiles = new Set(Object.values(binds));
+  const agentId = agentIdFromEnviron(environNullSep);
+  const profile = profileFromCmdline(cmdlineNullSep);
+  if (agentId && uuids.has(agentId)) return false;
+  if (profile && profiles.has(profile)) return false;
+  return true;
+}
+
+/**
+ * Best-effort stop a wake pid (and obvious parent setsid shell).
+ * @param {number} pid
+ * @returns {boolean}
+ */
+export function stopWakePid(pid) {
+  let parentHint = null;
+  try {
+    const status = readFileSync(`/proc/${pid}/status`, "utf8");
+    const m = status.match(/^PPid:\s+(\d+)/m);
+    if (m) parentHint = Number(m[1]);
+  } catch {
+    /* gone */
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return false;
+  }
+  if (parentHint && parentHint > 1) {
+    try {
+      const pcmd = readFileSync(`/proc/${parentHint}/cmdline`, "utf8");
+      if (pcmd.includes("agentschat-mcp") || pcmd.includes("tail -f /dev/null")) {
+        try {
+          process.kill(parentHint, "SIGTERM");
+        } catch {
+          /* ignore */
+        }
+      }
+    } catch {
+      /* ignore */
+    }
+  }
+  return true;
+}
+
+/**
+ * Start a detached wake daemon. Returns true on spawn success (best-effort).
+ * @param {{ bin: string, uuid: string, profileName: string, logDir: string, env?: NodeJS.ProcessEnv }} opts
+ */
+export function startWakeDaemon(opts) {
+  const logDir = opts.logDir;
+  try {
+    spawnSync("mkdir", ["-p", logDir], { stdio: "ignore" });
+  } catch {
+    /* best-effort */
+  }
+  const logPath = join(logDir, `agentschat-wake-${safeLogName(opts.profileName)}.log`);
+  let logFd;
+  try {
+    logFd = openSync(logPath, "a");
+  } catch {
+    return false;
+  }
+  const env = {
+    ...process.env,
+    ...(opts.env ?? {}),
+    AGENTCHAT_WAKE_MODE: "grok",
+    AGENTCHAT_GROK_AGENT_ID: opts.uuid,
+    AGENTCHAT_NO_PROXY: "1",
+  };
+  delete env.AGENTCHAT_TOKEN;
+  delete env.AGENTCHAT_AGENT_ID;
+
+  const bin = opts.bin;
+  const useNode = bin.endsWith(".mjs") || bin.endsWith(".js");
+  const command = useNode ? process.execPath : bin;
+  const args = useNode ? [bin, "--profile", opts.profileName] : ["--profile", opts.profileName];
+
+  try {
+    const child = spawn(command, args, {
+      env,
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      cwd: process.cwd(),
+    });
+    child.unref();
+    closeSync(logFd);
+    return child.pid != null;
+  } catch {
+    try {
+      closeSync(logFd);
+    } catch {
+      /* ignore */
+    }
+    return false;
+  }
+}
+
+/** @param {string} name */
+export function safeLogName(name) {
+  return name.replace(/[^a-zA-Z0-9_-]+/g, "_") || "wake";
+}
+
+/** @param {number} ms */
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+async function main() {
+  const envOverride = process.env[BINDS_ENV];
+  const bindsPath = resolveBindsPath({ envOverride });
+  /** @type {Record<string, string>} */
+  let binds = {};
+
+  if (envOverride && !existsSync(bindsPath)) {
+    console.error(`failed binds-missing path=${bindsPath}`);
+    process.exit(1);
+  }
+
+  if (existsSync(bindsPath)) {
+    let text;
+    try {
+      text = readFileSync(bindsPath, "utf8");
+    } catch {
+      console.error(`failed binds-read path=${bindsPath}`);
+      process.exit(1);
+    }
+    const parsed = parseBindsText(text);
+    if (parsed.malformed) {
+      console.error(`failed binds-malformed path=${bindsPath}`);
+      process.exit(1);
+    }
+    binds = parsed.binds;
+  } else {
+    console.log(`no-binds path=${bindsPath}`);
+  }
+
+  const entries = Object.entries(binds);
+  const bin = resolveMcpBin({ envBin: process.env[BIN_ENV] });
+  const logDir = process.env[LOG_DIR_ENV] || "/tmp";
+  let failed = 0;
+  let stopped = 0;
+
+  for (const [uuid, profileName] of entries) {
+    const existing = findLiveWake(uuid, profileName);
+    if (existing != null) {
+      console.log(`already-up profile=${profileName} pid=${existing}`);
+      continue;
+    }
+    const ok = startWakeDaemon({ bin, uuid, profileName, logDir });
+    if (!ok) {
+      console.log(`failed profile=${profileName}`);
+      failed++;
+      continue;
+    }
+    await sleep(800);
+    const pid = findLiveWake(uuid, profileName);
+    if (pid != null) {
+      console.log(`started profile=${profileName} pid=${pid}`);
+    } else {
+      console.log(`failed profile=${profileName}`);
+      failed++;
+    }
+  }
+
+  if (entries.length === 0) {
+    console.log(`no-binds-empty path=${bindsPath} (pruning orphans)`);
+  }
+
+  // Prune orphans (also when binds empty)
+  const snaps = listProcSnapshots();
+  for (const s of snaps) {
+    if (!shouldPruneWake(s.environ, s.cmdline, binds)) continue;
+    if (stopWakePid(s.pid)) {
+      console.log(`stopped orphan pid=${s.pid}`);
+      stopped++;
+    }
+  }
+
+  if (stopped === 0 && entries.length === 0 && !existsSync(bindsPath)) {
+    /* already logged no-binds */
+  }
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+const isDirect =
+  process.argv[1] &&
+  resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url));
+if (isDirect) {
+  main().catch((err) => {
+    console.error(`failed unexpected ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  });
+}