@addai/node 0.8.1 → 0.9.0

package/dist/open-browser.js

@@ -0,0 +1,42 @@
+"use strict";
+// Open a URL in whatever the user calls their browser.
+//
+// No dependency for this. The three commands are stable, and a package that
+// shells out for you is a package that can break pairing on a platform we
+// cannot test from here.
+//
+// Windows deliberately does NOT go through cmd.exe. `start` is a shell
+// builtin, so reaching it means spawning a shell around a URL, and this
+// codebase has already been burned by putting cmd.exe near strings it did not
+// control. rundll32 takes the URL as a plain argument and hands it to the
+// registered handler.
+//
+// Everything here is best-effort by design. A browser that fails to open is
+// not a failed pairing — the terminal still shows the code and the link, and
+// the user carries on by hand. So this never throws and never blocks: it
+// reports whether the launch was ACCEPTED, which is all the caller can
+// honestly say.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openBrowser = openBrowser;
+const child_process_1 = require("child_process");
+function openBrowser(url, platform = process.platform) {
+    const [cmd, args] = platform === 'darwin' ? ['open', [url]]
+        : platform === 'win32' ? ['rundll32', ['url.dll,FileProtocolHandler', url]]
+            : ['xdg-open', [url]];
+    try {
+        const child = (0, child_process_1.spawn)(cmd, args, {
+            stdio: 'ignore',
+            // The browser outlives us — and on a machine where the daemon is about
+            // to take over the terminal, a child holding the TTY would fight it.
+            detached: true,
+        });
+        // A missing xdg-open surfaces here rather than as an unhandled error that
+        // takes the daemon down with it.
+        child.on('error', () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/pair-destination.d.ts

@@ -0,0 +1,20 @@
+export interface PairDestination {
+    /** What to call it on screen. */
+    product: string;
+    /** Where the user goes to confirm. */
+    url: string;
+    /** That URL carrying the code, which is what actually gets opened. */
+    link(code: string): string;
+}
+/**
+ * @param argv process.argv.slice(2)
+ * @param env  process.env
+ */
+export declare function pairDestination(argv: string[], env?: NodeJS.ProcessEnv): PairDestination;
+export interface BrowserEnv {
+    isTTY: boolean;
+    platform: NodeJS.Platform | string;
+    env: NodeJS.ProcessEnv;
+}
+/** Would opening a browser here actually show the user anything? */
+export declare function canOpenBrowser({ isTTY, platform, env }: BrowserEnv): boolean;

package/dist/pair-destination.js

@@ -0,0 +1,59 @@
+"use strict";
+// Which product this machine is joining, and whether we can open a browser
+// to finish the job.
+//
+// The command the user ran is the answer to the first question. They copied it
+// off a page that already knew — so asking "which product?" in the terminal
+// would be asking them to repeat themselves. `ainode entities` goes to Entity
+// Studio; everything else keeps going to Vault, exactly as it always has.
+//
+// The second question is the one that decides whether pairing feels like
+// magic or like a broken promise. Opening a browser on a machine nobody is
+// sitting at does nothing; opening one over SSH opens it on the wrong
+// computer entirely. Both are common, so both are checked, and when the
+// answer is no the code gets printed like it always did.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pairDestination = pairDestination;
+exports.canOpenBrowser = canOpenBrowser;
+const config_1 = require("./config");
+const destination = (product, url) => ({
+    product,
+    url,
+    link: (code) => `${url}/${encodeURIComponent(code)}`,
+});
+/**
+ * @param argv process.argv.slice(2)
+ * @param env  process.env
+ */
+function pairDestination(argv, env = process.env) {
+    const entities = argv[0] === 'entities';
+    // A dev override has to move BOTH products or a local Studio ends up
+    // pairing against production Vault, which is a confusing way to lose an
+    // afternoon.
+    const base = env.AINODE_PAIR_BASE?.replace(/\/+$/, '');
+    if (base) {
+        return entities
+            ? destination('+Ai Entities', `${base}/connect`)
+            : destination('+Ai Vault', `${base}/add/entity`);
+    }
+    return entities
+        ? destination('+Ai Entities', config_1.ENTITIES_PAIR_URL)
+        : destination('+Ai Vault', config_1.VAULT_PAIR_URL);
+}
+/** Would opening a browser here actually show the user anything? */
+function canOpenBrowser({ isTTY, platform, env }) {
+    if (!isTTY)
+        return false;
+    if (env.AINODE_NO_BROWSER === '1')
+        return false;
+    // Over SSH the browser would open on the machine being administered, where
+    // nobody is looking at it — and the terminal would sit there claiming it
+    // had done something helpful.
+    if (env.SSH_TTY || env.SSH_CONNECTION)
+        return false;
+    // A Linux box with no display server has no browser to open. macOS and
+    // Windows always have one.
+    if (platform === 'linux' && !env.DISPLAY && !env.WAYLAND_DISPLAY)
+        return false;
+    return true;
+}

package/dist/pairing.d.ts

@@ -14,7 +14,9 @@ export declare function requestPairCode(): Promise<string>;
  */
 export declare function awaitPairing(code: string): Promise<FinalizeResult>;
 /**
- * Print the human-facing instructions for a fresh pairing.
+ * Run the whole first-run flow: ask, open, wait, save.
+ *
+ * @param argv process.argv.slice(2) — decides which product to join
  */
-export declare function printPairingInstructions(code: string): void;
+export declare function runPairing(argv: string[]): Promise<FinalizeResult>;
 export {};

package/dist/pairing.js

@@ -1,7 +1,15 @@
 "use strict";
-// First-run pairing flow. Called when state.json doesn't exist. Walks the
-// user through obtaining a 5-letter code and entering it at
-// vault.add.ai/add/entity. Once finalized, persists the daemon_token.
+// First-run pairing flow. Called when state.json doesn't exist.
+//
+// The machine now does the walking. It asks one question, opens the user's
+// browser at the confirm page carrying its own code, and waits — so the
+// person types nothing and never has to know a code existed. Where that
+// cannot work (no terminal, over SSH, headless Linux) it prints the code and
+// the link exactly as it always did, because those machines are real and are
+// often the ones that most need a node on them.
+//
+// Which product the browser lands on comes from the command the user ran:
+// `ainode entities` goes to Entity Studio, everything else to Vault.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -38,10 +46,13 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requestPairCode = requestPairCode;
 exports.awaitPairing = awaitPairing;
-exports.printPairingInstructions = printPairingInstructions;
+exports.runPairing = runPairing;
 const os = __importStar(require("os"));
 const supabase_client_1 = require("./supabase-client");
 const store_1 = require("./store");
+const pair_destination_1 = require("./pair-destination");
+const open_browser_1 = require("./open-browser");
+const pair_1 = require("./tui/pair");
 const config_1 = require("./config");
 function platform() {
     const p = process.platform;
@@ -113,17 +124,54 @@ async function awaitPairing(code) {
     throw new Error('pair_timeout');
 }
 /**
- * Print the human-facing instructions for a fresh pairing.
+ * Run the whole first-run flow: ask, open, wait, save.
+ *
+ * @param argv process.argv.slice(2) — decides which product to join
  */
-function printPairingInstructions(code) {
-    console.log('');
-    console.log('  ── Setup needed ──');
-    console.log('');
-    console.log(`  1. Open  ${config_1.VAULT_PAIR_URL}`);
-    console.log(`  2. Enter this code:  ${code}`);
-    console.log('');
-    console.log(`  (or click:  ${config_1.VAULT_PAIR_URL}/${code})`);
-    console.log('');
-    console.log('  Waiting for pairing… (expires in 15 minutes)');
-    console.log('');
+async function runPairing(argv) {
+    const dest = (0, pair_destination_1.pairDestination)(argv);
+    const hostname = os.hostname();
+    const interactive = (0, pair_destination_1.canOpenBrowser)({
+        isTTY: Boolean(process.stdout.isTTY) && Boolean(process.stdin.isTTY),
+        platform: process.platform,
+        env: process.env,
+    });
+    // Ask BEFORE minting a code. A code starts a 15-minute clock the moment it
+    // exists, and someone who walks away at the question should not come back
+    // to an expired one.
+    const choice = interactive ? await (0, pair_1.promptConnect)({ product: dest.product, hostname }) : 'manual';
+    const code = await requestPairCode();
+    const link = dest.link(code);
+    const opened = choice === 'open' ? (0, open_browser_1.openBrowser)(link) : false;
+    let waiting = null;
+    if (interactive) {
+        waiting = (0, pair_1.renderWaiting)({ product: dest.product, link, code, opened });
+    }
+    else {
+        // Headless: plain lines, no spinner, no cursor games. This output ends up
+        // in a log file as often as on a screen.
+        console.log('');
+        console.log(`  Connect this machine to ${dest.product}`);
+        console.log('');
+        console.log(`  1. Open  ${dest.url}`);
+        console.log(`  2. Enter this code:  ${code}`);
+        console.log('');
+        console.log(`  (or open directly:  ${link})`);
+        console.log('');
+        console.log('  Waiting for pairing… (expires in 15 minutes)');
+        console.log('');
+    }
+    try {
+        const result = await awaitPairing(code);
+        waiting?.stop();
+        if (interactive)
+            (0, pair_1.renderConnected)(hostname);
+        else
+            console.log(`  ✓ Connected as ${hostname}`);
+        return result;
+    }
+    catch (err) {
+        waiting?.stop();
+        throw err;
+    }
 }

package/dist/request-pump.d.ts

@@ -1,4 +1,5 @@
 export declare function inflightCount(): number;
+export declare function activeRequestIdList(): string[];
 export declare function start(): void;
 export declare function stop(): void;
 /**

package/dist/request-pump.js

@@ -5,6 +5,7 @@
 // arrives.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.inflightCount = inflightCount;
+exports.activeRequestIdList = activeRequestIdList;
 exports.start = start;
 exports.stop = stop;
 exports.drain = drain;
@@ -59,6 +60,14 @@ let lastHealthBlockAt = 0;
 // Exported so /stats can surface "pump stuck at N inflight" without
 // having to guess.
 function inflightCount() { return inflight; }
+// The runs this daemon is holding a child process for, right now. This is the
+// only honest answer to "is that run alive?" — the server used to infer it from
+// how recently the agent emitted an event, which measures how chatty the agent
+// is, not whether it is alive. A grok turn routinely goes ten minutes between
+// its last streamed token and turn_complete, and the server was failing those
+// runs mid-flight and apologising to the user for a reply that had already
+// arrived. Reported every 30s by the heartbeat.
+function activeRequestIdList() { return [...activeRequestIds]; }
 async function tick() {
     if (stopped)
         return;

package/dist/session-runner.js

@@ -2206,7 +2206,8 @@ async function runRequest(req) {
     if (installed.mcps?.some((m) => m.slug === 'entity-self-mcp')) {
         const livingPresence = [
             'LIVING PRESENCE — narrate your work so people can see what you are doing in real time.',
-            'Whenever you are working on a specific table record (a card / task / row), call the `report_status` tool at your real milestones: when you claim/start it (status "working", a low progress, a short human note like "Reviewing"), at each checkpoint (bump progress + update the note), if you get stuck and need a human (status "blocked", note why), and when you finish (status "done"). ALWAYS pass the record_id you are working on; if you are working on several records at once, report each separately with its own record_id so they never overwrite each other. This is lightweight — a handful of milestone updates per task; progress is a rough milestone percent (0-100), not a precise measurement.',
+            'Whenever you are working on a specific table record (a card / task / row), call the `report_status` tool at your real milestones: when you claim/start it (status "working", a low progress, a short note), at each checkpoint (bump progress + update the note), if you get stuck and need a human (status "blocked"), and when you finish (status "done"). ALWAYS pass the record_id you are working on; if you are working on several records at once, report each separately with its own record_id so they never overwrite each other. This is lightweight — a handful of milestone updates per task; progress is a rough milestone percent (0-100), not a precise measurement.',
+            'THE `note` MUST BE ULTRA-SHORT — 1 to 3 plain, friendly words a teammate could read at a glance, e.g. "Reviewing", "Playing widget", "Writing summary", "Checking design", "Almost done". It renders in a tiny bubble, so NEVER write a sentence and NEVER use technical or internal jargon (not "waiting for publish propagation" — just "Publishing"). Think status label, not explanation.',
         ].join('\n');
         req.system_prompt =
             req.system_prompt && req.system_prompt.trim().length > 0

package/dist/tui/pair.d.ts

@@ -0,0 +1,33 @@
+export type PairChoice = 'open' | 'manual';
+interface PromptOpts {
+    /** '+Ai Entities' — what the user thinks they are joining. */
+    product: string;
+    hostname: string;
+}
+/**
+ * Ask whether to open the browser. Resolves the user's answer; never rejects.
+ *
+ * Ctrl-C here means "I did not want to do this at all", so it exits rather
+ * than falling through to a code the user never asked for.
+ */
+export declare function promptConnect({ product, hostname }: PromptOpts): Promise<PairChoice>;
+export interface WaitingHandle {
+    /** Stop the spinner and leave the block on screen. */
+    stop(): void;
+}
+/**
+ * The block that stays up while the daemon waits to be claimed.
+ *
+ * It shows the code and the link even when the browser opened fine. That is
+ * not clutter — a browser that opened on the wrong profile, or behind another
+ * window, is invisible from here, and the only recovery is the thing this
+ * block is holding.
+ */
+export declare function renderWaiting(opts: {
+    product: string;
+    link: string;
+    code: string;
+    opened: boolean;
+}): WaitingHandle;
+export declare function renderConnected(name: string): void;
+export {};

package/dist/tui/pair.js

@@ -0,0 +1,178 @@
+"use strict";
+// The first thing anyone sees: one question, then the browser opens.
+//
+// This is not a screen on the console stack, and deliberately so. That stack
+// owns the alt screen and exits the process when it quits — both wrong here.
+// Pairing has to hand back to a daemon that then runs for months, and the code
+// and link have to stay in scrollback afterwards, because the most likely
+// reason someone is still reading this block is that the browser didn't open.
+//
+// So: no alt screen, no takeover. A question that repaints in place, then a
+// block that stays on the terminal and a spinner line that updates until the
+// machine is through.
+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.promptConnect = promptConnect;
+exports.renderWaiting = renderWaiting;
+exports.renderConnected = renderConnected;
+const readline = __importStar(require("readline"));
+const render_1 = require("./render");
+const E = '\x1b[';
+const write = (s) => { process.stdout.write(s); };
+/** Move up n lines and clear from there down — how a block repaints in place. */
+const rewind = (n) => { if (n > 0)
+    write(`${E}${n}A${E}0J`); };
+const CHOICES = [
+    { id: 'open', label: 'Yes, open my browser' },
+    { id: 'manual', label: 'No, show me a code instead' },
+];
+/**
+ * Ask whether to open the browser. Resolves the user's answer; never rejects.
+ *
+ * Ctrl-C here means "I did not want to do this at all", so it exits rather
+ * than falling through to a code the user never asked for.
+ */
+function promptConnect({ product, hostname }) {
+    return new Promise(resolve => {
+        let sel = 0;
+        let painted = 0;
+        const frame = () => [
+            '',
+            `  ${(0, render_1.bold)((0, render_1.cyan)('✦'))} ${(0, render_1.bold)('+Ai Node')}`,
+            '',
+            `  Connect ${(0, render_1.bold)(hostname)} to ${(0, render_1.bold)(product)}?`,
+            '',
+            ...CHOICES.map((c, i) => i === sel ? `  ${(0, render_1.green)('▸')} ${c.label}` : `    ${(0, render_1.grey)(c.label)}`),
+            '',
+            `  ${(0, render_1.dim)('↑↓ to choose · ⏎ to continue · ^C to cancel')}`,
+            '',
+        ];
+        const paint = () => {
+            rewind(painted);
+            const lines = frame();
+            write(lines.join('\n') + '\n');
+            painted = lines.length;
+        };
+        const done = (choice) => {
+            rewind(painted);
+            process.stdin.off('keypress', onKey);
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(false);
+            process.stdin.pause();
+            resolve(choice);
+        };
+        function onKey(_s, key) {
+            if (!key)
+                return;
+            if (key.ctrl && key.name === 'c') {
+                rewind(painted);
+                write(`  ${(0, render_1.dim)('Cancelled. Run the command again when you are ready.')}\n\n`);
+                process.exit(130);
+            }
+            if (key.name === 'up' || key.name === 'k') {
+                sel = (sel + CHOICES.length - 1) % CHOICES.length;
+                paint();
+            }
+            else if (key.name === 'down' || key.name === 'j') {
+                sel = (sel + 1) % CHOICES.length;
+                paint();
+            }
+            else if (key.name === 'y')
+                done('open');
+            else if (key.name === 'n')
+                done('manual');
+            else if (key.name === 'return' || key.name === 'space')
+                done(CHOICES[sel].id);
+        }
+        readline.emitKeypressEvents(process.stdin);
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on('keypress', onKey);
+        paint();
+    });
+}
+/**
+ * The block that stays up while the daemon waits to be claimed.
+ *
+ * It shows the code and the link even when the browser opened fine. That is
+ * not clutter — a browser that opened on the wrong profile, or behind another
+ * window, is invisible from here, and the only recovery is the thing this
+ * block is holding.
+ */
+function renderWaiting(opts) {
+    const { product, link, code, opened } = opts;
+    write('\n');
+    if (opened) {
+        write(`  ${(0, render_1.green)('✦')} ${(0, render_1.bold)(`Waiting in your browser…`)}\n`);
+        write('\n');
+        write(`  ${(0, render_1.dim)('Nothing opened? Go to')}  ${(0, render_1.cyan)(link)}\n`);
+    }
+    else {
+        write(`  ${(0, render_1.bold)(`Connect this machine to ${product}`)}\n`);
+        write('\n');
+        write(`  ${(0, render_1.dim)('1.')} Open  ${(0, render_1.cyan)(link.replace(`/${code}`, ''))}\n`);
+        write(`  ${(0, render_1.dim)('2.')} Enter this code:  ${(0, render_1.bold)((0, render_1.green)(code))}\n`);
+        write('\n');
+        write(`  ${(0, render_1.dim)('or open this directly:')}  ${(0, render_1.cyan)(link)}\n`);
+    }
+    if (opened)
+        write(`  ${(0, render_1.dim)('or enter this code:')}  ${(0, render_1.bold)((0, render_1.green)(code))}\n`);
+    write('\n');
+    let n = 0;
+    let painted = false;
+    const line = () => `  ${(0, render_1.green)(render_1.SPIN[n % render_1.SPIN.length])} ${(0, render_1.dim)('waiting for you to confirm · expires in 15 minutes')}`;
+    const tick = () => {
+        if (painted)
+            rewind(1);
+        write(line() + '\n');
+        painted = true;
+        n++;
+    };
+    tick();
+    const timer = setInterval(tick, 120);
+    // A spinner is not a reason to keep the process alive.
+    timer.unref?.();
+    return {
+        stop() {
+            clearInterval(timer);
+            if (painted)
+                rewind(1);
+        },
+    };
+}
+function renderConnected(name) {
+    write(`  ${(0, render_1.green)('✓')} ${(0, render_1.bold)('Connected')} ${(0, render_1.dim)('as')} ${name}\n\n`);
+}

package/package.json

@@ -1,60 +1,60 @@
-{
-  "name": "@addai/node",
-  "version": "0.8.1",
-  "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"
-  }
-}
+{
+  "name": "@addai/node",
+  "version": "0.9.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"
+  }
+}