@termhub/agent 0.2.3 → 0.3.0

package/dist/cli.js

@@ -56,8 +56,12 @@ var RPC = {
   "tmux.capture": def(z.object({ session: sessionName, lines: z.number().int().min(1).max(5e3) }), z.object({ text: z.string() })),
   /** Idempotent: creates the detached session in `cwd` when it is missing. `created` says whether it had to. */
   "tmux.ensure": def(z.object({ session: sessionName, cwd: machinePath }), z.object({ created: z.boolean() }), 1e4),
-  /** Types `text` literally, then (with `enter`) presses Enter on its own after a short pause. */
-  "tmux.sendText": def(z.object({ session: sessionName, text: z.string().max(TEXT_MAX_CHARS), enter: z.boolean() }), z.object({ sent: z.literal(true) }), 1e4),
+  /**
+   * Types `text` literally, then (with `enter`) presses Enter on its own after a short pause.
+   * `paste`: deliver `text` as a tmux buffer paste instead of typed keystrokes, so a TUI reads
+   * an embedded newline as part of the pasted text rather than as Enter (since agent 0.3.0).
+   */
+  "tmux.sendText": def(z.object({ session: sessionName, text: z.string().max(TEXT_MAX_CHARS), enter: z.boolean(), paste: z.boolean().optional() }), z.object({ sent: z.literal(true) }), 1e4),
   "tmux.sendKey": def(z.object({ session: sessionName, key: tmuxKey }), z.object({ sent: z.literal(true) }), 1e4),
   "tools.detect": def(z.object({}), z.object({ os: z.string().nullable(), tools: z.array(z.string().max(32)) })),
   "hw.probe": def(z.object({}), z.object({ stdout: z.string() }), 15e3),
@@ -211,6 +215,7 @@ function connectOnce(opts, signal) {
       };
       const hello = { type: "hello", protocol: PROTOCOL_VERSION, ...opts.hello };
       socket.sendControl(hello);
+      opts.onConnect?.();
       resolve({ socket, closed });
     });
     ws.on("message", (data) => {
@@ -376,9 +381,10 @@ function deleteConfig() {
 // src/run.ts
 import os6 from "os";
 
-// src/exec.ts
-import { execFile } from "child_process";
-import os2 from "os";
+// src/rpc/hooks.ts
+import { chmod, mkdir, readFile as readFile2, rename, rm, stat as stat2, writeFile } from "fs/promises";
+import os3 from "os";
+import path3 from "path";
 
 // ../../packages/machine-ops/dist/shell.js
 function shellQuote(s) {
@@ -665,13 +671,105 @@ function stripCodexConfig(current) {
   return lines.join("\n");
 }
 
+// ../../packages/machine-ops/dist/discover.js
+var CLAUDE_MARKERS = ["settings.json", "projects", ".credentials.json"];
+var CLAUDE_DIR_NAME = /^\.claude[A-Za-z0-9._-]*$/;
+function claudeDirsFromHome(entries) {
+  const out = [];
+  for (const entry of entries) {
+    if (!CLAUDE_DIR_NAME.test(entry.name))
+      continue;
+    if (!entry.files.some((f) => CLAUDE_MARKERS.includes(f)))
+      continue;
+    const dir = `~/${entry.name}`;
+    if (!out.includes(dir))
+      out.push(dir);
+  }
+  return out;
+}
+var ASSIGNMENT = /CLAUDE_CONFIG_DIR=(?:"([^"\n]*)"|'([^'\n]*)'|([^\s"';]*))/g;
+var FISH_SET = /CLAUDE_CONFIG_DIR\s+(?:"([^"\n]*)"|'([^'\n]*)'|([^\s"';]+))/g;
+function normalize(raw) {
+  let value = raw.trim().replace(/\/+$/, "");
+  value = value.replace(/^\$\{?HOME\}?(?=\/|$)/, "~");
+  if (!value || value === "~" || value.includes("$") || /[\0\n\r]/.test(value))
+    return null;
+  if (!value.startsWith("~/") && !value.startsWith("/"))
+    value = `~/${value}`;
+  return value;
+}
+function configDirsFromRc(text) {
+  const out = [];
+  for (const line of text.split("\n")) {
+    if (/^\s*#/.test(line))
+      continue;
+    const pattern = /^\s*set\s/.test(line) ? FISH_SET : ASSIGNMENT;
+    pattern.lastIndex = 0;
+    for (let m = pattern.exec(line); m; m = pattern.exec(line)) {
+      const dir = normalize(m[1] ?? m[2] ?? m[3] ?? "");
+      if (dir && !out.includes(dir))
+        out.push(dir);
+    }
+  }
+  return out;
+}
+
+// src/claude-dirs.ts
+import { readdir, readFile, stat } from "fs/promises";
+import path2 from "path";
+var RC_FILES = [".zshrc", ".bashrc", ".bash_profile", ".profile", ".config/fish/config.fish"];
+async function readOrEmpty(file) {
+  try {
+    return await readFile(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+async function isDir(dir) {
+  try {
+    return (await stat(dir)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function fileNames(dir) {
+  try {
+    return await readdir(dir);
+  } catch {
+    return [];
+  }
+}
+async function candidateNames(home) {
+  try {
+    const list3 = await readdir(home, { withFileTypes: true });
+    return list3.filter((d) => d.isDirectory() && d.name.startsWith(".claude")).map((d) => d.name);
+  } catch {
+    return [];
+  }
+}
+async function discoverClaudeDirs(home) {
+  const entries = [];
+  for (const name of await candidateNames(home)) {
+    entries.push({ name, files: await fileNames(path2.join(home, name)) });
+  }
+  const dirs = claudeDirsFromHome(entries);
+  for (const rc of RC_FILES) {
+    for (const dir of configDirsFromRc(await readOrEmpty(path2.join(home, rc)))) {
+      if (!dirs.includes(dir) && await isDir(expandHome(dir, home))) dirs.push(dir);
+    }
+  }
+  return dirs;
+}
+
 // src/exec.ts
+import { execFile } from "child_process";
+import os2 from "os";
 var DEFAULT_TIMEOUT_MS = 8e3;
 var RpcFailure = class extends Error {
-  constructor(code, message, path11) {
+  constructor(code, message, path12) {
     super(message);
     this.code = code;
-    this.path = path11;
+    this.path = path12;
   }
   code;
   path;
@@ -716,6 +814,138 @@ function sh(script, opts = {}) {
   return run("/bin/sh", ["-c", script], opts);
 }
 
+// src/rpc/hooks.ts
+var CODEX_DIR_REL = ".codex";
+var CODEX_CONFIG_REL = ".codex/config.toml";
+var isEnoent = (err) => err?.code === "ENOENT";
+async function readOrEmpty2(file) {
+  try {
+    return await readFile2(file, "utf8");
+  } catch (err) {
+    if (isEnoent(err)) return "";
+    throw err;
+  }
+}
+async function isDir2(dir) {
+  try {
+    return (await stat2(dir)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function writeAtomic(file, body, mode) {
+  const tmp = `${file}.termhub-new`;
+  await writeFile(tmp, body, { encoding: "utf8", mode });
+  await chmod(tmp, mode);
+  await rename(tmp, file);
+}
+var relPath = (shown) => shown.startsWith("~/") ? shown.slice(2) : shown;
+function fsFailure(err, shown) {
+  const code = err?.code;
+  if (code === "EACCES" || code === "EPERM") return new RpcFailure("eperm", `sem permiss\xE3o em ${shown}`, relPath(shown));
+  return new RpcFailure("failed", `n\xE3o foi poss\xEDvel escrever ${shown}: ${err instanceof Error ? err.message : String(err)}`, relPath(shown));
+}
+async function claudeTargets(dirs, home) {
+  const out = [];
+  for (const d of claudeConfigDirs([...dirs ?? [], ...await discoverClaudeDirs(home)])) {
+    const dir = expandHome(d, home);
+    if (d !== CLAUDE_DEFAULT_DIR && !await isDir2(dir)) continue;
+    out.push({ dir, file: path3.join(dir, "settings.json"), shown: `${d}/settings.json` });
+  }
+  return out;
+}
+async function install(params, home = os3.homedir()) {
+  const scriptPath = path3.join(home, HOOK_SCRIPT_REL);
+  const codexFile = path3.join(home, CODEX_CONFIG_REL);
+  const targets = await claudeTargets(params.claude_dirs, home);
+  const merged = [];
+  for (const target of targets) {
+    try {
+      merged.push({ target, body: mergeClaudeSettings(await readOrEmpty2(target.file), scriptPath) });
+    } catch (err) {
+      const message = 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", message, relPath(target.shown));
+    }
+  }
+  const hasCodex = await isDir2(path3.join(home, CODEX_DIR_REL));
+  const mergedCodex = hasCodex ? mergeCodexConfig(await readOrEmpty2(codexFile), scriptPath) : null;
+  let current = `~/${HOOK_SCRIPT_REL}`;
+  try {
+    await mkdir(path3.dirname(scriptPath), { recursive: true });
+    current = `~/${HOOK_ENV_REL}`;
+    await writeAtomic(path3.join(home, HOOK_ENV_REL), hookEnvFile(params.hooks_url, params.token), 384);
+    current = `~/${HOOK_SCRIPT_REL}`;
+    await writeAtomic(scriptPath, HOOK_SCRIPT, 493);
+    for (const { target, body } of merged) {
+      current = target.shown;
+      await mkdir(target.dir, { recursive: true });
+      await writeAtomic(target.file, body, 420);
+    }
+    if (mergedCodex !== null) {
+      current = `~/${CODEX_CONFIG_REL}`;
+      await writeAtomic(codexFile, mergedCodex, 420);
+    }
+  } catch (err) {
+    throw fsFailure(err, current);
+  }
+  return {
+    home,
+    claude: "installed",
+    codex: mergedCodex !== null ? "installed" : "skipped",
+    claude_dirs: merged.map(({ target }) => target.shown.replace(/\/settings\.json$/, ""))
+  };
+}
+async function heal(home = os3.homedir()) {
+  const scriptPath = path3.join(home, HOOK_SCRIPT_REL);
+  const env = await readOrEmpty2(path3.join(home, HOOK_ENV_REL));
+  if (!env.trim() || !await readOrEmpty2(scriptPath)) return [];
+  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 {
+      continue;
+    }
+    if (body === current) continue;
+    await writeAtomic(file, body, 420);
+    healed.push(dir);
+  }
+  return healed;
+}
+async function uninstall(params, home = os3.homedir()) {
+  const codexFile = path3.join(home, CODEX_CONFIG_REL);
+  const stripped = [];
+  for (const target of await claudeTargets(params.claude_dirs, home)) {
+    const current2 = await readOrEmpty2(target.file);
+    try {
+      const body = current2.trim() ? stripClaudeSettings(current2) : current2;
+      if (body !== current2) stripped.push({ target, body });
+    } catch {
+    }
+  }
+  const codexConfig = await isDir2(path3.join(home, CODEX_DIR_REL)) ? await readOrEmpty2(codexFile) : "";
+  let current = `~/${HOOK_SCRIPT_REL}`;
+  try {
+    await rm(path3.join(home, HOOK_SCRIPT_REL), { force: true });
+    current = `~/${HOOK_ENV_REL}`;
+    await rm(path3.join(home, HOOK_ENV_REL), { force: true });
+    for (const { target, body } of stripped) {
+      current = target.shown;
+      await writeAtomic(target.file, body, 420);
+    }
+    if (codexConfig.includes(HOOK_MARK)) {
+      current = `~/${CODEX_CONFIG_REL}`;
+      await writeAtomic(codexFile, stripCodexConfig(codexConfig), 420);
+    }
+  } catch (err) {
+    throw fsFailure(err, current);
+  }
+  return { removed: true };
+}
+
 // src/dispatch.ts
 async function handleRpc(msg, socket, handlers2, log2) {
   const method = msg.method;
@@ -773,11 +1003,11 @@ function createDispatcher(deps) {
 
 // src/pty.ts
 import fs3 from "fs";
-import path3 from "path";
+import path5 from "path";
 
 // src/pty-health.ts
 import fs2 from "fs";
-import path2 from "path";
+import path4 from "path";
 import { createRequire } from "module";
 function findSpawnHelper(resolveFrom = import.meta.url) {
   let pkgJson;
@@ -786,10 +1016,10 @@ function findSpawnHelper(resolveFrom = import.meta.url) {
   } catch {
     return null;
   }
-  const root = path2.dirname(pkgJson);
+  const root = path4.dirname(pkgJson);
   const candidates = [
-    path2.join(root, "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper"),
-    path2.join(root, "build", "Release", "spawn-helper")
+    path4.join(root, "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper"),
+    path4.join(root, "build", "Release", "spawn-helper")
   ];
   return candidates.find((p) => fs2.existsSync(p)) ?? null;
 }
@@ -809,7 +1039,7 @@ function ensureSpawnHelperExecutable(helper = findSpawnHelper()) {
 // src/pty.ts
 function expandHome2(rawCwd, home) {
   if (rawCwd === "~") return home;
-  if (rawCwd.startsWith("~/")) return path3.join(home, rawCwd.slice(2));
+  if (rawCwd.startsWith("~/")) return path5.join(home, rawCwd.slice(2));
   return rawCwd;
 }
 function existsDir(p) {
@@ -827,7 +1057,7 @@ function resolveCwd(rawCwd) {
 function isSpawnHelperFailure(err) {
   return /posix_spawnp failed/.test(err instanceof Error ? err.message : String(err));
 }
-function isEnoent(err) {
+function isEnoent2(err) {
   const e = err;
   if (e?.code === "ENOENT") return true;
   const message = e instanceof Error ? e.message : String(err);
@@ -878,7 +1108,7 @@ function createPtyManager(deps) {
         socket.sendControl({
           type: "open_error",
           ch,
-          error: isEnoent(err) ? { code: "no_tmux", message: "tmux not found" } : { code: "internal", message: "failed to start pty" }
+          error: isEnoent2(err) ? { code: "no_tmux", message: "tmux not found" } : { code: "internal", message: "failed to start pty" }
         });
         return;
       }
@@ -983,128 +1213,13 @@ async function list(params) {
   if (failure) throw failure;
   return { stdout: r.stdout };
 }
-async function mkdir(params) {
+async function mkdir2(params) {
   const r = await sh(buildMkdirScript(shellQuote(params.parent), shellQuote(params.name), { recursive: params.recursive === true }));
   const failure = processFailure("fs.mkdir", r);
   if (failure) throw failure;
   return { stdout: r.stdout };
 }
 
-// src/rpc/hooks.ts
-import { chmod, mkdir as mkdir2, readFile, rename, rm, stat, writeFile } from "fs/promises";
-import os3 from "os";
-import path4 from "path";
-var CODEX_DIR_REL = ".codex";
-var CODEX_CONFIG_REL = ".codex/config.toml";
-var isEnoent2 = (err) => err?.code === "ENOENT";
-async function readOrEmpty(file) {
-  try {
-    return await readFile(file, "utf8");
-  } catch (err) {
-    if (isEnoent2(err)) return "";
-    throw err;
-  }
-}
-async function isDir(dir) {
-  try {
-    return (await stat(dir)).isDirectory();
-  } catch {
-    return false;
-  }
-}
-async function writeAtomic(file, body, mode) {
-  const tmp = `${file}.termhub-new`;
-  await writeFile(tmp, body, { encoding: "utf8", mode });
-  await chmod(tmp, mode);
-  await rename(tmp, file);
-}
-var relPath = (shown) => shown.startsWith("~/") ? shown.slice(2) : shown;
-function fsFailure(err, shown) {
-  const code = err?.code;
-  if (code === "EACCES" || code === "EPERM") return new RpcFailure("eperm", `sem permiss\xE3o em ${shown}`, relPath(shown));
-  return new RpcFailure("failed", `n\xE3o foi poss\xEDvel escrever ${shown}: ${err instanceof Error ? err.message : String(err)}`, relPath(shown));
-}
-async function claudeTargets(dirs, home) {
-  const out = [];
-  for (const d of claudeConfigDirs(dirs ?? [])) {
-    const dir = expandHome(d, home);
-    if (d !== CLAUDE_DEFAULT_DIR && !await isDir(dir)) continue;
-    out.push({ dir, file: path4.join(dir, "settings.json"), shown: `${d}/settings.json` });
-  }
-  return out;
-}
-async function install(params, home = os3.homedir()) {
-  const scriptPath = path4.join(home, HOOK_SCRIPT_REL);
-  const codexFile = path4.join(home, CODEX_CONFIG_REL);
-  const targets = await claudeTargets(params.claude_dirs, home);
-  const merged = [];
-  for (const target of targets) {
-    try {
-      merged.push({ target, body: mergeClaudeSettings(await readOrEmpty(target.file), scriptPath) });
-    } catch (err) {
-      const message = 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", message, relPath(target.shown));
-    }
-  }
-  const hasCodex = await isDir(path4.join(home, CODEX_DIR_REL));
-  const mergedCodex = hasCodex ? mergeCodexConfig(await readOrEmpty(codexFile), scriptPath) : null;
-  let current = `~/${HOOK_SCRIPT_REL}`;
-  try {
-    await mkdir2(path4.dirname(scriptPath), { recursive: true });
-    current = `~/${HOOK_ENV_REL}`;
-    await writeAtomic(path4.join(home, HOOK_ENV_REL), hookEnvFile(params.hooks_url, params.token), 384);
-    current = `~/${HOOK_SCRIPT_REL}`;
-    await writeAtomic(scriptPath, HOOK_SCRIPT, 493);
-    for (const { target, body } of merged) {
-      current = target.shown;
-      await mkdir2(target.dir, { recursive: true });
-      await writeAtomic(target.file, body, 420);
-    }
-    if (mergedCodex !== null) {
-      current = `~/${CODEX_CONFIG_REL}`;
-      await writeAtomic(codexFile, mergedCodex, 420);
-    }
-  } catch (err) {
-    throw fsFailure(err, current);
-  }
-  return {
-    home,
-    claude: "installed",
-    codex: mergedCodex !== null ? "installed" : "skipped",
-    claude_dirs: merged.map(({ target }) => target.shown.replace(/\/settings\.json$/, ""))
-  };
-}
-async function uninstall(params, home = os3.homedir()) {
-  const codexFile = path4.join(home, CODEX_CONFIG_REL);
-  const stripped = [];
-  for (const target of await claudeTargets(params.claude_dirs, home)) {
-    const current2 = await readOrEmpty(target.file);
-    try {
-      const body = current2.trim() ? stripClaudeSettings(current2) : current2;
-      if (body !== current2) stripped.push({ target, body });
-    } catch {
-    }
-  }
-  const codexConfig = await isDir(path4.join(home, CODEX_DIR_REL)) ? await readOrEmpty(codexFile) : "";
-  let current = `~/${HOOK_SCRIPT_REL}`;
-  try {
-    await rm(path4.join(home, HOOK_SCRIPT_REL), { force: true });
-    current = `~/${HOOK_ENV_REL}`;
-    await rm(path4.join(home, HOOK_ENV_REL), { force: true });
-    for (const { target, body } of stripped) {
-      current = target.shown;
-      await writeAtomic(target.file, body, 420);
-    }
-    if (codexConfig.includes(HOOK_MARK)) {
-      current = `~/${CODEX_CONFIG_REL}`;
-      await writeAtomic(codexFile, stripCodexConfig(codexConfig), 420);
-    }
-  } catch (err) {
-    throw fsFailure(err, current);
-  }
-  return { removed: true };
-}
-
 // src/rpc/hw.ts
 async function probe(_params) {
   const r = await sh(HARDWARE_SCRIPT, { timeoutMs: 14e3 });
@@ -1121,12 +1236,13 @@ async function pasteFile(params) {
   if (r.timedOut) throw new RpcFailure("timeout", "file.paste timed out");
   if (r.code !== 0) throw new RpcFailure("internal", `file.paste exited with code ${r.code}`);
   const lines = r.stdout.split("\n").map((l) => l.trim()).filter(Boolean);
-  const path11 = lines[lines.length - 1] ?? "";
-  if (!path11.startsWith("/")) throw new RpcFailure("internal", "unexpected paste output");
-  return { path: path11 };
+  const path12 = lines[lines.length - 1] ?? "";
+  if (!path12.startsWith("/")) throw new RpcFailure("internal", "unexpected paste output");
+  return { path: path12 };
 }
 
 // src/rpc/tmux.ts
+import { randomUUID } from "crypto";
 var ENTER_PAUSE_MS = 300;
 function processFailure2(r) {
   if (r.timedOut) return new RpcFailure("timeout", "tmux timed out");
@@ -1168,12 +1284,31 @@ async function ensure(params) {
   if (made.code !== 0) throw new RpcFailure("failed", why(made.stderr, "tmux new-session falhou"), params.cwd);
   return { created: true };
 }
+async function pasteText(session, text) {
+  const bufferName = `termhub-paste-${randomUUID()}`;
+  try {
+    const loaded = await run(tmuxPath(), ["load-buffer", "-b", bufferName, "-"], { input: Buffer.from(text, "utf8") });
+    const loadFailure = processFailure2(loaded);
+    if (loadFailure) throw loadFailure;
+    if (loaded.code !== 0) throw new RpcFailure("internal", why(loaded.stderr, "tmux load-buffer failed"));
+    const pasted = await run(tmuxPath(), ["paste-buffer", "-p", "-d", "-b", bufferName, "-t", pane(session)]);
+    const pasteFailure = processFailure2(pasted);
+    if (pasteFailure) throw pasteFailure;
+    if (pasted.code !== 0) throw new RpcFailure("notfound", why(pasted.stderr, "session not found"));
+  } finally {
+    await run(tmuxPath(), ["delete-buffer", "-b", bufferName]);
+  }
+}
 async function sendText(params) {
   if (params.text) {
-    const typed = await run(tmuxPath(), ["send-keys", "-t", pane(params.session), "-l", "--", params.text]);
-    const failure = processFailure2(typed);
-    if (failure) throw failure;
-    if (typed.code !== 0) throw new RpcFailure("notfound", why(typed.stderr, "session not found"));
+    if (params.paste) {
+      await pasteText(params.session, params.text);
+    } else {
+      const typed = await run(tmuxPath(), ["send-keys", "-t", pane(params.session), "-l", "--", params.text]);
+      const failure = processFailure2(typed);
+      if (failure) throw failure;
+      if (typed.code !== 0) throw new RpcFailure("notfound", why(typed.stderr, "session not found"));
+    }
     if (params.enter) await new Promise((r) => setTimeout(r, ENTER_PAUSE_MS));
   }
   if (params.enter) {
@@ -1203,19 +1338,19 @@ async function detect(_params) {
 
 // src/rpc/update.ts
 import { existsSync, realpathSync as realpathSync2 } from "fs";
-import { readFile as readFile2 } from "fs/promises";
-import path9 from "path";
+import { readFile as readFile3 } from "fs/promises";
+import path10 from "path";
 
 // src/paths.ts
 import { realpathSync } from "fs";
-import path5 from "path";
+import path6 from "path";
 import { pathToFileURL } from "url";
 function resolveScriptPath(argv1) {
   if (!argv1) return "";
   try {
     return realpathSync(argv1);
   } catch {
-    return path5.resolve(argv1);
+    return path6.resolve(argv1);
   }
 }
 function isMainModule(importMetaUrl, argv1) {
@@ -1224,12 +1359,12 @@ function isMainModule(importMetaUrl, argv1) {
 }
 
 // src/service/index.ts
-import path8 from "path";
+import path9 from "path";
 
 // src/service/launchd.ts
 import fs4 from "fs";
 import os4 from "os";
-import path6 from "path";
+import path7 from "path";
 var LABEL = "dev.termhub.agent";
 function renderPlist({ label, node, script, logPath }) {
   const escape = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -1268,7 +1403,7 @@ function renderPlist({ label, node, script, logPath }) {
 `;
 }
 function plistPath(home = os4.homedir()) {
-  return path6.join(home, "Library", "LaunchAgents", `${LABEL}.plist`);
+  return path7.join(home, "Library", "LaunchAgents", `${LABEL}.plist`);
 }
 function gui() {
   return `gui/${process.getuid ? process.getuid() : 0}`;
@@ -1277,7 +1412,7 @@ async function install2(opts, deps = {}) {
   const runFn = deps.run ?? run;
   const file = plistPath(deps.home);
   const plist = renderPlist({ label: LABEL, node: opts.node, script: opts.script, logPath: opts.logPath });
-  fs4.mkdirSync(path6.dirname(file), { recursive: true });
+  fs4.mkdirSync(path7.dirname(file), { recursive: true });
   fs4.writeFileSync(file, plist, "utf8");
   await runFn("launchctl", ["bootout", gui(), file]);
   const result = await runFn("launchctl", ["bootstrap", gui(), file]);
@@ -1313,7 +1448,7 @@ async function status(deps = {}) {
 // src/service/systemd.ts
 import fs5 from "fs";
 import os5 from "os";
-import path7 from "path";
+import path8 from "path";
 var UNIT_NAME = "termhub-agent";
 function renderUnit({ node, script, logPath, pathEnv }) {
   const lines = [
@@ -1336,13 +1471,13 @@ function renderUnit({ node, script, logPath, pathEnv }) {
   return lines.join("\n");
 }
 function unitPath(home = os5.homedir()) {
-  return path7.join(home, ".config", "systemd", "user", `${UNIT_NAME}.service`);
+  return path8.join(home, ".config", "systemd", "user", `${UNIT_NAME}.service`);
 }
 async function install3(opts, deps = {}) {
   const runFn = deps.run ?? run;
   const file = unitPath(deps.home);
   const unit = renderUnit({ node: opts.node, script: opts.script, logPath: opts.logPath });
-  fs5.mkdirSync(path7.dirname(file), { recursive: true });
+  fs5.mkdirSync(path8.dirname(file), { recursive: true });
   fs5.writeFileSync(file, unit, "utf8");
   const reload = await runFn("systemctl", ["--user", "daemon-reload"]);
   if (reload.code !== 0) throw new Error(`systemctl daemon-reload failed (code ${reload.code}): ${reload.stderr.trim()}`);
@@ -1391,7 +1526,7 @@ function serviceFileOptions() {
   return {
     node: process.execPath,
     script: resolveScriptPath(process.argv[1]),
-    logPath: path8.join(agentHome(), "agent.log")
+    logPath: path9.join(agentHome(), "agent.log")
   };
 }
 function assertSupported(platform) {
@@ -1422,24 +1557,24 @@ async function status3() {
 }
 
 // src/version.ts
-var AGENT_VERSION = "0.2.3";
+var AGENT_VERSION = "0.3.0";
 
 // src/rpc/update.ts
 var PACKAGE = "@termhub/agent";
 var NPM_TIMEOUT_MS = 15e4;
 var EXIT_DELAY_MS = 750;
 function npmCliBesideNode(execPath = process.execPath) {
-  const dir = path9.dirname(execPath);
-  const symlink = path9.join(dir, "npm");
+  const dir = path10.dirname(execPath);
+  const symlink = path10.join(dir, "npm");
   if (existsSync(symlink)) return realpathSync2(symlink);
-  const fallback = path9.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js");
+  const fallback = path10.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js");
   return existsSync(fallback) ? fallback : null;
 }
 async function installedAgentVersion(argv1 = process.argv[1]) {
   const script = resolveScriptPath(argv1);
   if (!script) return null;
   try {
-    const pkg = JSON.parse(await readFile2(path9.join(path9.dirname(script), "..", "package.json"), "utf8"));
+    const pkg = JSON.parse(await readFile3(path10.join(path10.dirname(script), "..", "package.json"), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : null;
   } catch {
     return null;
@@ -1497,7 +1632,7 @@ var handlers = {
   "tools.detect": detect,
   "hw.probe": probe,
   "fs.list": list,
-  "fs.mkdir": mkdir,
+  "fs.mkdir": mkdir2,
   "ai.credential": credential,
   "file.paste": pasteFile,
   "hooks.install": install,
@@ -1586,6 +1721,12 @@ async function runAgent(config, opts) {
   else if (!helper.executable) opts.log("spawn-helper is not executable and could not be fixed", { path: helper.path, error: helper.error });
   const pty = createPtyManager({ log: opts.log });
   const dispatch = createDispatcher({ handlers, pty, log: opts.log });
+  const healHooks = () => {
+    heal().then((dirs) => {
+      if (dirs.length) opts.log("monitor hooks repaired", { dirs: dirs.length });
+    }).catch((err) => opts.log("monitor hooks could not be repaired", { error: err instanceof Error ? err.message : String(err) }));
+  };
+  healHooks();
   try {
     await runForever(
       {
@@ -1594,6 +1735,7 @@ async function runAgent(config, opts) {
         hello,
         onServerMessage: dispatch,
         onStream: (ch, data) => pty.write(ch, data),
+        onConnect: healHooks,
         onDisconnect: () => pty.closeAll(),
         log: opts.log
       },
@@ -1695,15 +1837,15 @@ function disconnectCommand() {
 // src/doctor.ts
 import fs6 from "fs";
 import os7 from "os";
-import path10 from "path";
+import path11 from "path";
 var SERVER_CHECK_TIMEOUT_MS = 5e3;
 function defaultDoctorPaths() {
   const home = os7.homedir();
-  const paths = [home, path10.join(home, "Documents"), path10.join(home, "Desktop")];
+  const paths = [home, path11.join(home, "Documents"), path11.join(home, "Desktop")];
   if (process.platform === "darwin") {
     try {
       for (const entry of fs6.readdirSync("/Volumes", { withFileTypes: true })) {
-        if (entry.isDirectory()) paths.push(path10.join("/Volumes", entry.name));
+        if (entry.isDirectory()) paths.push(path11.join("/Volumes", entry.name));
       }
     } catch {
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@termhub/agent",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "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,