noninteractive 0.3.6 → 0.3.8

package/README.md

@@ -16,14 +16,17 @@ npx noninteractive
 # Start a session (runs `npx workos` in a background PTY)
 npx noninteractive workos
 
-# Read what's on screen
-npx noninteractive read workos
+# Send keystrokes and wait for new output
+npx noninteractive send workos "" --wait
 
-# Send keystrokes (Enter to confirm a prompt)
-npx noninteractive send workos ""
+# Send text input and wait for response
+npx noninteractive send workos "my-api-key" --wait
 
-# Send text input
-npx noninteractive send workos "my-api-key"
+# Wait for new output without sending (e.g. OAuth callback)
+npx noninteractive read workos --wait
+
+# Read current output (non-blocking)
+npx noninteractive read workos
 
 # Stop a session
 npx noninteractive stop workos
@@ -37,18 +40,12 @@ npx noninteractive list
 ```bash
 # Start the installer
 npx noninteractive workos
-
-# Wait for it to load, then read the prompt
-npx noninteractive read workos
 # ◆  Run the AuthKit installer?
 # │  ● Yes / ○ No
 # └
 
-# Press Enter to confirm "Yes"
-npx noninteractive send workos ""
-
-# Read the next prompt
-npx noninteractive read workos
+# Press Enter to confirm "Yes", wait for next prompt
+npx noninteractive send workos "" --wait
 # ◆  You are on main. Create a feature branch?
 # │  ● Create feat/add-workos-authkit
 # │  ○ Continue on current branch
@@ -56,12 +53,29 @@ npx noninteractive read workos
 # └
 
 # Press Enter to confirm
-npx noninteractive send workos ""
+npx noninteractive send workos "" --wait
 
 # Done? Stop the session
 npx noninteractive stop workos
 ```
 
+## The `--wait` flag
+
+Both `send` and `read` support `--wait` (`-w`), which blocks until new output appears instead of returning immediately. This eliminates polling loops and reduces tool calls by ~7-10x.
+
+```bash
+# Old way (polling): send + read + read + read...
+npx noninteractive send workos ""
+npx noninteractive read workos        # maybe not ready yet
+npx noninteractive read workos        # still waiting...
+npx noninteractive read workos        # finally got output
+
+# New way (blocking): send --wait
+npx noninteractive send workos "" --wait   # returns when output appears
+```
+
+Use `--timeout <ms>` to set the max wait time (default: 30000ms).
+
 ## Agent Skill
 
 Install the [Agent Skill](https://agentskills.io) so your AI agent knows how to use noninteractive:
@@ -74,8 +88,9 @@ npx skills add https://noninteractive.org
 
 1. `npx noninteractive <tool>` spawns a detached daemon that runs `npx <tool>` inside a real pseudo-terminal (PTY)
 2. The daemon listens on a unix socket at `~/.noninteractive/sessions/<name>.sock`
-3. `read`, `send`, and `stop` connect to that socket to interact with the running process
-4. The PTY ensures the child process sees a real terminal — `isTTY` is true, ANSI colors work, interactive menus render correctly
+3. `send --wait` sends keystrokes and blocks until new output appears — one call instead of polling
+4. `read --wait` blocks until output changes — perfect for OAuth flows and long operations
+5. The PTY ensures the child process sees a real terminal — `isTTY` is true, ANSI colors work, interactive menus render correctly
 
 ## Why
 

package/bin/noninteractive.js

@@ -0,0 +1,604 @@
+#!/usr/bin/env node
+// @bun
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/paths.ts
+var exports_paths = {};
+__export(exports_paths, {
+  socketPath: () => socketPath,
+  ensureSessionsDir: () => ensureSessionsDir,
+  SESSIONS_DIR: () => SESSIONS_DIR
+});
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+function ensureSessionsDir() {
+  mkdirSync(SESSIONS_DIR, { recursive: true });
+}
+function socketPath(name) {
+  return resolve(SESSIONS_DIR, `${name}.sock`);
+}
+var SESSIONS_DIR;
+var init_paths = __esm(() => {
+  SESSIONS_DIR = resolve(homedir(), ".noninteractive", "sessions");
+});
+
+// src/paths.ts
+import { mkdirSync as mkdirSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { resolve as resolve2 } from "node:path";
+function ensureSessionsDir2() {
+  mkdirSync2(SESSIONS_DIR2, { recursive: true });
+}
+function socketPath2(name) {
+  return resolve2(SESSIONS_DIR2, `${name}.sock`);
+}
+var SESSIONS_DIR2;
+var init_paths2 = __esm(() => {
+  SESSIONS_DIR2 = resolve2(homedir2(), ".noninteractive", "sessions");
+});
+
+// src/daemon.ts
+var exports_daemon = {};
+__export(exports_daemon, {
+  runDaemon: () => runDaemon
+});
+import { spawn } from "node:child_process";
+import { unlinkSync } from "node:fs";
+import { createServer } from "node:net";
+import { dirname, resolve as resolve3 } from "node:path";
+function getPtyBridge() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const binaryName = `ptybridge-${platform}-${arch}`;
+  const scriptDir = dirname(process.argv[1] || process.execPath);
+  const candidates = [
+    resolve3(scriptDir, "..", "native", binaryName),
+    resolve3(scriptDir, "native", binaryName),
+    resolve3(dirname(import.meta.dirname), "native", binaryName),
+    resolve3(import.meta.dirname, "..", "native", binaryName)
+  ];
+  for (const p of candidates) {
+    try {
+      const { statSync } = __require("node:fs");
+      if (statSync(p).isFile())
+        return p;
+    } catch {}
+  }
+  return candidates[0];
+}
+function runDaemon(sessionName, executable, args) {
+  ensureSessionsDir2();
+  const sock = socketPath2(sessionName);
+  try {
+    unlinkSync(sock);
+  } catch {}
+  let outputBuffer = "";
+  let processExited = false;
+  let exitCode = null;
+  const waiters = [];
+  function notifyWaiters() {
+    while (waiters.length > 0) {
+      const w = waiters.shift();
+      clearTimeout(w.timer);
+      w.resolve(outputBuffer);
+    }
+  }
+  const ptyBridge = getPtyBridge();
+  const proc = spawn(ptyBridge, [executable, ...args], {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: { ...process.env, TERM: "xterm-256color" }
+  });
+  const { stdout, stderr, stdin } = proc;
+  stdout?.on("data", (chunk) => {
+    outputBuffer += chunk.toString();
+    notifyWaiters();
+  });
+  stderr?.on("data", (chunk) => {
+    outputBuffer += chunk.toString();
+    notifyWaiters();
+  });
+  proc.on("exit", (code) => {
+    processExited = true;
+    exitCode = code;
+    outputBuffer += `
+[exited ${code}]`;
+    notifyWaiters();
+    setTimeout(() => {
+      server.close();
+      try {
+        unlinkSync(sock);
+      } catch {}
+      process.exit(0);
+    }, 60000);
+  });
+  proc.on("error", (err) => {
+    outputBuffer += `
+[error: ${err.message}]`;
+    processExited = true;
+  });
+  const server = createServer((socket) => {
+    let buf = "";
+    socket.on("data", (chunk) => {
+      buf += chunk.toString();
+      try {
+        const msg = JSON.parse(buf);
+        buf = "";
+        handle(msg, socket);
+      } catch {}
+    });
+  });
+  function respondWithOutput(socket) {
+    socket.end(JSON.stringify({
+      ok: true,
+      output: outputBuffer,
+      exited: processExited,
+      exitCode
+    }));
+  }
+  function waitForNewOutput(socket, sinceLength, timeout) {
+    if (outputBuffer.length > sinceLength || processExited) {
+      respondWithOutput(socket);
+      return;
+    }
+    const waiter = {
+      resolve: () => respondWithOutput(socket),
+      timer: setTimeout(() => {
+        const idx = waiters.indexOf(waiter);
+        if (idx !== -1)
+          waiters.splice(idx, 1);
+        respondWithOutput(socket);
+      }, timeout)
+    };
+    waiters.push(waiter);
+  }
+  function handle(msg, socket) {
+    switch (msg.action) {
+      case "read":
+        if (msg.wait) {
+          const timeout = msg.timeout ?? 30000;
+          waitForNewOutput(socket, outputBuffer.length, timeout);
+        } else {
+          respondWithOutput(socket);
+        }
+        break;
+      case "send":
+        if (processExited) {
+          socket.end(JSON.stringify({ ok: false, error: "process exited" }));
+          break;
+        }
+        stdin?.write(`${msg.data}\r`);
+        socket.end(JSON.stringify({ ok: true }));
+        break;
+      case "sendread": {
+        if (processExited) {
+          socket.end(JSON.stringify({ ok: false, error: "process exited" }));
+          break;
+        }
+        const beforeLength = outputBuffer.length;
+        const timeout = msg.timeout ?? 30000;
+        stdin?.write(`${msg.data}\r`);
+        waitForNewOutput(socket, beforeLength, timeout);
+        break;
+      }
+      case "stop":
+        proc.kill("SIGTERM");
+        socket.end(JSON.stringify({ ok: true }));
+        setTimeout(() => {
+          server.close();
+          try {
+            unlinkSync(sock);
+          } catch {}
+          process.exit(0);
+        }, 500);
+        break;
+      case "status":
+        socket.end(JSON.stringify({
+          ok: true,
+          running: !processExited,
+          pid: proc.pid,
+          exitCode
+        }));
+        break;
+      default:
+        socket.end(JSON.stringify({ ok: false, error: "unknown action" }));
+    }
+  }
+  server.listen(sock);
+}
+var init_daemon = __esm(() => {
+  init_paths2();
+});
+
+// package.json
+var require_package = __commonJS((exports, module) => {
+  module.exports = {
+    name: "noninteractive",
+    version: "0.3.8",
+    type: "module",
+    bin: {
+      noninteractive: "./bin/noninteractive.js"
+    },
+    files: [
+      "bin/noninteractive.js",
+      "native/**/*"
+    ],
+    scripts: {
+      dev: "bun run src/index.ts",
+      build: `bun build src/index.ts --outfile bin/noninteractive.js --target node && node -e "const f='bin/noninteractive.js';const c=require('fs').readFileSync(f,'utf8');require('fs').writeFileSync(f,c.replace('#!/usr/bin/env bun','#!/usr/bin/env node'))" && chmod +x bin/noninteractive.js`,
+      "build:standalone": "bun build src/index.ts --compile --outfile bin/noninteractive",
+      "build:pty": "cd ptybridge && GOOS=darwin GOARCH=arm64 go build -o ../native/ptybridge-darwin-arm64 . && GOOS=darwin GOARCH=amd64 go build -o ../native/ptybridge-darwin-amd64 . && GOOS=linux GOARCH=amd64 go build -o ../native/ptybridge-linux-amd64 . && GOOS=linux GOARCH=arm64 go build -o ../native/ptybridge-linux-arm64 .",
+      check: "biome check --write src/",
+      test: "bun test",
+      prepublishOnly: "bun run build"
+    },
+    devDependencies: {
+      "@biomejs/biome": "^2.4.5",
+      "@types/bun": "latest"
+    },
+    engines: {
+      node: ">=18"
+    }
+  };
+});
+
+// src/index.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync } from "fs";
+
+// src/client.ts
+import { createConnection } from "node:net";
+function sendMessage(sockPath, msg, timeoutMs) {
+  const effectiveTimeout = timeoutMs ?? 5000;
+  return new Promise((resolve, reject) => {
+    const socket = createConnection(sockPath);
+    let data = "";
+    let resolved = false;
+    let timer;
+    function tryResolve() {
+      if (resolved)
+        return;
+      try {
+        const parsed = JSON.parse(data);
+        resolved = true;
+        clearTimeout(timer);
+        socket.destroy();
+        resolve(parsed);
+      } catch {}
+    }
+    socket.on("connect", () => {
+      socket.write(JSON.stringify(msg));
+    });
+    socket.on("data", (chunk) => {
+      data += chunk.toString();
+      tryResolve();
+    });
+    socket.on("end", () => {
+      tryResolve();
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        reject(new Error("invalid response from daemon"));
+      }
+    });
+    socket.on("error", (err) => {
+      if (resolved)
+        return;
+      resolved = true;
+      clearTimeout(timer);
+      if (err.code === "ECONNREFUSED" || err.code === "ENOENT") {
+        reject(new Error("session not found"));
+      } else {
+        reject(err);
+      }
+    });
+    timer = setTimeout(() => {
+      if (resolved)
+        return;
+      resolved = true;
+      socket.destroy();
+      reject(new Error("connection timeout"));
+    }, effectiveTimeout);
+  });
+}
+
+// src/index.ts
+init_paths();
+var HELP = `noninteractive \u2014 run interactive CLI commands non-interactively.
+
+usage: npx noninteractive <tool> [args...]
+
+commands:
+  <tool> [args...]                       start a session (runs npx <tool> in a PTY)
+  send  <session> <text> [--wait]        send keystrokes (--wait waits for new output)
+  read  <session> [--wait] [--timeout N] read terminal output (--wait blocks until new output)
+  stop  <session>                        stop a session
+  list                                   show active sessions
+  start <cmd> [args...]                  explicit start (for non-npx commands)
+
+flags:
+  --wait, -w         block until new output appears (for send and read)
+  --timeout <ms>     max wait time in ms (default: 30000, used with --wait)
+
+the session name is auto-derived from the tool (e.g. "workos" \u2192 session "workos").
+
+example workflow (recommended \u2014 uses --wait to minimize round-trips):
+  npx noninteractive workos                    # starts "npx workos", session = "workos"
+  npx noninteractive send workos "" --wait     # press Enter, wait for response
+  npx noninteractive send workos "y" --wait    # type "y", wait for response
+  npx noninteractive read workos --wait        # wait for new output (e.g. OAuth callback)
+  npx noninteractive stop workos               # done, stop the session
+
+more examples:
+  npx noninteractive vercel                 # session "vercel"
+  npx noninteractive supabase init          # session "supabase"
+  npx noninteractive start vercel login     # explicit start for non-npx commands`;
+function getSelfCommand() {
+  if (process.argv[1] && /\.(ts|js)$/.test(process.argv[1])) {
+    return [process.argv[0], process.argv[1]];
+  }
+  return [process.argv[0]];
+}
+function deriveSessionName(cmd, args) {
+  const parts = [cmd, ...args];
+  let i = 0;
+  if (parts[i] === "npx" || parts[i] === "bunx")
+    i++;
+  while (i < parts.length && parts[i].startsWith("-"))
+    i++;
+  const name = parts[i] || cmd;
+  return name.replace(/^@[^/]+\//, "").replace(/[^a-zA-Z0-9_-]/g, "");
+}
+async function start(cmdArgs) {
+  const executable = cmdArgs[0];
+  const args = cmdArgs.slice(1);
+  const name = deriveSessionName(executable, args);
+  const sock = socketPath(name);
+  try {
+    const res = await sendMessage(sock, { action: "read" });
+    if (res.ok) {
+      process.stdout.write(res.output ?? "");
+      if (res.exited) {
+        console.log(`
+[session '${name}' already exists but exited ${res.exitCode} \u2014 stopping it]`);
+        try {
+          await sendMessage(sock, { action: "stop" });
+        } catch {}
+      } else {
+        console.log(`
+[session '${name}' already running \u2014 read the output above, then use:]`);
+        console.log(`  npx noninteractive send ${name} "<text>" --wait  # send and wait for response`);
+        console.log(`  npx noninteractive read ${name} --wait        # wait for new output`);
+        console.log(`  npx noninteractive stop ${name}               # stop the session`);
+        return;
+      }
+    }
+  } catch {}
+  ensureSessionsDir();
+  try {
+    const { unlinkSync: unlinkSync2 } = await import("fs");
+    unlinkSync2(sock);
+  } catch {}
+  const self = getSelfCommand();
+  const child = spawn2(self[0], [...self.slice(1), "__daemon__", name, executable, ...args], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  for (let i = 0;i < 50; i++) {
+    if (existsSync(sock))
+      break;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  if (!existsSync(sock)) {
+    console.error(`error: failed to start session '${name}'.`);
+    console.error(`the command was: ${executable} ${args.join(" ")}`);
+    console.error(`
+make sure the command exists. examples:`);
+    console.error(`  npx noninteractive start npx vercel        # run an npx package`);
+    console.error(`  npx noninteractive start vercel login       # run a command directly`);
+    process.exit(1);
+  }
+  const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07]*\x07/g, "");
+  for (let i = 0;i < 50; i++) {
+    await new Promise((r) => setTimeout(r, 200));
+    try {
+      const res = await sendMessage(sock, { action: "read" });
+      const clean = stripAnsi(res.output ?? "").trim();
+      if (clean.length > 10) {
+        process.stdout.write(res.output);
+        if (res.exited) {
+          console.log(`
+[session '${name}' exited ${res.exitCode} \u2014 the command failed]`);
+          console.log(`hint: the first argument to "start" is the command to run, NOT a session name.`);
+          console.log(`  npx noninteractive start npx vercel        # run an npx package`);
+          console.log(`  npx noninteractive start vercel login       # run a command directly`);
+        } else {
+          console.log(`
+[session '${name}' started \u2014 read the output above, then use:]`);
+          console.log(`  npx noninteractive send ${name} "<text>" --wait  # send and wait for response`);
+          console.log(`  npx noninteractive read ${name} --wait        # wait for new output`);
+          console.log(`  npx noninteractive stop ${name}               # stop the session`);
+        }
+        return;
+      }
+      if (res.exited) {
+        process.stdout.write(res.output ?? "");
+        console.log(`
+[session '${name}' exited ${res.exitCode} \u2014 the command failed]`);
+        console.log(`hint: the first argument to "start" is the command to run, NOT a session name.`);
+        console.log(`  npx noninteractive start npx vercel        # run an npx package`);
+        console.log(`  npx noninteractive start vercel login       # run a command directly`);
+        return;
+      }
+    } catch {}
+  }
+  console.log(`[session '${name}' started but no output yet \u2014 use:]`);
+  console.log(`  npx noninteractive send ${name} "<text>" --wait  # send and wait for response`);
+  console.log(`  npx noninteractive read ${name} --wait        # wait for new output`);
+  console.log(`  npx noninteractive stop ${name}               # stop the session`);
+}
+async function read(name, wait, timeout) {
+  const sock = socketPath(name);
+  const msg = { action: "read" };
+  if (wait) {
+    msg.wait = true;
+    msg.timeout = timeout;
+  }
+  const clientTimeout = wait ? timeout + 5000 : 5000;
+  const res = await sendMessage(sock, msg, clientTimeout);
+  if (res.output !== undefined)
+    process.stdout.write(res.output);
+  if (res.exited)
+    console.log(`
+[exited ${res.exitCode}]`);
+}
+async function send(name, text, wait, timeout) {
+  const sock = socketPath(name);
+  if (wait) {
+    const res = await sendMessage(sock, { action: "sendread", data: text, timeout }, timeout + 5000);
+    if (res.output !== undefined)
+      process.stdout.write(res.output);
+    if (res.exited)
+      console.log(`
+[exited ${res.exitCode}]`);
+  } else {
+    await sendMessage(sock, { action: "send", data: text });
+    console.log(`[sent to '${name}' \u2014 run "npx noninteractive read ${name}" to see the result]`);
+  }
+}
+async function stop(name) {
+  const sock = socketPath(name);
+  await sendMessage(sock, { action: "stop" });
+  console.log(`session '${name}' stopped`);
+}
+async function list() {
+  const { readdirSync } = await import("fs");
+  ensureSessionsDir();
+  const files = readdirSync((await Promise.resolve().then(() => (init_paths(), exports_paths))).SESSIONS_DIR);
+  const sessions = files.filter((f) => f.endsWith(".sock")).map((f) => f.replace(".sock", ""));
+  if (sessions.length === 0) {
+    console.log("no active sessions");
+    return;
+  }
+  for (const name of sessions) {
+    const sock = socketPath(name);
+    try {
+      const res = await sendMessage(sock, { action: "status" });
+      const status = res.running ? "running" : `exited (${res.exitCode})`;
+      console.log(`${name} [${status}] pid=${res.pid}`);
+    } catch {
+      console.log(`${name} [dead]`);
+    }
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args[0] === "__daemon__") {
+    const { runDaemon: runDaemon2 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
+    return runDaemon2(args[1], args[2], args.slice(3));
+  }
+  const cmd = args[0];
+  switch (cmd) {
+    case "start": {
+      if (args.length < 2) {
+        console.error(`usage: noninteractive start <cmd> [args...]
+
+example: npx noninteractive start npx vercel`);
+        process.exit(1);
+      }
+      return start(args.slice(1));
+    }
+    case "read": {
+      const readArgs = args.slice(1);
+      const name = readArgs.find((a) => !a.startsWith("-"));
+      if (!name) {
+        console.error(`usage: noninteractive read <session> [-w|--wait] [--timeout <ms>]
+
+example: npx noninteractive read vercel --wait`);
+        process.exit(1);
+      }
+      const wait = readArgs.includes("-w") || readArgs.includes("--wait");
+      const timeoutIdx = readArgs.indexOf("--timeout");
+      const timeout = timeoutIdx !== -1 ? Number(readArgs[timeoutIdx + 1]) : 30000;
+      return read(name, wait, timeout);
+    }
+    case "sendread":
+    case "send": {
+      const sendArgs = args.slice(1);
+      const positional = sendArgs.filter((a) => !a.startsWith("-"));
+      const name = positional[0];
+      const text = positional[1];
+      if (!name || text === undefined) {
+        console.error(`usage: noninteractive send <session> <text> [--wait] [--timeout <ms>]
+
+example: npx noninteractive send workos "" --wait`);
+        process.exit(1);
+      }
+      const wait = cmd === "sendread" || sendArgs.includes("-w") || sendArgs.includes("--wait");
+      const timeoutIdx = sendArgs.indexOf("--timeout");
+      const timeout = timeoutIdx !== -1 ? Number(sendArgs[timeoutIdx + 1]) : 30000;
+      return send(name, text, wait, timeout);
+    }
+    case "stop": {
+      const name = args[1];
+      if (!name) {
+        console.error(`usage: noninteractive stop <session>
+
+example: npx noninteractive stop vercel`);
+        process.exit(1);
+      }
+      return stop(name);
+    }
+    case "list":
+    case "ls":
+      return list();
+    case "version":
+    case "--version":
+    case "-v": {
+      const { version } = require_package();
+      console.log(`noninteractive v${version}`);
+      return;
+    }
+    case undefined:
+    case "help":
+    case "--help":
+    case "-h":
+      console.log(HELP);
+      break;
+    default:
+      return start(["npx", ...args]);
+  }
+}
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});

package/package.json

@@ -1,26 +1,28 @@
 {
   "name": "noninteractive",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "type": "module",
   "bin": {
-    "noninteractive": "./src/index.ts"
+    "noninteractive": "./bin/noninteractive.js"
   },
   "files": [
-    "src/**/*",
+    "bin/noninteractive.js",
     "native/**/*"
   ],
   "scripts": {
     "dev": "bun run src/index.ts",
-    "build": "bun build src/index.ts --compile --outfile bin/noninteractive",
+    "build": "bun build src/index.ts --outfile bin/noninteractive.js --target node && node -e \"const f='bin/noninteractive.js';const c=require('fs').readFileSync(f,'utf8');require('fs').writeFileSync(f,c.replace('#!/usr/bin/env bun','#!/usr/bin/env node'))\" && chmod +x bin/noninteractive.js",
+    "build:standalone": "bun build src/index.ts --compile --outfile bin/noninteractive",
     "build:pty": "cd ptybridge && GOOS=darwin GOARCH=arm64 go build -o ../native/ptybridge-darwin-arm64 . && GOOS=darwin GOARCH=amd64 go build -o ../native/ptybridge-darwin-amd64 . && GOOS=linux GOARCH=amd64 go build -o ../native/ptybridge-linux-amd64 . && GOOS=linux GOARCH=arm64 go build -o ../native/ptybridge-linux-arm64 .",
     "check": "biome check --write src/",
-    "test": "bun test"
+    "test": "bun test",
+    "prepublishOnly": "bun run build"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.5",
     "@types/bun": "latest"
   },
-  "peerDependencies": {
-    "typescript": "^5"
+  "engines": {
+    "node": ">=18"
   }
 }

package/src/client.ts

@@ -1,50 +0,0 @@
-import { createConnection } from "node:net";
-
-export interface DaemonResponse {
-	ok: boolean;
-	output?: string;
-	exited?: boolean;
-	exitCode?: number | null;
-	running?: boolean;
-	pid?: number;
-	error?: string;
-}
-
-export function sendMessage(
-	sockPath: string,
-	msg: Record<string, unknown>,
-): Promise<DaemonResponse> {
-	return new Promise((resolve, reject) => {
-		const socket = createConnection(sockPath);
-		let data = "";
-
-		socket.on("connect", () => {
-			socket.write(JSON.stringify(msg));
-		});
-
-		socket.on("data", (chunk) => {
-			data += chunk.toString();
-		});
-
-		socket.on("end", () => {
-			try {
-				resolve(JSON.parse(data));
-			} catch {
-				reject(new Error("invalid response from daemon"));
-			}
-		});
-
-		socket.on("error", (err: NodeJS.ErrnoException) => {
-			if (err.code === "ECONNREFUSED" || err.code === "ENOENT") {
-				reject(new Error("session not found"));
-			} else {
-				reject(err);
-			}
-		});
-
-		setTimeout(() => {
-			socket.destroy();
-			reject(new Error("connection timeout"));
-		}, 5000);
-	});
-}

package/src/daemon.ts

@@ -1,146 +0,0 @@
-import { spawn } from "node:child_process";
-import { unlinkSync } from "node:fs";
-import { createServer, type Socket } from "node:net";
-import { dirname, resolve } from "node:path";
-import { ensureSessionsDir, socketPath } from "./paths";
-
-interface DaemonMessage {
-	action: "read" | "send" | "stop" | "status";
-	data?: string;
-}
-
-function getPtyBridge(): string {
-	const platform = process.platform;
-	const arch = process.arch;
-	const binaryName = `ptybridge-${platform}-${arch}`;
-
-	const candidates = [
-		resolve(dirname(process.argv[1] || process.execPath), "native", binaryName),
-		resolve(dirname(import.meta.dirname), "native", binaryName),
-		resolve(import.meta.dirname, "..", "native", binaryName),
-	];
-	for (const p of candidates) {
-		try {
-			const { statSync } = require("node:fs");
-			if (statSync(p).isFile()) return p;
-		} catch {}
-	}
-	return candidates[0];
-}
-
-export function runDaemon(
-	sessionName: string,
-	executable: string,
-	args: string[],
-) {
-	ensureSessionsDir();
-	const sock = socketPath(sessionName);
-
-	try {
-		unlinkSync(sock);
-	} catch {}
-
-	let outputBuffer = "";
-	let processExited = false;
-	let exitCode: number | null = null;
-
-	const ptyBridge = getPtyBridge();
-	const proc = spawn(ptyBridge, [executable, ...args], {
-		stdio: ["pipe", "pipe", "pipe"],
-		env: { ...process.env, TERM: "xterm-256color" },
-	});
-
-	const { stdout, stderr, stdin } = proc;
-
-	stdout?.on("data", (chunk: Buffer) => {
-		outputBuffer += chunk.toString();
-	});
-
-	stderr?.on("data", (chunk: Buffer) => {
-		outputBuffer += chunk.toString();
-	});
-
-	proc.on("exit", (code) => {
-		processExited = true;
-		exitCode = code;
-		outputBuffer += `\n[exited ${code}]`;
-
-		setTimeout(() => {
-			server.close();
-			try {
-				unlinkSync(sock);
-			} catch {}
-			process.exit(0);
-		}, 60_000);
-	});
-
-	proc.on("error", (err) => {
-		outputBuffer += `\n[error: ${err.message}]`;
-		processExited = true;
-	});
-
-	const server = createServer((socket) => {
-		let buf = "";
-
-		socket.on("data", (chunk) => {
-			buf += chunk.toString();
-			try {
-				const msg = JSON.parse(buf);
-				buf = "";
-				handle(msg, socket);
-			} catch {}
-		});
-	});
-
-	function handle(msg: DaemonMessage, socket: Socket) {
-		switch (msg.action) {
-			case "read":
-				socket.end(
-					JSON.stringify({
-						ok: true,
-						output: outputBuffer,
-						exited: processExited,
-						exitCode,
-					}),
-				);
-				break;
-
-			case "send":
-				if (processExited) {
-					socket.end(JSON.stringify({ ok: false, error: "process exited" }));
-					break;
-				}
-				stdin?.write(`${msg.data}\r`);
-				socket.end(JSON.stringify({ ok: true }));
-				break;
-
-			case "stop":
-				proc.kill("SIGTERM");
-				socket.end(JSON.stringify({ ok: true }));
-				setTimeout(() => {
-					server.close();
-					try {
-						unlinkSync(sock);
-					} catch {}
-					process.exit(0);
-				}, 500);
-				break;
-
-			case "status":
-				socket.end(
-					JSON.stringify({
-						ok: true,
-						running: !processExited,
-						pid: proc.pid,
-						exitCode,
-					}),
-				);
-				break;
-
-			default:
-				socket.end(JSON.stringify({ ok: false, error: "unknown action" }));
-		}
-	}
-
-	server.listen(sock);
-}

package/src/index.ts

@@ -1,316 +0,0 @@
-#!/usr/bin/env bun
-
-import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import { sendMessage } from "./client";
-import { ensureSessionsDir, socketPath } from "./paths";
-
-const HELP = `noninteractive — run interactive CLI commands non-interactively.
-
-usage: npx noninteractive <tool> [args...]
-
-commands:
-  <tool> [args...]         start a session (runs npx <tool> in a PTY)
-  read  <session>          read current terminal output
-  send  <session> <text>   send keystrokes (use "" for Enter)
-  stop  <session>          stop a session
-  list                     show active sessions
-  start <cmd> [args...]    explicit start (for non-npx commands)
-
-the session name is auto-derived from the tool (e.g. "workos" → session "workos").
-
-example workflow:
-  npx noninteractive workos                 # starts "npx workos", session = "workos"
-  npx noninteractive read workos            # see what's on screen
-  npx noninteractive send workos ""         # press Enter
-  npx noninteractive send workos "y"        # type "y" and press Enter
-  npx noninteractive read workos            # see updated output
-  npx noninteractive stop workos            # done, stop the session
-
-more examples:
-  npx noninteractive vercel                 # session "vercel"
-  npx noninteractive supabase init          # session "supabase"
-  npx noninteractive start vercel login     # explicit start for non-npx commands`;
-
-function getSelfCommand(): string[] {
-	if (process.argv[1] && /\.(ts|js)$/.test(process.argv[1])) {
-		return [process.argv[0], process.argv[1]];
-	}
-	return [process.argv[0]];
-}
-
-function deriveSessionName(cmd: string, args: string[]): string {
-	const parts = [cmd, ...args];
-	// skip npx/bunx prefix to get the real command name
-	let i = 0;
-	if (parts[i] === "npx" || parts[i] === "bunx") i++;
-	// skip flags like -y, --yes
-	while (i < parts.length && parts[i].startsWith("-")) i++;
-	const name = parts[i] || cmd;
-	// strip npm scope @foo/bar -> bar
-	return name.replace(/^@[^/]+\//, "").replace(/[^a-zA-Z0-9_-]/g, "");
-}
-
-async function start(cmdArgs: string[]) {
-	const executable = cmdArgs[0];
-	const args = cmdArgs.slice(1);
-	const name = deriveSessionName(executable, args);
-	const sock = socketPath(name);
-
-	try {
-		const res = await sendMessage(sock, { action: "read" });
-		if (res.ok) {
-			process.stdout.write(res.output ?? "");
-			if (res.exited) {
-				console.log(
-					`\n[session '${name}' already exists but exited ${res.exitCode} — stopping it]`,
-				);
-				try {
-					await sendMessage(sock, { action: "stop" });
-				} catch {}
-				// fall through to start a new session
-			} else {
-				console.log(
-					`\n[session '${name}' already running — read the output above, then use:]`,
-				);
-				console.log(
-					`  npx noninteractive send ${name} "<text>"   # send keystrokes (use "" for Enter)`,
-				);
-				console.log(
-					`  npx noninteractive read ${name}             # read updated output`,
-				);
-				console.log(
-					`  npx noninteractive stop ${name}             # stop the session`,
-				);
-				return;
-			}
-		}
-	} catch {}
-
-	ensureSessionsDir();
-	try {
-		const { unlinkSync } = await import("node:fs");
-		unlinkSync(sock);
-	} catch {}
-
-	const self = getSelfCommand();
-	const child = spawn(
-		self[0],
-		[...self.slice(1), "__daemon__", name, executable, ...args],
-		{
-			detached: true,
-			stdio: "ignore",
-		},
-	);
-	child.unref();
-
-	// wait for socket to appear
-	for (let i = 0; i < 50; i++) {
-		if (existsSync(sock)) break;
-		await new Promise((r) => setTimeout(r, 100));
-	}
-
-	if (!existsSync(sock)) {
-		console.error(`error: failed to start session '${name}'.`);
-		console.error(`the command was: ${executable} ${args.join(" ")}`);
-		console.error(`\nmake sure the command exists. examples:`);
-		console.error(
-			`  npx noninteractive start npx vercel        # run an npx package`,
-		);
-		console.error(
-			`  npx noninteractive start vercel login       # run a command directly`,
-		);
-		process.exit(1);
-	}
-
-	// poll until we get meaningful output (up to 10s)
-	const stripAnsi = (s: string) =>
-		s.replace(/\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07]*\x07/g, "");
-	for (let i = 0; i < 50; i++) {
-		await new Promise((r) => setTimeout(r, 200));
-		try {
-			const res = await sendMessage(sock, { action: "read" });
-			const clean = stripAnsi(res.output ?? "").trim();
-			if (clean.length > 10) {
-				process.stdout.write(res.output);
-				if (res.exited) {
-					console.log(
-						`\n[session '${name}' exited ${res.exitCode} — the command failed]`,
-					);
-					console.log(
-						`hint: the first argument to "start" is the command to run, NOT a session name.`,
-					);
-					console.log(
-						`  npx noninteractive start npx vercel        # run an npx package`,
-					);
-					console.log(
-						`  npx noninteractive start vercel login       # run a command directly`,
-					);
-				} else {
-					console.log(
-						`\n[session '${name}' started — read the output above, then use:]`,
-					);
-					console.log(
-						`  npx noninteractive send ${name} "<text>"   # send keystrokes (use "" for Enter)`,
-					);
-					console.log(
-						`  npx noninteractive read ${name}             # read updated output`,
-					);
-					console.log(
-						`  npx noninteractive stop ${name}             # stop the session`,
-					);
-				}
-				return;
-			}
-			if (res.exited) {
-				process.stdout.write(res.output ?? "");
-				console.log(
-					`\n[session '${name}' exited ${res.exitCode} — the command failed]`,
-				);
-				console.log(
-					`hint: the first argument to "start" is the command to run, NOT a session name.`,
-				);
-				console.log(
-					`  npx noninteractive start npx vercel        # run an npx package`,
-				);
-				console.log(
-					`  npx noninteractive start vercel login       # run a command directly`,
-				);
-				return;
-			}
-		} catch {}
-	}
-
-	console.log(`[session '${name}' started but no output yet — use:]`);
-	console.log(`  npx noninteractive read ${name}             # read output`);
-	console.log(
-		`  npx noninteractive send ${name} "<text>"   # send keystrokes (use "" for Enter)`,
-	);
-	console.log(
-		`  npx noninteractive stop ${name}             # stop the session`,
-	);
-}
-
-async function read(name: string) {
-	const sock = socketPath(name);
-	const res = await sendMessage(sock, { action: "read" });
-	if (res.output !== undefined) process.stdout.write(res.output);
-	if (res.exited) console.log(`\n[exited ${res.exitCode}]`);
-}
-
-async function send(name: string, text: string) {
-	const sock = socketPath(name);
-	await sendMessage(sock, { action: "send", data: text });
-	console.log(
-		`[sent to '${name}' — run "npx noninteractive read ${name}" to see the result]`,
-	);
-}
-
-async function stop(name: string) {
-	const sock = socketPath(name);
-	await sendMessage(sock, { action: "stop" });
-	console.log(`session '${name}' stopped`);
-}
-
-async function list() {
-	const { readdirSync } = await import("node:fs");
-	ensureSessionsDir();
-	const files = readdirSync((await import("./paths")).SESSIONS_DIR);
-	const sessions = files
-		.filter((f) => f.endsWith(".sock"))
-		.map((f) => f.replace(".sock", ""));
-
-	if (sessions.length === 0) {
-		console.log("no active sessions");
-		return;
-	}
-
-	for (const name of sessions) {
-		const sock = socketPath(name);
-		try {
-			const res = await sendMessage(sock, { action: "status" });
-			const status = res.running ? "running" : `exited (${res.exitCode})`;
-			console.log(`${name} [${status}] pid=${res.pid}`);
-		} catch {
-			console.log(`${name} [dead]`);
-		}
-	}
-}
-
-async function main() {
-	const args = process.argv.slice(2);
-
-	if (args[0] === "__daemon__") {
-		const { runDaemon } = await import("./daemon");
-		return runDaemon(args[1], args[2], args.slice(3));
-	}
-
-	const cmd = args[0];
-
-	switch (cmd) {
-		case "start": {
-			if (args.length < 2) {
-				console.error(
-					"usage: noninteractive start <cmd> [args...]\n\nexample: npx noninteractive start npx vercel",
-				);
-				process.exit(1);
-			}
-			return start(args.slice(1));
-		}
-		case "read": {
-			const name = args[1];
-			if (!name) {
-				console.error(
-					"usage: noninteractive read <session>\n\nexample: npx noninteractive read vercel",
-				);
-				process.exit(1);
-			}
-			return read(name);
-		}
-		case "send": {
-			const name = args[1];
-			const text = args[2];
-			if (!name || text === undefined) {
-				console.error(
-					'usage: noninteractive send <session> <text>\n\nexample: npx noninteractive send vercel "y"',
-				);
-				process.exit(1);
-			}
-			return send(name, text);
-		}
-		case "stop": {
-			const name = args[1];
-			if (!name) {
-				console.error(
-					"usage: noninteractive stop <session>\n\nexample: npx noninteractive stop vercel",
-				);
-				process.exit(1);
-			}
-			return stop(name);
-		}
-		case "list":
-		case "ls":
-			return list();
-		case "version":
-		case "--version":
-		case "-v": {
-			const { version } = require("../package.json");
-			console.log(`noninteractive v${version}`);
-			return;
-		}
-		case undefined:
-		case "help":
-		case "--help":
-		case "-h":
-			console.log(HELP);
-			break;
-		default:
-			// treat unknown commands as: start npx <args>
-			return start(["npx", ...args]);
-	}
-}
-
-main().catch((err) => {
-	console.error(err.message);
-	process.exit(1);
-});

package/src/paths.ts

@@ -1,13 +0,0 @@
-import { mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { resolve } from "node:path";
-
-export const SESSIONS_DIR = resolve(homedir(), ".noninteractive", "sessions");
-
-export function ensureSessionsDir() {
-	mkdirSync(SESSIONS_DIR, { recursive: true });
-}
-
-export function socketPath(name: string) {
-	return resolve(SESSIONS_DIR, `${name}.sock`);
-}