@termhub/agent 0.1.3 → 0.1.5

package/dist/cli.js

@@ -40,7 +40,8 @@ var machinePath = z.string().min(1).max(4096).refine((p) => (p === "~" || p.star
 var pasteName = z.string().min(1).max(255).regex(/^[A-Za-z0-9._-]+$/);
 var aiProvider = z.enum(["claude", "chatgpt", "gemini", "antigravity"]);
 var rpcErrorSchema = z.object({
-  code: z.enum(["eperm", "notfound", "no_tmux", "timeout", "invalid", "internal"]),
+  /** `failed`: the operation ran on the machine and `message` says why it failed, in words meant for the user. */
+  code: z.enum(["eperm", "notfound", "no_tmux", "timeout", "invalid", "internal", "failed"]),
   message: z.string().max(2e3),
   path: z.string().max(4096).optional()
 });
@@ -60,7 +61,15 @@ var RPC = {
     recursive: z.boolean().optional()
   }), z.object({ stdout: z.string() })),
   "ai.credential": def(z.object({ provider: aiProvider, config_dir: machinePath.nullable() }), z.object({ stdout: z.string() }), 1e4),
-  "file.paste": def(z.object({ name: pasteName, data_b64: z.string().min(1).max(28 * 1024 * 1024) }), z.object({ path: z.string() }), 6e4)
+  "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. */
+  "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),
+  "hooks.uninstall": def(z.object({ claude_dirs: z.array(machinePath).max(16).optional() }), z.object({ removed: z.boolean() }), 15e3)
 };
 var RPC_METHODS = Object.keys(RPC);
 var rpcMethod = z.enum(RPC_METHODS);
@@ -355,7 +364,7 @@ function deleteConfig() {
 }
 
 // src/run.ts
-import os4 from "os";
+import os5 from "os";
 
 // src/exec.ts
 import { execFile } from "child_process";
@@ -372,16 +381,16 @@ var DETECT_TOOLS = ["tmux", "claude", "gh", "git", "node", "pnpm", "xcodebuild",
 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) {
-  let os8 = null;
+  let os9 = null;
   const caps = [];
   for (const line of stdout.split("\n")) {
     if (line.startsWith("OS:")) {
       const raw = line.slice(3).trim().toLowerCase();
-      os8 = raw === "darwin" ? "macos" : raw || null;
+      os9 = raw === "darwin" ? "macos" : raw || null;
     } else if (line.startsWith("CAP:"))
       caps.push(line.slice(4).trim());
   }
-  return { os: os8, capabilities: caps };
+  return { os: os9, capabilities: caps };
 }
 
 // ../../packages/machine-ops/dist/hardware-script.js
@@ -526,13 +535,121 @@ function ptyEnv(base, shell) {
   };
 }
 
+// ../../packages/machine-ops/dist/hooks.js
+var HOOK_SCRIPT_REL = ".termhub/bin/termhub-hook";
+var HOOK_ENV_REL = ".termhub/hook.env";
+var HOOK_MARK = "termhub-hook";
+var CLAUDE_DEFAULT_DIR = "~/.claude";
+function claudeConfigDirs(accountDirs) {
+  const out = [CLAUDE_DEFAULT_DIR];
+  for (const raw of accountDirs) {
+    let d = (raw ?? "").trim().replace(/\/+$/, "");
+    if (!d || d === "~" || /[\0\n\r]/.test(d))
+      continue;
+    if (!d.startsWith("~/") && !d.startsWith("/"))
+      d = `~/${d}`;
+    if (!out.includes(d))
+      out.push(d);
+  }
+  return out;
+}
+function expandHome(dir, home) {
+  return dir.startsWith("~/") ? `${home}/${dir.slice(2)}` : dir;
+}
+var CLAUDE_HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "Notification", "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).
+TOOL="\${1:-claude}"
+[ -f "$HOME/${HOOK_ENV_REL}" ] || exit 0
+. "$HOME/${HOOK_ENV_REL}"
+[ -n "$TERMHUB_HOOK_URL" ] && [ -n "$TERMHUB_HOOK_TOKEN" ] || exit 0
+[ -n "$TMUX_PANE" ] || exit 0
+PATH="$HOME/.local/bin:/opt/homebrew/bin:/usr/local/bin:$PATH"
+SESSION=$(tmux display-message -p -t "$TMUX_PANE" '#{session_name}' 2>/dev/null) || exit 0
+[ -n "$SESSION" ] || exit 0
+if [ "$TOOL" = codex ]; then EVENT="$2"; else EVENT=$(cat 2>/dev/null); fi
+[ -n "$EVENT" ] || EVENT='{}'
+{ printf '{"tool":"%s","session":"%s","event":' "$TOOL" "$SESSION"; printf '%s' "$EVENT"; printf '}'; } |
+  curl -s -m 5 -o /dev/null -X POST "$TERMHUB_HOOK_URL" \\
+    -H "authorization: Bearer $TERMHUB_HOOK_TOKEN" -H 'content-type: application/json' --data-binary @- >/dev/null 2>&1 &
+exit 0
+`;
+function hookEnvFile(hooksUrl, token) {
+  return `TERMHUB_HOOK_URL=${shellQuote(hooksUrl)}
+TERMHUB_HOOK_TOKEN=${shellQuote(token)}
+`;
+}
+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) {
+  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");
+    settings = parsed;
+  }
+  const hooks = settings.hooks && typeof settings.hooks === "object" && !Array.isArray(settings.hooks) ? settings.hooks : {};
+  for (const event of CLAUDE_HOOK_EVENTS) {
+    const list3 = Array.isArray(hooks[event]) ? hooks[event] : [];
+    const others = list3.filter((e) => !isOurs(e));
+    others.push({ hooks: [{ type: "command", command: `${scriptPath} claude`, timeout: 10 }] });
+    hooks[event] = others;
+  }
+  settings.hooks = hooks;
+  return `${JSON.stringify(settings, null, 2)}
+`;
+}
+function stripClaudeSettings(current) {
+  if (!current.trim())
+    return current;
+  const parsed = JSON.parse(current);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return current;
+  const settings = parsed;
+  const hooks = settings.hooks;
+  if (hooks && typeof hooks === "object" && !Array.isArray(hooks)) {
+    const h = hooks;
+    for (const key of Object.keys(h)) {
+      if (!Array.isArray(h[key]))
+        continue;
+      const kept = h[key].filter((e) => !isOurs(e));
+      if (kept.length)
+        h[key] = kept;
+      else
+        delete h[key];
+    }
+    if (Object.keys(h).length === 0)
+      delete settings.hooks;
+  }
+  return `${JSON.stringify(settings, null, 2)}
+`;
+}
+function mergeCodexConfig(current, scriptPath) {
+  const line = `notify = [${JSON.stringify(scriptPath)}, "codex"]`;
+  const lines = current.split("\n");
+  const idx = lines.findIndex((l) => /^\s*notify\s*=/.test(l));
+  if (idx !== -1)
+    lines[idx] = line;
+  else
+    lines.unshift(line);
+  const out = lines.join("\n");
+  return out.endsWith("\n") ? out : `${out}
+`;
+}
+function stripCodexConfig(current) {
+  const lines = current.split("\n").filter((l) => !(/^\s*notify\s*=/.test(l) && l.includes(HOOK_MARK)));
+  return lines.join("\n");
+}
+
 // src/exec.ts
 var DEFAULT_TIMEOUT_MS = 8e3;
 var RpcFailure = class extends Error {
-  constructor(code, message, path9) {
+  constructor(code, message, path10) {
     super(message);
     this.code = code;
-    this.path = path9;
+    this.path = path10;
   }
   code;
   path;
@@ -635,7 +752,7 @@ function createDispatcher(deps) {
 // src/pty.ts
 import fs2 from "fs";
 import path2 from "path";
-function expandHome(rawCwd, home) {
+function expandHome2(rawCwd, home) {
   if (rawCwd === "~") return home;
   if (rawCwd.startsWith("~/")) return path2.join(home, rawCwd.slice(2));
   return rawCwd;
@@ -649,7 +766,7 @@ function existsDir(p) {
 }
 function resolveCwd(rawCwd) {
   const home = process.env.HOME || "/";
-  const expanded = expandHome(rawCwd, home);
+  const expanded = expandHome2(rawCwd, home);
   return existsDir(expanded) ? expanded : home;
 }
 function isEnoent(err) {
@@ -836,6 +953,121 @@ async function mkdir(params) {
   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 });
@@ -852,9 +1084,9 @@ 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 path9 = lines[lines.length - 1] ?? "";
-  if (!path9.startsWith("/")) throw new RpcFailure("internal", "unexpected paste output");
-  return { path: path9 };
+  const path10 = lines[lines.length - 1] ?? "";
+  if (!path10.startsWith("/")) throw new RpcFailure("internal", "unexpected paste output");
+  return { path: path10 };
 }
 
 // src/rpc/tmux.ts
@@ -891,8 +1123,8 @@ async function detect(_params) {
   const r = await sh(DETECT_SCRIPT);
   if (r.timedOut) throw new RpcFailure("timeout", "tools.detect timed out");
   if (r.code !== 0) throw new RpcFailure("internal", `tools.detect exited with code ${r.code}`);
-  const { os: os8, capabilities } = parseDetect(r.stdout);
-  return { os: os8, tools: capabilities };
+  const { os: os9, capabilities } = parseDetect(r.stdout);
+  return { os: os9, tools: capabilities };
 }
 
 // src/rpc/index.ts
@@ -905,13 +1137,15 @@ var handlers = {
   "fs.list": list,
   "fs.mkdir": mkdir,
   "ai.credential": credential,
-  "file.paste": pasteFile
+  "file.paste": pasteFile,
+  "hooks.install": install,
+  "hooks.uninstall": uninstall
 };
 
 // src/service/launchd.ts
 import fs4 from "fs";
-import os3 from "os";
-import path4 from "path";
+import os4 from "os";
+import path5 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;");
@@ -944,22 +1178,22 @@ function renderPlist({ label, node, script, logPath }) {
     <string>${escape(agentEnv().PATH ?? "")}</string>
   </dict>
   <key>WorkingDirectory</key>
-  <string>${escape(os3.homedir())}</string>
+  <string>${escape(os4.homedir())}</string>
 </dict>
 </plist>
 `;
 }
 function plistPath() {
-  return path4.join(os3.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+  return path5.join(os4.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
 }
 function gui() {
   return `gui/${process.getuid ? process.getuid() : 0}`;
 }
-async function install(opts, deps = {}) {
+async function install2(opts, deps = {}) {
   const runFn = deps.run ?? run;
   const file = plistPath();
   const plist = renderPlist({ label: LABEL, node: opts.node, script: opts.script, logPath: opts.logPath });
-  fs4.mkdirSync(path4.dirname(file), { recursive: true });
+  fs4.mkdirSync(path5.dirname(file), { recursive: true });
   fs4.writeFileSync(file, plist, "utf8");
   await runFn("launchctl", ["bootout", gui(), file]);
   const result = await runFn("launchctl", ["bootstrap", gui(), file]);
@@ -967,7 +1201,7 @@ async function install(opts, deps = {}) {
     throw new Error(`launchctl bootstrap failed (code ${result.code}): ${result.stderr.trim() || result.stdout.trim()}`);
   }
 }
-async function uninstall(deps = {}) {
+async function uninstall2(deps = {}) {
   const runFn = deps.run ?? run;
   const file = plistPath();
   await runFn("launchctl", ["bootout", gui(), file]);
@@ -993,7 +1227,7 @@ async function status(deps = {}) {
 }
 
 // src/version.ts
-var AGENT_VERSION = "0.1.3";
+var AGENT_VERSION = "0.1.5";
 
 // src/run.ts
 function detectOs(platform = process.platform) {
@@ -1013,7 +1247,7 @@ async function buildHello(osName) {
     agent_version: AGENT_VERSION,
     os: osName,
     arch: process.arch,
-    hostname: os4.hostname(),
+    hostname: os5.hostname(),
     tmux: tools.includes("tmux"),
     tools
   };
@@ -1033,7 +1267,7 @@ async function checkServerConnection(config, timeoutMs = 5e3) {
       {
         url: config.url,
         token: config.token,
-        hello: { agent_version: AGENT_VERSION, os: osName, arch: process.arch, hostname: os4.hostname(), tmux: false, tools: [], probe: true },
+        hello: { agent_version: AGENT_VERSION, os: osName, arch: process.arch, hostname: os5.hostname(), tmux: false, tools: [], probe: true },
         onServerMessage: () => {
         },
         onStream: () => {
@@ -1184,16 +1418,16 @@ function disconnectCommand() {
 
 // src/doctor.ts
 import fs5 from "fs";
-import os5 from "os";
-import path5 from "path";
+import os6 from "os";
+import path6 from "path";
 var SERVER_CHECK_TIMEOUT_MS = 5e3;
 function defaultDoctorPaths() {
-  const home = os5.homedir();
-  const paths = [home, path5.join(home, "Documents"), path5.join(home, "Desktop")];
+  const home = os6.homedir();
+  const paths = [home, path6.join(home, "Documents"), path6.join(home, "Desktop")];
   if (process.platform === "darwin") {
     try {
       for (const entry of fs5.readdirSync("/Volumes", { withFileTypes: true })) {
-        if (entry.isDirectory()) paths.push(path5.join("/Volumes", entry.name));
+        if (entry.isDirectory()) paths.push(path6.join("/Volumes", entry.name));
       }
     } catch {
     }
@@ -1285,21 +1519,21 @@ async function runCommand(log2) {
 }
 
 // src/commands/service.ts
-import os7 from "os";
+import os8 from "os";
 
 // src/service/index.ts
-import path8 from "path";
+import path9 from "path";
 
 // src/paths.ts
 import { realpathSync } from "fs";
-import path6 from "path";
+import path7 from "path";
 import { pathToFileURL } from "url";
 function resolveScriptPath(argv1) {
   if (!argv1) return "";
   try {
     return realpathSync(argv1);
   } catch {
-    return path6.resolve(argv1);
+    return path7.resolve(argv1);
   }
 }
 function isMainModule(importMetaUrl, argv1) {
@@ -1309,8 +1543,8 @@ function isMainModule(importMetaUrl, argv1) {
 
 // src/service/systemd.ts
 import fs6 from "fs";
-import os6 from "os";
-import path7 from "path";
+import os7 from "os";
+import path8 from "path";
 var UNIT_NAME = "termhub-agent";
 function renderUnit({ node, script, logPath }) {
   const lines = [
@@ -1332,13 +1566,13 @@ function renderUnit({ node, script, logPath }) {
   return lines.join("\n");
 }
 function unitPath() {
-  return path7.join(os6.homedir(), ".config", "systemd", "user", `${UNIT_NAME}.service`);
+  return path8.join(os7.homedir(), ".config", "systemd", "user", `${UNIT_NAME}.service`);
 }
-async function install2(opts, deps = {}) {
+async function install3(opts, deps = {}) {
   const runFn = deps.run ?? run;
   const file = unitPath();
   const unit = renderUnit({ node: opts.node, script: opts.script, logPath: opts.logPath });
-  fs6.mkdirSync(path7.dirname(file), { recursive: true });
+  fs6.mkdirSync(path8.dirname(file), { recursive: true });
   fs6.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()}`);
@@ -1346,7 +1580,7 @@ async function install2(opts, deps = {}) {
   if (enable.code !== 0) throw new Error(`systemctl enable --now failed (code ${enable.code}): ${enable.stderr.trim()}`);
   console.log("Para o agente continuar ap\xF3s o logout: loginctl enable-linger $USER");
 }
-async function uninstall2(deps = {}) {
+async function uninstall3(deps = {}) {
   const runFn = deps.run ?? run;
   await runFn("systemctl", ["--user", "disable", "--now", UNIT_NAME]);
   try {
@@ -1367,24 +1601,24 @@ 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) {
   if (platform !== "darwin" && platform !== "linux") throw new Error("Sistema n\xE3o suportado");
 }
-async function install3() {
+async function install4() {
   const platform = process.platform;
   assertSupported(platform);
   const opts = serviceFileOptions();
-  if (platform === "darwin") await install(opts);
-  else await install2(opts);
+  if (platform === "darwin") await install2(opts);
+  else await install3(opts);
 }
-async function uninstall3() {
+async function uninstall4() {
   const platform = process.platform;
   assertSupported(platform);
-  if (platform === "darwin") await uninstall();
-  else await uninstall2();
+  if (platform === "darwin") await uninstall2();
+  else await uninstall3();
 }
 async function status3() {
   const platform = process.platform;
@@ -1397,16 +1631,16 @@ async function status3() {
 async function serviceCommand(sub) {
   switch (sub) {
     case "install": {
-      const homeCheck = checkPathAccess(os7.homedir());
+      const homeCheck = checkPathAccess(os8.homedir());
       if (!homeCheck.ok && homeCheck.error === "eperm" && process.platform === "darwin") {
         console.error(fullDiskAccessNote());
       }
-      await install3();
+      await install4();
       console.log("Servi\xE7o instalado.");
       return;
     }
     case "uninstall":
-      await uninstall3();
+      await uninstall4();
       console.log("Servi\xE7o removido.");
       return;
     case "status": {

package/package.json

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