@addai/node 0.4.0

package/dist/win.js

@@ -0,0 +1,317 @@
+"use strict";
+// Windows-compatibility helpers shared by every module that discovers or
+// spawns an agent CLI. On macOS every function here is either a no-op
+// passthrough or the same logic the callers used before; the win32 branches
+// are additive. One deliberate Linux delta: the old kimi/codex/gemini PATH
+// probe (execFileSync('command', ...) with no shell) only worked on macOS
+// (which ships /usr/bin/command); on Linux it always threw and discovery
+// fell through to hardcoded candidates. The /bin/sh probe here works on all
+// POSIX, so on Linux a PATH-resident binary now correctly wins — matching
+// macOS behavior and the finders' documented intent.
+//
+// The three Windows realities this file encapsulates:
+//
+//  1. npm installs CLIs as `.cmd` shims (%APPDATA%\npm\<name>.cmd), and
+//     Node >=18.17/20 refuses to spawn/execFile a .cmd/.bat without
+//     shell:true (EINVAL — the CVE-2024-27980 fix). shell:true means
+//     cmd.exe, and our argv routinely carries whole chat prompts (quotes,
+//     %VARS%, newlines) — running that through cmd.exe is a command-
+//     injection hazard. So instead of a shell we RESOLVE the shim to the
+//     node script it wraps and run [process.execPath, script, ...args]
+//     directly. No cmd.exe anywhere near prompt text.
+//
+//  2. `command -v` / /bin/sh don't exist on Windows; PATH lookup is
+//     `where`, and results need .exe preferred over .cmd.
+//
+//  3. Creating FILE symlinks needs admin/Developer Mode; DIRECTORY links
+//     work unprivileged only as junctions. Renaming over an open file
+//     fails EPERM/EBUSY (antivirus etc.).
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IS_WINDOWS = void 0;
+exports.whereLookup = whereLookup;
+exports.npmShimCandidates = npmShimCandidates;
+exports.findCliBinary = findCliBinary;
+exports.resolveCliInvocation = resolveCliInvocation;
+exports.killProcessTree = killProcessTree;
+exports.wrapMcpCommandForPlatform = wrapMcpCommandForPlatform;
+exports.safeRenameSync = safeRenameSync;
+exports.linkOrCopyFile = linkOrCopyFile;
+exports.linkDir = linkDir;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const paths_1 = require("./paths");
+exports.IS_WINDOWS = process.platform === 'win32';
+function fileExists(p) {
+    try {
+        return fs.existsSync(p) && fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** `where <name>` on win32. Returns the best hit (.exe > .cmd > .bat) or
+ *  null. Extensionless hits (git-bash shims) are skipped — CreateProcess
+ *  can't run them. */
+function whereLookup(name) {
+    if (!exports.IS_WINDOWS)
+        return null;
+    try {
+        const out = (0, child_process_1.execFileSync)('where', [name], { encoding: 'utf8', timeout: 5000 });
+        const lines = out.split(/\r?\n/).map(l => l.trim()).filter(Boolean);
+        const pick = lines.find(l => /\.exe$/i.test(l)) ??
+            lines.find(l => /\.cmd$/i.test(l)) ??
+            lines.find(l => /\.bat$/i.test(l)) ??
+            null;
+        return pick && fileExists(pick) ? pick : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Standard npm global-shim locations for a CLI on win32. */
+function npmShimCandidates(name) {
+    const out = [];
+    const appData = process.env.APPDATA;
+    const localAppData = process.env.LOCALAPPDATA;
+    if (appData)
+        out.push(path.join(appData, 'npm', `${name}.cmd`));
+    if (localAppData)
+        out.push(path.join(localAppData, 'npm', `${name}.cmd`));
+    out.push(path.join(os.homedir(), 'AppData', 'Roaming', 'npm', `${name}.cmd`));
+    return out;
+}
+/** POSIX PATH probe via the shell (`command -v` follows aliases/functions
+ *  to a real path; /bin/sh exists on every macOS/Linux box). */
+function posixCommandV(name) {
+    try {
+        const out = (0, child_process_1.execFileSync)('/bin/sh', ['-c', `command -v ${name}`], {
+            encoding: 'utf8',
+            timeout: 5000,
+        }).trim();
+        return out && fs.existsSync(out) ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Cross-platform CLI discovery: PATH probe first, then platform-specific
+ * candidate paths. Returns null when not installed — callers surface an
+ * install hint. NOT cached here; each finder module keeps its own cache.
+ */
+function findCliBinary(name, opts = {}) {
+    if (exports.IS_WINDOWS) {
+        const viaWhere = whereLookup(name);
+        if (viaWhere)
+            return viaWhere;
+        const nodeDir = path.dirname(process.execPath);
+        const execSiblings = [path.join(nodeDir, `${name}.cmd`), path.join(nodeDir, `${name}.exe`)];
+        const toolsShims = [paths_1.RUNTIME_HOME, paths_1.LEGACY_RUNTIME_HOME].flatMap(root => {
+            const toolsDir = path.join(root, 'tools');
+            return [path.join(toolsDir, `${name}.cmd`), path.join(toolsDir, `${name}.exe`)];
+        });
+        for (const c of [...npmShimCandidates(name), ...(opts.win32Candidates ?? []), ...execSiblings, ...toolsShims]) {
+            if (fileExists(c))
+                return c;
+        }
+        return null;
+    }
+    const viaSh = posixCommandV(name);
+    if (viaSh)
+        return viaSh;
+    // npm -g drops bins next to the node binary itself (nvm/homebrew/asdf
+    // prefixes) — a dir that is often NOT on the daemon's launchd PATH.
+    const nodeBinSibling = path.join(path.dirname(process.execPath), name);
+    // The daemon's own toolchain prefix — where installs land when the
+    // machine's global prefix is root-owned (EACCES fallback).
+    // The legacy home is searched too: a box whose state dir was never
+    // migrated (because the new home already had its own state.json) can
+    // still hold harnesses installed before the rename.
+    const toolsBins = [paths_1.RUNTIME_HOME, paths_1.LEGACY_RUNTIME_HOME].map(root => path.join(root, 'tools', 'bin', name));
+    for (const c of [...(opts.posixCandidates ?? []), nodeBinSibling, ...toolsBins]) {
+        if (fileExists(c))
+            return c;
+    }
+    return null;
+}
+/**
+ * Turn a (binary, args) pair into something Node can actually spawn on this
+ * platform. POSIX: identity. win32: `.cmd`/`.bat` npm shims are resolved to
+ * the node script they wrap and run via process.execPath — never through
+ * cmd.exe, because args carry raw prompt text. `.exe` passes through.
+ *
+ * Throws with a descriptive message when a shim can't be resolved — callers
+ * already route spawn errors into a clean per-request failure.
+ */
+function resolveCliInvocation(bin, args) {
+    if (!exports.IS_WINDOWS)
+        return { file: bin, args };
+    let target = bin;
+    // A bare name (no dir, no extension) can't be CreateProcess'd unless it's
+    // an .exe on PATH — try `where` to pin it down.
+    if (!path.isAbsolute(target) && !/\.(exe|cmd|bat)$/i.test(target)) {
+        const found = whereLookup(target);
+        if (found)
+            target = found;
+    }
+    if (/\.(cmd|bat)$/i.test(target)) {
+        const script = resolveNpmShimScript(target);
+        if (!script) {
+            throw new Error(`cannot spawn npm shim safely: ${target} — could not resolve the node script it wraps. ` +
+                `Install the CLI's native Windows build (an .exe) or reinstall via npm.`);
+        }
+        return { file: process.execPath, args: [script, ...args] };
+    }
+    return { file: target, args };
+}
+/** Parse a package-manager .cmd shim for the `…\node_modules\…js` script it
+ *  executes. Returns the absolute script path or null. Two shim dialects:
+ *  npm's cmd-shim writes `"%dp0%\<rel>.js"` (a variable it SETs earlier);
+ *  pnpm/yarn-classic write `"%~dp0\<rel>.js"` (batch parameter expansion —
+ *  note: no trailing `%`). */
+function resolveNpmShimScript(shimPath) {
+    let body;
+    try {
+        body = fs.readFileSync(shimPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const m = body.match(/"%(?:dp0%|~dp0)[\\/]([^"]+\.(?:m|c)?js)"/i);
+    if (!m)
+        return null;
+    const script = path.join(path.dirname(shimPath), m[1]);
+    return fs.existsSync(script) ? script : null;
+}
+/**
+ * Kill an agent child process. POSIX: SIGINT (graceful — CLIs flush and
+ * exit). win32: `taskkill /T /F` — Node's SIGINT emulation is a hard
+ * TerminateProcess on the one process anyway, and /T also reaps the MCP
+ * server grandchildren that would otherwise be orphaned.
+ */
+function killProcessTree(proc) {
+    if (exports.IS_WINDOWS && proc.pid) {
+        try {
+            (0, child_process_1.spawn)('taskkill', ['/PID', String(proc.pid), '/T', '/F'], {
+                stdio: 'ignore',
+                windowsHide: true,
+            }).unref();
+            return;
+        }
+        catch { /* fall through to plain kill */ }
+    }
+    try {
+        proc.kill('SIGINT');
+    }
+    catch { /* already gone */ }
+}
+/**
+ * Rewrite a stdio MCP server command for the platform. On native Windows,
+ * registry commands like `npx` are npm .cmd shims that the agent CLIs
+ * (claude.exe, codex, grok…) can't CreateProcess directly — the documented
+ * fix is a `cmd /c` wrapper. MCP commands + args come from the trusted
+ * registry (not chat text), so cmd.exe here is acceptable. `.exe` commands
+ * pass through untouched. POSIX: identity.
+ */
+function wrapMcpCommandForPlatform(command, args) {
+    if (!exports.IS_WINDOWS)
+        return { command, args };
+    if (/\.exe$/i.test(command))
+        return { command, args };
+    return { command: 'cmd', args: ['/c', command, ...args] };
+}
+function sleepSync(ms) {
+    try {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+    }
+    catch { /* SharedArrayBuffer unavailable — skip the wait */ }
+}
+/**
+ * renameSync with win32 EPERM/EBUSY retries (antivirus / another process
+ * briefly holding the target open), falling back to copy+unlink. POSIX
+ * behaves exactly like fs.renameSync.
+ */
+function safeRenameSync(from, to) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            fs.renameSync(from, to);
+            return;
+        }
+        catch (err) {
+            const code = err.code;
+            const retryable = exports.IS_WINDOWS && (code === 'EPERM' || code === 'EBUSY' || code === 'EACCES');
+            if (!retryable)
+                throw err;
+            if (attempt >= 2)
+                break;
+            sleepSync(30 * (attempt + 1));
+        }
+    }
+    // Last resort: non-atomic replace (still better than failing the write).
+    fs.copyFileSync(from, to);
+    try {
+        fs.unlinkSync(from);
+    }
+    catch { /* tmp file left behind — harmless */ }
+}
+/**
+ * Bridge a host file into a sandbox dir: symlink where possible, copy where
+ * not (win32 file symlinks need admin/Developer Mode). maxCopyBytes guards
+ * against duplicating something huge when we fall back to copying.
+ */
+function linkOrCopyFile(real, dest, maxCopyBytes = 8 * 1024 * 1024) {
+    try {
+        fs.symlinkSync(real, dest);
+        return;
+    }
+    catch { /* fall through */ }
+    try {
+        const st = fs.statSync(real);
+        if (st.size <= maxCopyBytes)
+            fs.copyFileSync(real, dest);
+    }
+    catch { /* unreadable — skip */ }
+}
+/** Directory link that works unprivileged on win32 ('junction' is ignored
+ *  by Node on POSIX, where a normal symlink is created). */
+function linkDir(real, dest) {
+    try {
+        fs.symlinkSync(real, dest, 'junction');
+    }
+    catch { /* target exists or FS refuses — caller treats as best-effort */ }
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@addai/node",
+  "version": "0.4.0",
+  "description": "Daemon that pairs a machine with your +Ai account and runs Claude / Codex / Kimi / Gemini agents on its behalf. Reachable via Supabase from Vault, Entity Studio, or any other +Ai surface.",
+  "license": "MIT",
+  "keywords": [
+    "addai",
+    "entity-studio",
+    "claude",
+    "codex",
+    "kimi",
+    "gemini",
+    "agent",
+    "daemon",
+    "supabase",
+    "mcp"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/just-AddAi/addai-entity-runtime.git"
+  },
+  "homepage": "https://github.com/just-AddAi/addai-entity-runtime#readme",
+  "bugs": {
+    "url": "https://github.com/just-AddAi/addai-entity-runtime/issues"
+  },
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "bin": {
+    "ainode": "dist/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "scripts",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/cli.js",
+    "dev": "tsc -p tsconfig.json && node dist/cli.js",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\"",
+    "postinstall": "node scripts/fix-pty-helper.js",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "node-pty": "^1.1.0",
+    "ws": "^8.21.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.6.0"
+  }
+}

package/scripts/fix-pty-helper.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+// node-pty ships POSIX prebuilds whose `spawn-helper` binary can lose its
+// executable bit when the npm tarball is extracted. macOS node-pty
+// posix_spawn()s that helper, so without +x every PTY spawn dies with
+// "posix_spawnp failed." — see src/pty-helper.ts for the full story.
+//
+// This used to hunt for <pkg>/node_modules/node-pty by hand, a path that
+// only exists when node-pty is NESTED. npm hoists it to the tree root under
+// npx, so the fix silently did nothing on exactly the installs that needed
+// it. The real logic now lives in the daemon (dist/pty-helper.js) and
+// resolves the package the way Node does. The daemon also repairs at boot,
+// so if dist isn't built yet (a source checkout installing before its first
+// build) we exit quietly instead of duplicating the logic here.
+
+let mod;
+try {
+  mod = require('../dist/pty-helper.js');
+} catch {
+  process.exit(0);
+}
+
+try {
+  const line = mod.describeRepair(mod.ensurePtyHelperExecutable());
+  if (line) process.stdout.write(`[entities-runtime] ${line}\n`);
+} catch (err) {
+  process.stderr.write(`[entities-runtime] pty helper check failed: ${err.message}\n`);
+}
+process.exit(0);