@termhub/agent 0.1.7 → 0.2.1

package/dist/cli.js

@@ -39,6 +39,9 @@ var sessionName = z.string().min(1).max(128).regex(SESSION_RE);
 var machinePath = z.string().min(1).max(4096).refine((p) => (p === "~" || p.startsWith("~/") || p.startsWith("/")) && !/[\0\n\r]/.test(p), "invalid path");
 var pasteName = z.string().min(1).max(255).regex(/^[A-Za-z0-9._-]+$/);
 var aiProvider = z.enum(["claude", "chatgpt", "gemini", "antigravity"]);
+var TMUX_KEYS = ["Enter", "Escape", "C-c", "Up", "Down", "Tab", "y", "n", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
+var tmuxKey = z.enum(TMUX_KEYS);
+var TEXT_MAX_CHARS = 4e3;
 var rpcErrorSchema = z.object({
   /** `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"]),
@@ -51,6 +54,11 @@ var RPC = {
   "tmux.list": def(z.object({}), z.object({ sessions: z.array(sessionName) })),
   "tmux.kill": def(z.object({ session: sessionName }), z.object({ killed: z.boolean() })),
   "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),
+  "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),
   "fs.list": def(z.object({ path: machinePath }), z.object({ stdout: z.string() })),
@@ -69,7 +77,9 @@ var RPC = {
     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)
+  "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)
 };
 var RPC_METHODS = Object.keys(RPC);
 var rpcMethod = z.enum(RPC_METHODS);
@@ -364,7 +374,7 @@ function deleteConfig() {
 }
 
 // src/run.ts
-import os5 from "os";
+import os6 from "os";
 
 // src/exec.ts
 import { execFile } from "child_process";
@@ -658,10 +668,10 @@ function stripCodexConfig(current) {
 // src/exec.ts
 var DEFAULT_TIMEOUT_MS = 8e3;
 var RpcFailure = class extends Error {
-  constructor(code, message, path10) {
+  constructor(code, message, path11) {
     super(message);
     this.code = code;
-    this.path = path10;
+    this.path = path11;
   }
   code;
   path;
@@ -1111,12 +1121,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 path10 = lines[lines.length - 1] ?? "";
-  if (!path10.startsWith("/")) throw new RpcFailure("internal", "unexpected paste output");
-  return { path: path10 };
+  const path11 = lines[lines.length - 1] ?? "";
+  if (!path11.startsWith("/")) throw new RpcFailure("internal", "unexpected paste output");
+  return { path: path11 };
 }
 
 // src/rpc/tmux.ts
+var ENTER_PAUSE_MS = 300;
 function processFailure2(r) {
   if (r.timedOut) return new RpcFailure("timeout", "tmux timed out");
   if (r.error === "enoent") return new RpcFailure("no_tmux", "tmux not found");
@@ -1144,6 +1155,42 @@ async function capture(params) {
   if (r.code !== 0) throw new RpcFailure("notfound", "session not found");
   return { text: r.stdout };
 }
+var pane = (session) => `=${session}:`;
+var why = (stderr, fallback) => stderr.trim().split("\n")[0] || fallback;
+async function ensure(params) {
+  const has = await run(tmuxPath(), ["has-session", "-t", `=${params.session}`]);
+  const hasFailure = processFailure2(has);
+  if (hasFailure) throw hasFailure;
+  if (has.code === 0) return { created: false };
+  const made = await run(tmuxPath(), ["new-session", "-d", "-s", params.session, "-c", params.cwd]);
+  const madeFailure = processFailure2(made);
+  if (madeFailure) throw madeFailure;
+  if (made.code !== 0) throw new RpcFailure("failed", why(made.stderr, "tmux new-session falhou"), params.cwd);
+  return { created: true };
+}
+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.enter) await new Promise((r) => setTimeout(r, ENTER_PAUSE_MS));
+  }
+  if (params.enter) {
+    const entered = await run(tmuxPath(), ["send-keys", "-t", pane(params.session), "Enter"]);
+    const failure = processFailure2(entered);
+    if (failure) throw failure;
+    if (entered.code !== 0) throw new RpcFailure("notfound", why(entered.stderr, "session not found"));
+  }
+  return { sent: true };
+}
+async function sendKey(params) {
+  const r = await run(tmuxPath(), ["send-keys", "-t", pane(params.session), params.key]);
+  const failure = processFailure2(r);
+  if (failure) throw failure;
+  if (r.code !== 0) throw new RpcFailure("notfound", why(r.stderr, "session not found"));
+  return { sent: true };
+}
 
 // src/rpc/tools.ts
 async function detect(_params) {
@@ -1154,25 +1201,35 @@ async function detect(_params) {
   return { os: os9, tools: capabilities };
 }
 
-// src/rpc/index.ts
-var handlers = {
-  "tmux.list": list2,
-  "tmux.kill": kill,
-  "tmux.capture": capture,
-  "tools.detect": detect,
-  "hw.probe": probe,
-  "fs.list": list,
-  "fs.mkdir": mkdir,
-  "ai.credential": credential,
-  "file.paste": pasteFile,
-  "hooks.install": install,
-  "hooks.uninstall": uninstall
-};
+// src/rpc/update.ts
+import { existsSync, realpathSync as realpathSync2 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import path9 from "path";
+
+// src/paths.ts
+import { realpathSync } from "fs";
+import path5 from "path";
+import { pathToFileURL } from "url";
+function resolveScriptPath(argv1) {
+  if (!argv1) return "";
+  try {
+    return realpathSync(argv1);
+  } catch {
+    return path5.resolve(argv1);
+  }
+}
+function isMainModule(importMetaUrl, argv1) {
+  if (!argv1) return false;
+  return importMetaUrl === pathToFileURL(resolveScriptPath(argv1)).href;
+}
+
+// src/service/index.ts
+import path8 from "path";
 
 // src/service/launchd.ts
 import fs4 from "fs";
 import os4 from "os";
-import path5 from "path";
+import path6 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;");
@@ -1211,7 +1268,7 @@ function renderPlist({ label, node, script, logPath }) {
 `;
 }
 function plistPath() {
-  return path5.join(os4.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+  return path6.join(os4.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
 }
 function gui() {
   return `gui/${process.getuid ? process.getuid() : 0}`;
@@ -1220,7 +1277,7 @@ 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(path5.dirname(file), { recursive: true });
+  fs4.mkdirSync(path6.dirname(file), { recursive: true });
   fs4.writeFileSync(file, plist, "utf8");
   await runFn("launchctl", ["bootout", gui(), file]);
   const result = await runFn("launchctl", ["bootstrap", gui(), file]);
@@ -1253,8 +1310,175 @@ async function status(deps = {}) {
   return result.code === 0;
 }
 
+// src/service/systemd.ts
+import fs5 from "fs";
+import os5 from "os";
+import path7 from "path";
+var UNIT_NAME = "termhub-agent";
+function renderUnit({ node, script, logPath }) {
+  const lines = [
+    "[Unit]",
+    "Description=termhub agent",
+    "After=network-online.target",
+    "",
+    "[Service]",
+    `ExecStart=${node} ${script} run`,
+    "Restart=on-failure",
+    "RestartSec=2",
+    "RestartPreventExitStatus=78",
+    `Environment=PATH=${agentEnv().PATH ?? ""}`
+  ];
+  if (logPath) {
+    lines.push(`StandardOutput=append:${logPath}`, `StandardError=append:${logPath}`);
+  }
+  lines.push("", "[Install]", "WantedBy=default.target", "");
+  return lines.join("\n");
+}
+function unitPath() {
+  return path7.join(os5.homedir(), ".config", "systemd", "user", `${UNIT_NAME}.service`);
+}
+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 });
+  fs5.mkdirSync(path7.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()}`);
+  const enable = await runFn("systemctl", ["--user", "enable", "--now", UNIT_NAME]);
+  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 uninstall3(deps = {}) {
+  const runFn = deps.run ?? run;
+  await runFn("systemctl", ["--user", "disable", "--now", UNIT_NAME]);
+  try {
+    fs5.unlinkSync(unitPath());
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  await runFn("systemctl", ["--user", "daemon-reload"]);
+}
+async function status2(deps = {}) {
+  const runFn = deps.run ?? run;
+  const result = await runFn("systemctl", ["--user", "is-active", UNIT_NAME]);
+  return result.code === 0;
+}
+
+// src/service/index.ts
+function serviceFileOptions() {
+  return {
+    node: process.execPath,
+    script: resolveScriptPath(process.argv[1]),
+    logPath: path8.join(agentHome(), "agent.log")
+  };
+}
+function assertSupported(platform) {
+  if (platform !== "darwin" && platform !== "linux") throw new Error("Sistema n\xE3o suportado");
+}
+async function install4() {
+  const platform = process.platform;
+  assertSupported(platform);
+  const opts = serviceFileOptions();
+  if (platform === "darwin") await install2(opts);
+  else await install3(opts);
+}
+async function uninstall4() {
+  const platform = process.platform;
+  assertSupported(platform);
+  if (platform === "darwin") await uninstall2();
+  else await uninstall3();
+}
+async function status3() {
+  const platform = process.platform;
+  assertSupported(platform);
+  if (platform === "darwin") return status();
+  return status2();
+}
+
 // src/version.ts
-var AGENT_VERSION = "0.1.7";
+var AGENT_VERSION = "0.2.1";
+
+// 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");
+  if (existsSync(symlink)) return realpathSync2(symlink);
+  const fallback = path9.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"));
+    return typeof pkg.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+var defaultDeps = {
+  run,
+  execPath: process.execPath,
+  npmCli: npmCliBesideNode,
+  installedVersion: installedAgentVersion,
+  serviceInstalled: () => status3(),
+  exit: (code) => process.exit(code),
+  log: (msg, meta) => console.error(meta ? `[termhub-agent] ${msg} ${JSON.stringify(meta)}` : `[termhub-agent] ${msg}`)
+};
+var inFlight = null;
+async function updateAgent(params, deps = defaultDeps) {
+  if (inFlight) throw new RpcFailure("failed", "update already running");
+  inFlight = doUpdate(params.version, deps);
+  try {
+    return await inFlight;
+  } finally {
+    inFlight = null;
+  }
+}
+async function doUpdate(version, deps) {
+  deps.log("update starting", { from: AGENT_VERSION, to: version });
+  const npmCli = deps.npmCli();
+  if (!npmCli) throw new RpcFailure("notfound", "npm not found beside node");
+  const r = await deps.run(deps.execPath, [npmCli, "install", "-g", "--no-fund", "--no-audit", `${PACKAGE}@${version}`], { timeoutMs: NPM_TIMEOUT_MS });
+  if (r.error === "enoent") throw new RpcFailure("notfound", "npm not found on this machine");
+  if (r.timedOut) throw new RpcFailure("timeout", "npm install timed out");
+  if (r.code !== 0) {
+    deps.log("update failed", { to: version, code: r.code });
+    throw new RpcFailure("failed", `npm exited with code ${r.code ?? "unknown"}`);
+  }
+  const installed = await deps.installedVersion();
+  if (installed !== version) throw new RpcFailure("failed", `installed version mismatch (${installed ?? "unknown"})`);
+  const restart = await deps.serviceInstalled() ? "service" : "manual";
+  deps.log("update installed", { from: AGENT_VERSION, to: version, restart });
+  if (restart === "service") {
+    setTimeout(() => deps.exit(1), EXIT_DELAY_MS);
+  }
+  return { installed_version: installed, restart };
+}
+var update = (params) => updateAgent(params);
+
+// src/rpc/index.ts
+var handlers = {
+  "tmux.list": list2,
+  "tmux.kill": kill,
+  "tmux.capture": capture,
+  "tmux.ensure": ensure,
+  "tmux.sendText": sendText,
+  "tmux.sendKey": sendKey,
+  "tools.detect": detect,
+  "hw.probe": probe,
+  "fs.list": list,
+  "fs.mkdir": mkdir,
+  "ai.credential": credential,
+  "file.paste": pasteFile,
+  "hooks.install": install,
+  "hooks.uninstall": uninstall,
+  "agent.update": update
+};
 
 // src/run.ts
 function detectOs(platform = process.platform) {
@@ -1274,7 +1498,7 @@ async function buildHello(osName) {
     agent_version: AGENT_VERSION,
     os: osName,
     arch: process.arch,
-    hostname: os5.hostname(),
+    hostname: os6.hostname(),
     tmux: tools.includes("tmux"),
     tools
   };
@@ -1294,7 +1518,7 @@ async function checkServerConnection(config, timeoutMs = 5e3) {
       {
         url: config.url,
         token: config.token,
-        hello: { agent_version: AGENT_VERSION, os: osName, arch: process.arch, hostname: os5.hostname(), tmux: false, tools: [], probe: true },
+        hello: { agent_version: AGENT_VERSION, os: osName, arch: process.arch, hostname: os6.hostname(), tmux: false, tools: [], probe: true },
         onServerMessage: () => {
         },
         onStream: () => {
@@ -1444,17 +1668,17 @@ function disconnectCommand() {
 }
 
 // src/doctor.ts
-import fs5 from "fs";
-import os6 from "os";
-import path6 from "path";
+import fs6 from "fs";
+import os7 from "os";
+import path10 from "path";
 var SERVER_CHECK_TIMEOUT_MS = 5e3;
 function defaultDoctorPaths() {
-  const home = os6.homedir();
-  const paths = [home, path6.join(home, "Documents"), path6.join(home, "Desktop")];
+  const home = os7.homedir();
+  const paths = [home, path10.join(home, "Documents"), path10.join(home, "Desktop")];
   if (process.platform === "darwin") {
     try {
-      for (const entry of fs5.readdirSync("/Volumes", { withFileTypes: true })) {
-        if (entry.isDirectory()) paths.push(path6.join("/Volumes", entry.name));
+      for (const entry of fs6.readdirSync("/Volumes", { withFileTypes: true })) {
+        if (entry.isDirectory()) paths.push(path10.join("/Volumes", entry.name));
       }
     } catch {
     }
@@ -1467,7 +1691,7 @@ function pathErrorCode(err) {
   if (e?.code) return e.code;
   return err instanceof Error ? err.message : String(err);
 }
-function checkPathAccess(p, fsImpl = fs5) {
+function checkPathAccess(p, fsImpl = fs6) {
   try {
     fsImpl.readdirSync(p);
     return { path: p, ok: true };
@@ -1479,7 +1703,7 @@ function fullDiskAccessNote(execPath = process.execPath) {
   return `Conceda Acesso Total ao Disco a ${execPath} em Ajustes \u2192 Privacidade e Seguran\xE7a \u2192 Acesso Total ao Disco`;
 }
 async function runDoctor(paths, deps = {}) {
-  const fsImpl = deps.fs ?? fs5;
+  const fsImpl = deps.fs ?? fs6;
   const connect = deps.connect ?? checkServerConnection;
   const config = readConfig();
   const configReport = { ok: config !== null, path: configPath() };
@@ -1547,114 +1771,6 @@ async function runCommand(log2) {
 
 // src/commands/service.ts
 import os8 from "os";
-
-// src/service/index.ts
-import path9 from "path";
-
-// src/paths.ts
-import { realpathSync } from "fs";
-import path7 from "path";
-import { pathToFileURL } from "url";
-function resolveScriptPath(argv1) {
-  if (!argv1) return "";
-  try {
-    return realpathSync(argv1);
-  } catch {
-    return path7.resolve(argv1);
-  }
-}
-function isMainModule(importMetaUrl, argv1) {
-  if (!argv1) return false;
-  return importMetaUrl === pathToFileURL(resolveScriptPath(argv1)).href;
-}
-
-// src/service/systemd.ts
-import fs6 from "fs";
-import os7 from "os";
-import path8 from "path";
-var UNIT_NAME = "termhub-agent";
-function renderUnit({ node, script, logPath }) {
-  const lines = [
-    "[Unit]",
-    "Description=termhub agent",
-    "After=network-online.target",
-    "",
-    "[Service]",
-    `ExecStart=${node} ${script} run`,
-    "Restart=on-failure",
-    "RestartSec=2",
-    "RestartPreventExitStatus=78",
-    `Environment=PATH=${agentEnv().PATH ?? ""}`
-  ];
-  if (logPath) {
-    lines.push(`StandardOutput=append:${logPath}`, `StandardError=append:${logPath}`);
-  }
-  lines.push("", "[Install]", "WantedBy=default.target", "");
-  return lines.join("\n");
-}
-function unitPath() {
-  return path8.join(os7.homedir(), ".config", "systemd", "user", `${UNIT_NAME}.service`);
-}
-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(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()}`);
-  const enable = await runFn("systemctl", ["--user", "enable", "--now", UNIT_NAME]);
-  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 uninstall3(deps = {}) {
-  const runFn = deps.run ?? run;
-  await runFn("systemctl", ["--user", "disable", "--now", UNIT_NAME]);
-  try {
-    fs6.unlinkSync(unitPath());
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  }
-  await runFn("systemctl", ["--user", "daemon-reload"]);
-}
-async function status2(deps = {}) {
-  const runFn = deps.run ?? run;
-  const result = await runFn("systemctl", ["--user", "is-active", UNIT_NAME]);
-  return result.code === 0;
-}
-
-// src/service/index.ts
-function serviceFileOptions() {
-  return {
-    node: process.execPath,
-    script: resolveScriptPath(process.argv[1]),
-    logPath: path9.join(agentHome(), "agent.log")
-  };
-}
-function assertSupported(platform) {
-  if (platform !== "darwin" && platform !== "linux") throw new Error("Sistema n\xE3o suportado");
-}
-async function install4() {
-  const platform = process.platform;
-  assertSupported(platform);
-  const opts = serviceFileOptions();
-  if (platform === "darwin") await install2(opts);
-  else await install3(opts);
-}
-async function uninstall4() {
-  const platform = process.platform;
-  assertSupported(platform);
-  if (platform === "darwin") await uninstall2();
-  else await uninstall3();
-}
-async function status3() {
-  const platform = process.platform;
-  assertSupported(platform);
-  if (platform === "darwin") return status();
-  return status2();
-}
-
-// src/commands/service.ts
 async function serviceCommand(sub) {
   switch (sub) {
     case "install": {

package/package.json

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