noninteractive 0.3.4 → 0.3.6

package/README.md

@@ -14,7 +14,7 @@ npx noninteractive
 
 ```bash
 # Start a session (runs `npx workos` in a background PTY)
-npx noninteractive start workos
+npx noninteractive workos
 
 # Read what's on screen
 npx noninteractive read workos
@@ -36,7 +36,7 @@ npx noninteractive list
 
 ```bash
 # Start the installer
-npx noninteractive start workos
+npx noninteractive workos
 
 # Wait for it to load, then read the prompt
 npx noninteractive read workos
@@ -62,9 +62,17 @@ npx noninteractive send workos ""
 npx noninteractive stop workos
 ```
 
+## Agent Skill
+
+Install the [Agent Skill](https://agentskills.io) so your AI agent knows how to use noninteractive:
+
+```bash
+npx skills add https://noninteractive.org
+```
+
 ## How it works
 
-1. `start` spawns a detached daemon process that runs the target command inside a real pseudo-terminal (PTY)
+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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "noninteractive",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "type": "module",
   "bin": {
     "noninteractive": "./src/index.ts"
@@ -13,9 +13,11 @@
     "dev": "bun run src/index.ts",
     "build": "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"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.4.5",
     "@types/bun": "latest"
   },
   "peerDependencies": {

package/src/client.ts

@@ -1,37 +1,50 @@
 import { createConnection } from "node:net";
 
-export function sendMessage(sockPath: string, msg: Record<string, unknown>): Promise<any> {
-  return new Promise((resolve, reject) => {
-    const socket = createConnection(sockPath);
-    let data = "";
+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("connect", () => {
+			socket.write(JSON.stringify(msg));
+		});
 
-    socket.on("data", (chunk) => {
-      data += chunk.toString();
-    });
+		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("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);
-      }
-    });
+		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);
-  });
+		setTimeout(() => {
+			socket.destroy();
+			reject(new Error("connection timeout"));
+		}, 5000);
+	});
 }

package/src/daemon.ts

@@ -1,125 +1,146 @@
-import { createServer } from "node:net";
 import { spawn } from "node:child_process";
 import { unlinkSync } from "node:fs";
-import { resolve, dirname } from "node:path";
-import { socketPath, ensureSessionsDir } from "./paths";
+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];
+	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" },
-  });
-
-  proc.stdout!.on("data", (chunk: Buffer) => {
-    outputBuffer += chunk.toString();
-  });
-
-  proc.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: any, socket: any) {
-    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;
-        }
-        proc.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);
+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

@@ -2,232 +2,315 @@
 
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { socketPath, ensureSessionsDir } from "./paths";
 import { sendMessage } from "./client";
+import { ensureSessionsDir, socketPath } from "./paths";
 
 const HELP = `noninteractive — run interactive CLI commands non-interactively.
 
-usage: npx noninteractive <command> [args]
+usage: npx noninteractive <tool> [args...]
 
 commands:
-  start <cmd> [args...]    start a session running <cmd>
+  <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 first argument to "start" is the command to run, NOT a session name.
-the session name is auto-derived from the command (e.g. "npx vercel" → session "vercel").
+the session name is auto-derived from the tool (e.g. "workos" → session "workos").
 
 example workflow:
-  npx noninteractive start npx vercel       # starts "npx vercel", session name = "vercel"
-  npx noninteractive read vercel            # see what's on screen
-  npx noninteractive send vercel ""         # press Enter
-  npx noninteractive send vercel "y"        # type "y" and press Enter
-  npx noninteractive read vercel            # see updated output
-  npx noninteractive stop vercel            # done, stop the session
+  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 start npx workos       # session "workos"
-  npx noninteractive start vercel login     # session "vercel"
-  npx noninteractive start npx supabase init  # session "supabase"`;
+  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]];
+	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, "");
+	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`);
+	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}]`);
+	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]`);
+	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`);
+	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]`);
-    }
-  }
+	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;
-    }
-    default:
-      console.log(HELP);
-  }
+	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);
+	console.error(err.message);
+	process.exit(1);
 });

package/src/paths.ts

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