npm - noninteractive - Versions diffs - 0.1.0 - Mend

noninteractive 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/CLAUDE.md ADDED Viewed

@@ -0,0 +1,144 @@
+# noninteractive CLI
+Session wrapper for interactive CLI commands. Lets claude code run interactive login flows non-interactively.
+## Architecture
+- `src/index.ts` — CLI entry point, arg parsing, auto-start flow
+- `src/daemon.ts` — detached daemon per session, spawns target command, unix socket server
+- `src/client.ts` — connects to daemon via unix socket, sends JSON commands
+- `src/paths.ts` — session dir/socket path helpers
+- `src/ptybridge.py` — python3 PTY bridge, allocates real terminal for child process
+Sessions stored at `~/.noninteractive/sessions/<name>.sock`. Protocol is JSON over unix socket.
+## Commands
+```
+noninteractive start <name> [args...]   # start session (runs npx <name> in a PTY)
+noninteractive read  <name>             # read terminal output
+noninteractive send  <name> <text>      # send keystrokes to session
+noninteractive stop  <name>             # stop a session
+noninteractive list                     # show active sessions (alias: ls)
+```
+## Build
+```
+bun run build    # compiles to bin/noninteractive standalone binary
+```
+## Notes
+- daemon uses node:child_process and node:net (not Bun-specific APIs) for subprocess/socket — needed for detached spawn and unix socket server
+- PTY via python3 ptybridge.py — allocates a real pseudo-terminal so child processes see isTTY=true
+- compiled binary is ~55MB (includes bun runtime)
+- ptybridge.py must be co-located with the binary (or in src/ during dev)
+---
+Default to using Bun instead of Node.js.
+- Use `bun <file>` instead of `node <file>` or `ts-node <file>`
+- Use `bun test` instead of `jest` or `vitest`
+- Use `bun build <file.html|file.ts|file.css>` instead of `webpack` or `esbuild`
+- Use `bun install` instead of `npm install` or `yarn install` or `pnpm install`
+- Use `bun run <script>` instead of `npm run <script>` or `yarn run <script>` or `pnpm run <script>`
+- Use `bunx <package> <command>` instead of `npx <package> <command>`
+- Bun automatically loads .env, so don't use dotenv.
+## APIs
+- `Bun.serve()` supports WebSockets, HTTPS, and routes. Don't use `express`.
+- `bun:sqlite` for SQLite. Don't use `better-sqlite3`.
+- `Bun.redis` for Redis. Don't use `ioredis`.
+- `Bun.sql` for Postgres. Don't use `pg` or `postgres.js`.
+- `WebSocket` is built-in. Don't use `ws`.
+- Prefer `Bun.file` over `node:fs`'s readFile/writeFile
+- Bun.$`ls` instead of execa.
+## Testing
+Use `bun test` to run tests.
+```ts#index.test.ts
+import { test, expect } from "bun:test";
+test("hello world", () => {
+  expect(1).toBe(1);
+});
+```
+## Frontend
+Use HTML imports with `Bun.serve()`. Don't use `vite`. HTML imports fully support React, CSS, Tailwind.
+Server:
+```ts#index.ts
+import index from "./index.html"
+Bun.serve({
+  routes: {
+    "/": index,
+    "/api/users/:id": {
+      GET: (req) => {
+        return new Response(JSON.stringify({ id: req.params.id }));
+      },
+    },
+  },
+  // optional websocket support
+  websocket: {
+    open: (ws) => {
+      ws.send("Hello, world!");
+    },
+    message: (ws, message) => {
+      ws.send(message);
+    },
+    close: (ws) => {
+      // handle close
+    }
+  },
+  development: {
+    hmr: true,
+    console: true,
+  }
+})
+```
+HTML files can import .tsx, .jsx or .js files directly and Bun's bundler will transpile & bundle automatically. `<link>` tags can point to stylesheets and Bun's CSS bundler will bundle.
+```html#index.html
+<html>
+  <body>
+    <h1>Hello, world!</h1>
+    <script type="module" src="./frontend.tsx"></script>
+  </body>
+</html>
+```
+With the following `frontend.tsx`:
+```tsx#frontend.tsx
+import React from "react";
+import { createRoot } from "react-dom/client";
+// import .css files directly and it works
+import './index.css';
+const root = createRoot(document.body);
+export default function Frontend() {
+  return <h1>Hello, world!</h1>;
+}
+root.render(<Frontend />);
+```
+Then, run index.ts
+```sh
+bun --hot ./index.ts
+```
+For more information, read the Bun API docs in `node_modules/bun-types/docs/**.mdx`.

package/README.md ADDED Viewed

@@ -0,0 +1,15 @@
+# cli
+To install dependencies:
+```bash
+bun install
+```
+To run:
+```bash
+bun run index.ts
+```
+This project was created using `bun init` in bun v1.3.6. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/index.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ console.log("Hello via Bun!");

package/package.json ADDED Viewed

@@ -0,0 +1,19 @@
+{
+  "name": "noninteractive",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "noninteractive": "./src/index.ts"
+  },
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "bun build src/index.ts --compile --outfile bin/noninteractive",
+    "test": "bun test"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}

package/prompt.md ADDED Viewed

@@ -0,0 +1,11 @@
+You have a CLI tool called `2027` that wraps interactive CLI commands so you can control them non-interactively across multiple invocations.
+It has these subcommands:
+- Start a session (runs the command in background with a PTY)
+- Read the current terminal output of a session
+- Send keystrokes/text to a session
+- Stop a session
+- List active sessions
+Given this tool, what would you name each subcommand? Just the verb, one word each. Think about what feels most natural and guessable.

package/src/client.ts ADDED Viewed

@@ -0,0 +1,37 @@
+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 = "";
+    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 ADDED Viewed

@@ -0,0 +1,123 @@
+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";
+function getPtyBridge(): string {
+  // when compiled, pty.py is bundled next to the binary
+  // in dev, it's in the same directory as this file
+  const candidates = [
+    resolve(dirname(process.argv[1] || process.execPath), "ptybridge.py"),
+    resolve(dirname(import.meta.dirname), "ptybridge.py"),
+    resolve(import.meta.dirname, "ptybridge.py"),
+  ];
+  for (const p of candidates) {
+    try {
+      const { statSync } = require("node:fs");
+      if (statSync(p).isFile()) return p;
+    } catch {}
+  }
+  return resolve(import.meta.dirname, "ptybridge.py");
+}
+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("python3", [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);
+}

package/src/index.ts ADDED Viewed

@@ -0,0 +1,146 @@
+#!/usr/bin/env bun
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { socketPath, ensureSessionsDir } from "./paths";
+import { sendMessage } from "./client";
+const HELP = `usage: noninteractive <command> [args]
+  start <name> [args...]   start a session (runs npx <name>)
+  read  <name>             read terminal output
+  send  <name> <text>      send keystrokes to session
+  stop  <name>             stop a session
+  list                     show active sessions`;
+function getSelfCommand(): string[] {
+  if (process.argv[1] && /\.(ts|js)$/.test(process.argv[1])) {
+    return [process.argv[0], process.argv[1]];
+  }
+  return [process.argv[0]];
+}
+async function start(name: string, args: string[]) {
+  const sock = socketPath(name);
+  try {
+    const res = await sendMessage(sock, { action: "read" });
+    if (res.ok) {
+      process.stdout.write(res.output ?? "");
+      console.log(`\n[session '${name}' already running]`);
+      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, "npx", name, ...args], {
+    detached: true,
+    stdio: "ignore",
+  });
+  child.unref();
+  for (let i = 0; i < 50; i++) {
+    if (existsSync(sock)) {
+      await new Promise(r => setTimeout(r, 200));
+      try {
+        const res = await sendMessage(sock, { action: "read" });
+        if (res.output) process.stdout.write(res.output);
+      } catch {}
+      console.log(`[session '${name}' started]`);
+      return;
+    }
+    await new Promise(r => setTimeout(r, 100));
+  }
+  console.error("timeout: failed to start session");
+  process.exit(1);
+}
+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 });
+}
+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": {
+      const name = args[1];
+      if (!name) { console.error("usage: noninteractive start <name> [args...]"); process.exit(1); }
+      return start(name, args.slice(2));
+    }
+    case "read": {
+      const name = args[1];
+      if (!name) { console.error("usage: noninteractive read <name>"); 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 <name> <text>"); process.exit(1); }
+      return send(name, text);
+    }
+    case "stop": {
+      const name = args[1];
+      if (!name) { console.error("usage: noninteractive stop <name>"); process.exit(1); }
+      return stop(name);
+    }
+    case "list":
+    case "ls":
+      return list();
+    default:
+      console.log(HELP);
+  }
+}
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});

package/src/paths.ts ADDED Viewed

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

package/src/ptybridge.py ADDED Viewed

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+"""PTY bridge: spawns a command in a real PTY, pipes stdin/stdout."""
+import pty, os, sys, select, fcntl, termios, struct
+master, slave = pty.openpty()
+# set terminal size so TUI libraries render correctly
+winsize = struct.pack("HHHH", 24, 80, 0, 0)
+fcntl.ioctl(slave, termios.TIOCSWINSZ, winsize)
+pid = os.fork()
+if pid == 0:
+    os.close(master)
+    os.setsid()
+    # make slave the controlling terminal
+    fcntl.ioctl(slave, termios.TIOCSCTTY, 0)
+    os.dup2(slave, 0)
+    os.dup2(slave, 1)
+    os.dup2(slave, 2)
+    os.close(slave)
+    os.execvp(sys.argv[1], sys.argv[1:])
+os.close(slave)
+try:
+    while True:
+        fds = [master]
+        try:
+            fds.append(sys.stdin.fileno())
+        except ValueError:
+            pass
+        r, _, _ = select.select(fds, [], [], 1.0)
+        if sys.stdin.fileno() in r:
+            data = os.read(sys.stdin.fileno(), 4096)
+            if not data:
+                continue
+            os.write(master, data)
+        if master in r:
+            data = os.read(master, 4096)
+            if not data:
+                break
+            os.write(sys.stdout.fileno(), data)
+except OSError:
+    pass
+_, status = os.waitpid(pid, 0)
+sys.exit(os.WEXITSTATUS(status) if os.WIFEXITED(status) else 1)

package/tsconfig.json ADDED Viewed

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}