@termhub/agent 0.4.1 → 0.4.3

package/dist/cli.js

@@ -76,11 +76,18 @@ var RPC = {
   "file.paste": def(z.object({ name: pasteName, data_b64: z.string().min(1).max(28 * 1024 * 1024) }), z.object({ path: z.string() }), 6e4),
   /** Monitor hooks (see @termhub/machine-ops hooks.ts): the agent writes the script, env and config entries under its own $HOME. */
   /** `claude_dirs`: Claude config dirs besides ~/.claude (accounts with CLAUDE_CONFIG_DIR), hooked when they exist; since agent 0.1.5. */
+  /** `cursor` in the result: ~/.cursor/hooks.json (Cursor CLI), written when ~/.cursor exists; since agent 0.4.3 (older agents leave it out). */
   "hooks.install": def(z.object({
     hooks_url: z.string().min(1).max(2048).regex(/^https?:\/\/[^\s'"]+$/),
     token: z.string().min(1).max(256).regex(/^[A-Za-z0-9_-]+$/),
     claude_dirs: z.array(machinePath).max(16).optional()
-  }), z.object({ home: z.string(), claude: z.enum(["installed", "skipped"]), codex: z.enum(["installed", "skipped"]), claude_dirs: z.array(z.string()).optional() }), 15e3),
+  }), z.object({
+    home: z.string(),
+    claude: z.enum(["installed", "skipped"]),
+    codex: z.enum(["installed", "skipped"]),
+    cursor: z.enum(["installed", "skipped"]).optional(),
+    claude_dirs: z.array(z.string()).optional()
+  }), 15e3),
   "hooks.uninstall": def(z.object({ claude_dirs: z.array(machinePath).max(16).optional() }), z.object({ removed: z.boolean() }), 15e3),
   /** Installs `version` of @termhub/agent with npm; when the agent runs as a service it then exits so the service relaunches the new code (since agent 0.2.1). */
   "agent.update": def(z.object({ version: z.string().regex(/^\d+\.\d+\.\d+$/) }), z.object({ installed_version: z.string(), restart: z.enum(["service", "manual"]) }), 18e4)
@@ -420,7 +427,7 @@ function shellQuote(s) {
 var REMOTE_PATH_PREFIX = 'export PATH="$HOME/.local/bin:/opt/homebrew/bin:/usr/local/bin:$PATH"; ';
 
 // ../../packages/machine-ops/dist/detect.js
-var DETECT_TOOLS = ["tmux", "claude", "codex", "gh", "git", "node", "pnpm", "xcodebuild", "docker", "adb", "python3"];
+var DETECT_TOOLS = ["tmux", "claude", "codex", "cursor-agent", "gh", "git", "node", "pnpm", "xcodebuild", "docker", "adb", "python3"];
 var WDA_RUNNER_APP = "$HOME/.termhub/WebDriverAgent/DerivedData/Build/Products/Debug-iphonesimulator/WebDriverAgentRunner-Runner.app";
 var DETECT_SCRIPT = `echo OS:$(uname -s); for t in ${DETECT_TOOLS.join(" ")}; do command -v $t >/dev/null 2>&1 && echo CAP:$t; done; [ -d "${WDA_RUNNER_APP}" ] && echo CAP:wda; exit 0`;
 function parseDetect(stdout) {
@@ -612,10 +619,12 @@ function expandHome(dir, home) {
   return dir.startsWith("~/") ? `${home}/${dir.slice(2)}` : dir;
 }
 var CLAUDE_HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "Notification", "Stop", "SessionEnd"];
+var CURSOR_HOOK_EVENTS = ["sessionStart", "beforeSubmitPrompt", "afterAgentResponse", "stop", "sessionEnd"];
 var HOOK_SCRIPT = `#!/bin/sh
-# termhub monitor hook \u2014 installed by termhub; forwards Claude Code / Codex hook events to
-# termhub tagged with the tmux session, so the app knows which tab is waiting for you.
-# Safe to delete (also remove the entries in ~/.claude/settings.json and ~/.codex/config.toml).
+# termhub monitor hook \u2014 installed by termhub; forwards Claude Code / Codex / Cursor CLI hook
+# events to termhub tagged with the tmux session, so the app knows which tab is waiting for you.
+# Safe to delete (also remove the entries in ~/.claude/settings.json, ~/.codex/config.toml and
+# ~/.cursor/hooks.json).
 TOOL="\${1:-claude}"
 [ -f "$HOME/${HOOK_ENV_REL}" ] || exit 0
 . "$HOME/${HOOK_ENV_REL}"
@@ -626,8 +635,9 @@ SESSION=$(tmux display-message -p -t "$TMUX_PANE" '#{session_name}' 2>/dev/null)
 [ -n "$SESSION" ] || exit 0
 if [ "$TOOL" = codex ]; then EVENT="$2"; else EVENT=$(cat 2>/dev/null); fi
 [ -n "$EVENT" ] || EVENT='{}'
-# Tool calls: only the tool's name travels (never its input), and only when it changed since the
-# last one for this session \u2014 twenty edits in a row are one request. The marker is per tmux
+# Tool calls: only the tool's name travels (never its input), with the spinner's verb when one is on
+# screen, and only when the pair changed since the last one for this session \u2014 twenty edits in a row
+# are one request as long as the verb stays the same (a new verb mid-run is a new request). The marker is per tmux
 # session, under TMPDIR, with the session name reduced to filename-safe characters.
 MARK="\${TMPDIR:-/tmp}/termhub-hook-$(printf '%s' "$SESSION" | tr -c 'A-Za-z0-9_-' '_')"
 case "$EVENT" in
@@ -643,9 +653,30 @@ case "$EVENT" in
     REST=\${REST#*'"'}
     NAME=\${REST%%'"'*}
     case "$NAME" in '' | *[!A-Za-z0-9_.-]*) exit 0 ;; esac
-    [ "$(cat "$MARK" 2>/dev/null)" = "$NAME" ] && exit 0
-    printf '%s' "$NAME" 2>/dev/null > "$MARK"
-    EVENT=$(printf '{"hook_event_name":"PreToolUse","tool_name":"%s"}' "$NAME")
+    # Claude Code's spinner verb ("\u273B Moonwalking\u2026 (12s \xB7 esc to interrupt)"): the visible pane is
+    # read here, on the machine, and only the verb may leave it \u2014 one word of 2 to 24 ASCII letters
+    # right after a spinner glyph at column 0 and a single space, immediately followed by "\u2026" or
+    # "...", then the end of the line or a space. Column 0 because Claude Code draws its spinner
+    # there, while a draft in the input box or indented tool output can look just like one. The
+    # lowest such line of the last 24 non-blank rows wins (the live spinner sits above the todo list
+    # and the input box; blank rows under a short session are skipped). Both grep and sed run under
+    # LC_ALL=C: bytes the locale calls invalid then neither trip grep's "binary file matches" (which
+    # would also swallow the rest of the screen) nor sed's "illegal byte sequence" on macOS, and
+    # the match works the same on GNU, BSD and busybox. ASCII only on purpose: a customised verb
+    # with accents is dropped rather than half-matched. The case below checks the result again, so
+    # the hand-built JSON only ever gets letters.
+    VERB=$(tmux capture-pane -p -t "$TMUX_PANE" 2>/dev/null | LC_ALL=C grep -v '^[[:space:]]*$' 2>/dev/null | tail -n 24 |
+      LC_ALL=C sed -n -E 's/^(\xB7|\u2722|\u2733|\u2736|\u273B|\u273D|\\*) ([A-Za-z]{2,24})(\u2026|\\.\\.\\.)( .*)?$/\\2/p' | tail -n 1)
+    case "$VERB" in *[!A-Za-z]*) VERB= ;; esac
+    [ "\${#VERB}" -le 24 ] || VERB=
+    KEY="$NAME\${VERB:+ $VERB}"
+    [ "$(cat "$MARK" 2>/dev/null)" = "$KEY" ] && exit 0
+    printf '%s' "$KEY" 2>/dev/null > "$MARK"
+    if [ -n "$VERB" ]; then
+      EVENT=$(printf '{"hook_event_name":"PreToolUse","tool_name":"%s","verb":"%s"}' "$NAME" "$VERB")
+    else
+      EVENT=$(printf '{"hook_event_name":"PreToolUse","tool_name":"%s"}' "$NAME")
+    fi
     ;;
   # A new turn starts fresh, and so does an answered notification: a permission prompt takes the tab
   # out of working, and the tool the person approves is the same one that set the marker, so without
@@ -664,26 +695,35 @@ function hookEnvFile(hooksUrl, token) {
 TERMHUB_HOOK_TOKEN=${shellQuote(token)}
 `;
 }
+var asObject = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : null;
+var asHooksRecord = (v) => {
+  if (v == null || Array.isArray(v) && v.length === 0)
+    return {};
+  return asObject(v);
+};
 var isOurs = (e) => !!e && typeof e === "object" && Array.isArray(e.hooks) && e.hooks.some((h) => typeof h?.command === "string" && h.command.includes(HOOK_MARK));
-function mergeClaudeSettings(current, scriptPath) {
+function mergeClaudeSettings(current, scriptPath, shown = "~/.claude/settings.json") {
   let settings = {};
   if (current.trim()) {
     const parsed = JSON.parse(current);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-      throw new Error("~/.claude/settings.json n\xE3o \xE9 um objeto JSON");
+      throw new Error(`${shown} n\xE3o \xE9 um objeto JSON`);
     settings = parsed;
   }
-  const hooks = settings.hooks && typeof settings.hooks === "object" && !Array.isArray(settings.hooks) ? settings.hooks : {};
+  const hooks = asHooksRecord(settings.hooks);
+  if (settings.hooks != null && hooks === null)
+    throw new Error(`${shown}: o campo "hooks" n\xE3o \xE9 um objeto`);
+  const next = hooks ?? {};
   for (const event of CLAUDE_HOOK_EVENTS) {
-    const list3 = Array.isArray(hooks[event]) ? hooks[event] : [];
+    const list3 = Array.isArray(next[event]) ? next[event] : [];
     const others = list3.filter((e) => !isOurs(e));
     const entry = { hooks: [{ type: "command", command: `${scriptPath} claude`, timeout: 10 }] };
     if (event === "PreToolUse")
       entry.matcher = "*";
     others.push(entry);
-    hooks[event] = others;
+    next[event] = others;
   }
-  settings.hooks = hooks;
+  settings.hooks = next;
   return `${JSON.stringify(settings, null, 2)}
 `;
 }
@@ -728,6 +768,50 @@ function stripCodexConfig(current) {
   const lines = current.split("\n").filter((l) => !(/^\s*notify\s*=/.test(l) && l.includes(HOOK_MARK)));
   return lines.join("\n");
 }
+var isOurCursorEntry = (e) => !!e && typeof e === "object" && typeof e.command === "string" && e.command.includes(HOOK_MARK);
+function mergeCursorHooks(current, scriptPath, shown = "~/.cursor/hooks.json") {
+  let file = {};
+  if (current.trim()) {
+    const parsed = asObject(JSON.parse(current));
+    if (!parsed)
+      throw new Error(`${shown} n\xE3o \xE9 um objeto JSON`);
+    file = parsed;
+  }
+  const hooks = asHooksRecord(file.hooks);
+  if (file.hooks != null && hooks === null)
+    throw new Error(`${shown}: o campo "hooks" n\xE3o \xE9 um objeto`);
+  const next = hooks ?? {};
+  for (const event of CURSOR_HOOK_EVENTS) {
+    const others = (Array.isArray(next[event]) ? next[event] : []).filter((e) => !isOurCursorEntry(e));
+    others.push({ command: `${scriptPath} cursor` });
+    next[event] = others;
+  }
+  return `${JSON.stringify({ ...file, version: typeof file.version === "number" ? file.version : 1, hooks: next }, null, 2)}
+`;
+}
+function stripCursorHooks(current) {
+  if (!current.trim())
+    return current;
+  const file = asObject(JSON.parse(current));
+  if (!file)
+    return current;
+  const hooks = asObject(file.hooks);
+  if (hooks) {
+    for (const key of Object.keys(hooks)) {
+      if (!Array.isArray(hooks[key]))
+        continue;
+      const kept = hooks[key].filter((e) => !isOurCursorEntry(e));
+      if (kept.length)
+        hooks[key] = kept;
+      else
+        delete hooks[key];
+    }
+    if (Object.keys(hooks).length === 0)
+      delete file.hooks;
+  }
+  return `${JSON.stringify(file, null, 2)}
+`;
+}
 
 // ../../packages/machine-ops/dist/discover.js
 var CLAUDE_MARKERS = ["settings.json", "projects", ".credentials.json"];
@@ -875,6 +959,8 @@ function sh(script, opts = {}) {
 // src/rpc/hooks.ts
 var CODEX_DIR_REL = ".codex";
 var CODEX_CONFIG_REL = ".codex/config.toml";
+var CURSOR_DIR_REL = ".cursor";
+var CURSOR_HOOKS_REL = ".cursor/hooks.json";
 var isEnoent = (err) => err?.code === "ENOENT";
 async function readOrEmpty2(file) {
   try {
@@ -912,6 +998,15 @@ async function claudeTargets(dirs, home) {
   }
   return out;
 }
+async function mergedCursorHooks(home, scriptPath) {
+  if (!await isDir2(path3.join(home, CURSOR_DIR_REL))) return null;
+  try {
+    return mergeCursorHooks(await readOrEmpty2(path3.join(home, CURSOR_HOOKS_REL)), scriptPath, `~/${CURSOR_HOOKS_REL}`);
+  } catch (err) {
+    const message2 = err instanceof SyntaxError || err instanceof Error && err.message.includes("n\xE3o \xE9 um objeto JSON") ? `~/${CURSOR_HOOKS_REL} n\xE3o \xE9 JSON v\xE1lido` : err instanceof Error ? err.message : String(err);
+    throw new RpcFailure("failed", message2, CURSOR_HOOKS_REL);
+  }
+}
 async function install(params, home = os3.homedir()) {
   const scriptPath = path3.join(home, HOOK_SCRIPT_REL);
   const codexFile = path3.join(home, CODEX_CONFIG_REL);
@@ -919,7 +1014,7 @@ async function install(params, home = os3.homedir()) {
   const merged = [];
   for (const target of targets) {
     try {
-      merged.push({ target, body: mergeClaudeSettings(await readOrEmpty2(target.file), scriptPath) });
+      merged.push({ target, body: mergeClaudeSettings(await readOrEmpty2(target.file), scriptPath, target.shown) });
     } catch (err) {
       const message2 = err instanceof SyntaxError || err instanceof Error && err.message.includes("n\xE3o \xE9 um objeto JSON") ? `${target.shown} n\xE3o \xE9 JSON v\xE1lido` : err instanceof Error ? err.message : String(err);
       throw new RpcFailure("failed", message2, relPath(target.shown));
@@ -927,6 +1022,7 @@ async function install(params, home = os3.homedir()) {
   }
   const hasCodex = await isDir2(path3.join(home, CODEX_DIR_REL));
   const mergedCodex = hasCodex ? mergeCodexConfig(await readOrEmpty2(codexFile), scriptPath) : null;
+  const mergedCursor = await mergedCursorHooks(home, scriptPath);
   let current = `~/${HOOK_SCRIPT_REL}`;
   try {
     await mkdir(path3.dirname(scriptPath), { recursive: true });
@@ -943,6 +1039,10 @@ async function install(params, home = os3.homedir()) {
       current = `~/${CODEX_CONFIG_REL}`;
       await writeAtomic(codexFile, mergedCodex, 420);
     }
+    if (mergedCursor !== null) {
+      current = `~/${CURSOR_HOOKS_REL}`;
+      await writeAtomic(path3.join(home, CURSOR_HOOKS_REL), mergedCursor, 420);
+    }
   } catch (err) {
     throw fsFailure(err, current);
   }
@@ -950,6 +1050,7 @@ async function install(params, home = os3.homedir()) {
     home,
     claude: "installed",
     codex: mergedCodex !== null ? "installed" : "skipped",
+    cursor: mergedCursor !== null ? "installed" : "skipped",
     claude_dirs: merged.map(({ target }) => target.shown.replace(/\/settings\.json$/, ""))
   };
 }
@@ -959,22 +1060,71 @@ async function heal(home = os3.homedir()) {
   const script = await readOrEmpty2(scriptPath);
   if (!env.trim() || !script) return [];
   if (script !== HOOK_SCRIPT) await writeAtomic(scriptPath, HOOK_SCRIPT, 493);
+  const steps = [healClaudeDirs, healCursor, healCodex];
+  const healed = [];
+  for (const step of steps) {
+    try {
+      healed.push(...await step(home, scriptPath));
+    } catch {
+    }
+  }
+  return healed;
+}
+var healSkipLogged = /* @__PURE__ */ new Set();
+function logHealSkip(shown, err, key = shown) {
+  if (healSkipLogged.has(key)) return;
+  healSkipLogged.add(key);
+  const code = err?.code;
+  console.error(
+    `[termhub-agent] monitor hooks heal skipped ${JSON.stringify({ path: shown, error: code ?? (err instanceof Error ? err.message : String(err)) })}`
+  );
+}
+async function healClaudeDirs(home, scriptPath) {
   const healed = [];
   for (const dir of await discoverClaudeDirs(home)) {
     const file = path3.join(expandHome(dir, home), "settings.json");
-    const current = await readOrEmpty2(file);
-    let body;
     try {
-      body = mergeClaudeSettings(current, scriptPath);
-    } catch {
+      const current = await readOrEmpty2(file);
+      const body = mergeClaudeSettings(current, scriptPath, `${dir}/settings.json`);
+      if (body === current) continue;
+      await writeAtomic(file, body, 420);
+    } catch (err) {
+      logHealSkip(dir, err, file);
       continue;
     }
-    if (body === current) continue;
-    await writeAtomic(file, body, 420);
     healed.push(dir);
   }
   return healed;
 }
+async function healCursor(home, scriptPath) {
+  if (!await isDir2(path3.join(home, CURSOR_DIR_REL))) return [];
+  const file = path3.join(home, CURSOR_HOOKS_REL);
+  const shown = `~/${CURSOR_DIR_REL}`;
+  try {
+    const current = await readOrEmpty2(file);
+    const body = mergeCursorHooks(current, scriptPath);
+    if (body === current) return [];
+    await writeAtomic(file, body, 420);
+  } catch (err) {
+    logHealSkip(shown, err, file);
+    return [];
+  }
+  return [shown];
+}
+async function healCodex(home, scriptPath) {
+  if (!await isDir2(path3.join(home, CODEX_DIR_REL))) return [];
+  const shown = `~/${CODEX_DIR_REL}`;
+  try {
+    const file = path3.join(home, CODEX_CONFIG_REL);
+    const current = await readOrEmpty2(file);
+    if (/^\s*notify\s*=/m.test(current)) return [];
+    await writeAtomic(file, mergeCodexConfig(current, scriptPath), 420);
+    return [shown];
+  } catch (err) {
+    logHealSkip(shown, err, path3.join(home, CODEX_CONFIG_REL));
+    return [];
+  }
+}
 async function uninstall(params, home = os3.homedir()) {
   const codexFile = path3.join(home, CODEX_CONFIG_REL);
   const stripped = [];
@@ -987,6 +1137,13 @@ async function uninstall(params, home = os3.homedir()) {
     }
   }
   const codexConfig = await isDir2(path3.join(home, CODEX_DIR_REL)) ? await readOrEmpty2(codexFile) : "";
+  const cursorFile = path3.join(home, CURSOR_HOOKS_REL);
+  const cursorHooks = await readOrEmpty2(cursorFile);
+  let strippedCursor = null;
+  try {
+    strippedCursor = cursorHooks.includes(HOOK_MARK) ? stripCursorHooks(cursorHooks) : null;
+  } catch {
+  }
   let current = `~/${HOOK_SCRIPT_REL}`;
   try {
     await rm(path3.join(home, HOOK_SCRIPT_REL), { force: true });
@@ -1000,6 +1157,10 @@ async function uninstall(params, home = os3.homedir()) {
       current = `~/${CODEX_CONFIG_REL}`;
       await writeAtomic(codexFile, stripCodexConfig(codexConfig), 420);
     }
+    if (strippedCursor !== null) {
+      current = `~/${CURSOR_HOOKS_REL}`;
+      await writeAtomic(cursorFile, strippedCursor, 420);
+    }
   } catch (err) {
     throw fsFailure(err, current);
   }
@@ -1866,7 +2027,7 @@ async function status3() {
 }
 
 // src/version.ts
-var AGENT_VERSION = "0.4.1";
+var AGENT_VERSION = "0.4.3";
 
 // src/rpc/update.ts
 var PACKAGE = "@termhub/agent";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@termhub/agent",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Agente do termhub: conecta esta máquina ao servidor por WebSocket de saída (sem SSH) e expõe os terminais tmux no navegador.",
   "license": "MIT",
   "private": false,