hilos-agent 0.9.3 → 0.9.4

package/README.md

@@ -25,16 +25,20 @@ machine until then).
 
 ## Quick start
 
-In hilos: open your agent's profile → **Connect** → copy the
-`hilos-agent --join …` command. Then on your machine, **run it from inside your
-repo's folder** — the daemon matches the repo by its git remote, so no config is
-needed:
+In hilos: open your agent's profile → **Connect** → **Run in channel**. Copy the
+terminal command and run it from inside your repo's folder. It waits at a hidden
+prompt; copy the private join code from Hilos and paste it there. The daemon
+matches the repo by its git remote, so no config is needed, and the reusable
+credential never enters shell history or the process list:
 
 ```sh
 cd ~/code/your-repo
-npx hilos-agent@latest --join <blob> # token + endpoint from the link; repo auto-detected from cwd
+npx hilos-agent@latest --join-stdin  # then paste the private join code when asked
 ```
 
+Previously copied `--join <blob>` commands remain compatible. New commands use
+stdin because the blob contains the agent token and should not live in argv.
+
 Running from elsewhere, or want to map several repos explicitly? Use a config:
 
 ```jsonc

package/bin/hilos-agent.mjs

@@ -5,6 +5,7 @@
 //
 // Usage:
 //   hilos-agent --join <blob>      connect with a copy-paste link from hilos
+//   hilos-agent --join-stdin       read a private link without exposing it in argv
 //   hilos-agent init               write a starter config (~/.hilos/agent.json)
 //   hilos-agent                    run with the resolved config (default)
 //   hilos-agent run                same as above, explicit
@@ -20,6 +21,7 @@ import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 
 import { resolveConfig, decodeJoin, writeStarterConfig, GLOBAL_CONFIG } from "../src/config.mjs";
+import { readPrivateJoin } from "../src/join-input.mjs";
 import { run } from "../src/run.mjs";
 import { hookMain, hooksMain } from "../src/hook.mjs";
 
@@ -34,6 +36,7 @@ function parseArgs(argv) {
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === "--join") flags.join = argv[++i];
+    else if (a === "--join-stdin") flags.joinStdin = true;
     else if (a === "--config") flags.config = argv[++i];
     else if (a === "--channel") flags.channelId = argv[++i];
     else if (a === "--url") flags.url = argv[++i];
@@ -62,6 +65,7 @@ function parseArgs(argv) {
 const HELP = `hilos-agent — your coding agent as a teammate in hilos
 
   hilos-agent --join <blob>      connect using a link copied from hilos
+  hilos-agent --join-stdin       paste the private link at a no-echo prompt
   hilos-agent init               write a starter config to ~/.hilos/agent.json
   hilos-agent                    run the daemon (watch @mentions, propose diffs)
   hilos-agent hooks install      stream this repo's Codex, Claude, and Cursor
@@ -118,9 +122,18 @@ async function main() {
     return;
   }
 
-  const joinPayload = flags.join ? decodeJoin(flags.join) : undefined;
-  if (flags.join && !joinPayload) {
-    console.error("That --join link is invalid. Re-copy it from hilos.");
+  if (flags.join && flags.joinStdin) {
+    console.error("Use either --join or --join-stdin, not both.");
+    process.exit(1);
+  }
+  const joinBlob = flags.joinStdin ? await readPrivateJoin() : flags.join;
+  if (flags.joinStdin && !joinBlob) {
+    console.error("No private join code was provided. Re-copy it from hilos.");
+    process.exit(1);
+  }
+  const joinPayload = joinBlob ? decodeJoin(joinBlob) : undefined;
+  if (joinBlob && !joinPayload) {
+    console.error("That private join code is invalid. Re-copy it from hilos.");
     process.exit(1);
   }
 
@@ -140,6 +153,7 @@ async function main() {
   // run (default) — when --join is passed without init, connect straight away.
   const cliFlags = { ...flags };
   delete cliFlags.join;
+  delete cliFlags.joinStdin;
   delete cliFlags.help;
   const cfg = resolveConfig({ flags: cliFlags, join: joinPayload });
   await run(cfg);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hilos-agent",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "description": "Run your own coding agent (Claude Code / Codex / Cursor) as an autonomous teammate in a hilos channel. Picks up @mentions in channels and threads, makes the change, and opens a PR for review — your code and credentials never leave your machine. (Approve-before-push is available via gate:true.)",
   "type": "module",
   "bin": {

package/src/join-input.mjs

@@ -0,0 +1,80 @@
+const MAX_JOIN_BYTES = 64 * 1024;
+
+/** @typedef {import("node:stream").Readable & {
+ *   isTTY?: boolean,
+ *   isRaw?: boolean,
+ *   setRawMode?: (enabled: boolean) => unknown,
+ * }} PrivateJoinInput */
+
+/**
+ * Read a private join blob without putting it in process argv or shell history.
+ * Piped stdin is consumed normally. On a terminal, raw mode keeps pasted input
+ * off-screen while still supporting backspace and Ctrl-C.
+ * @param {PrivateJoinInput} input
+ * @param {NodeJS.WritableStream} output
+ */
+export async function readPrivateJoin(input = process.stdin, output = process.stderr) {
+  if (!input?.isTTY || typeof input.setRawMode !== "function") {
+    let value = "";
+    for await (const chunk of input) {
+      value += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+      if (Buffer.byteLength(value, "utf8") > MAX_JOIN_BYTES) {
+        throw new Error("The private join code is too large.");
+      }
+    }
+    return value.trim();
+  }
+
+  output.write("Paste the private join code from hilos, then press Enter: ");
+  const wasRaw = Boolean(input.isRaw);
+  const wasPaused = typeof input.isPaused === "function" ? input.isPaused() : false;
+  const setRawMode = input.setRawMode.bind(input);
+
+  return new Promise((resolve, reject) => {
+    let value = "";
+    let settled = false;
+
+    const cleanup = () => {
+      input.off("data", onData);
+      input.off("error", onError);
+      setRawMode(wasRaw);
+      if (wasPaused) input.pause();
+    };
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      output.write("\n");
+      if (error) reject(error);
+      else resolve(value.trim());
+    };
+    const onError = (error) => finish(error);
+    const onData = (chunk) => {
+      for (const char of String(chunk)) {
+        if (char === "\u0003") {
+          finish(new Error("Private join cancelled."));
+          return;
+        }
+        if (char === "\r" || char === "\n") {
+          finish();
+          return;
+        }
+        if (char === "\u007f" || char === "\b") {
+          value = value.slice(0, -1);
+          continue;
+        }
+        value += char;
+        if (Buffer.byteLength(value, "utf8") > MAX_JOIN_BYTES) {
+          finish(new Error("The private join code is too large."));
+          return;
+        }
+      }
+    };
+
+    input.setEncoding?.("utf8");
+    setRawMode(true);
+    input.on("data", onData);
+    input.on("error", onError);
+    input.resume();
+  });
+}