@volter/tabnode 0.5.27 → 0.5.29

package/src/runtime.ts

@@ -117,6 +117,29 @@ function __substrateGuestConstructor(Constructor: unknown, process: Process): un
     return __substrateFunctionScope(__substrateGuestGlobal(process), String(compiled));
   } });
 }
+/**
+ * `vm.runInThisContext` runs its script in the calling process's global scope,
+ * as Node's does. The shim evaluated it in the host's, so a script saw the
+ * worker's own timers: jiti evaluates every module it loads this way, and
+ * pi-mcp-adapter's `setInterval(...).unref()` threw "unref is not a function"
+ * because the browser's `setInterval` returns a number. The script runs inside
+ * the process's guest global, as a guest `Function` does
+ * (`__substrateGuestConstructor`).
+ */
+const __substrateScriptScope = Function("__substrateScriptGlobals", "__substrateScriptSource", "with (__substrateScriptGlobals) { return eval(__substrateScriptSource); }");
+const __substrateGuestVms = new WeakMap<Process, unknown>();
+function __substrateGuestVm(process: Process): unknown {
+  let vm = __substrateGuestVms.get(process);
+  if (vm) return vm;
+  const run = (code: string): unknown => __substrateScriptScope(__substrateGuestGlobal(process), String(code));
+  class Script extends vmShim.Script {
+    override runInThisContext(_options?: object): unknown { return run((this as unknown as { code: string }).code); }
+  }
+  vm = { ...vmShim, Script, runInThisContext: (code: string, _options?: object) => run(code), default: undefined };
+  (vm as { default: unknown }).default = vm;
+  __substrateGuestVms.set(process, vm);
+  return vm;
+}
 /**
  * A `.ts`, `.mts` or `.cts` file runs with its types stripped, as Node runs
  * one since 22.18, before the module's imports are read -- the entry a `node`
@@ -413,6 +436,97 @@ function collectDirectEval(node: any, replacements: Array<[number, number, strin
   replacements.push([source.end, source.end, ")"]);
 }
 
+/**
+ * Node's AsyncLocalStorage context follows an `await`; in a tab nothing can
+ * observe one (see shims/async_hooks), so the body follows it itself. An async
+ * function takes its frame on entry and puts it back wherever it resumes:
+ * after each `await`, at the start of a `catch` or `finally` (a rejected
+ * `await` resumes there), and in and after a `for await`. An async arrow with
+ * an expression body takes the frame at each `await`, which is the same
+ * frame. Playwright names each API call from a zone it keeps in one; a zone
+ * left over from another call made its errors lose `locator.click:`. Only
+ * insertions, and no line breaks, so a stack frame keeps its line.
+ */
+const ASYNC_FRAME = '__substrateAsyncFrame';
+// Every fragment the pass inserts is one of these strings or ends in the
+// marker, so a function's source can be given back as it was written (below).
+const FOLLOW_MARK = '/*substrate*/';
+const FOLLOW_TAKE = `const ${ASYNC_FRAME}=__substrateContext();`;
+const FOLLOW_RESTORE = `__substrateRestore(${ASYNC_FRAME});`;
+const FOLLOW_RESUME_FRAMED = `__substrateResume(${ASYNC_FRAME},`;
+const FOLLOW_RESUME_TAKEN = '__substrateResume(__substrateContext(),';
+function __substrateFollowAwaits(code: string): string {
+  if (!/\bawait\b/.test(code)) return code;
+  let ast;
+  try {
+    ast = acorn.parse(code, { ecmaVersion: "latest", sourceType: "script", allowReturnOutsideFunction: true, allowHashBang: true, allowAwaitOutsideFunction: true });
+  } catch {
+    return code;
+  }
+  const edits: Array<[number, number, string]> = [];
+  const insert = (at: number, text: string): void => { edits.push([at, at, text]); };
+  const isFunction = (node: any): boolean => node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression';
+  // `framed`: the nearest function is async and holds the frame in ASYNC_FRAME.
+  const visit = (node: any, framed: boolean, parent: any): void => {
+    if (isFunction(node)) {
+      framed = node.async && node.body.type === 'BlockStatement';
+      if (framed) {
+        const directives = node.body.body.filter((statement: any) => statement.directive !== undefined);
+        const at = directives.length ? directives[directives.length - 1].end : node.body.start + 1;
+        insert(at, FOLLOW_TAKE);
+      }
+    } else if (node.type === 'AwaitExpression') {
+      insert(node.start, framed ? FOLLOW_RESUME_FRAMED : FOLLOW_RESUME_TAKEN);
+      insert(node.end, `${FOLLOW_MARK})`);
+    } else if (framed && node.type === 'CatchClause') {
+      insert(node.body.start + 1, FOLLOW_RESTORE);
+    } else if (framed && node.type === 'TryStatement' && node.finalizer) {
+      insert(node.finalizer.start + 1, FOLLOW_RESTORE);
+    } else if (framed && node.type === 'ForOfStatement' && node.await) {
+      // The loop's own wrap first: where its end is the body's, an insertion
+      // made later lands before it, so the body's brace closes inside.
+      const whole = parent?.type === 'LabeledStatement' ? parent : node;
+      insert(whole.start, `{${FOLLOW_MARK}`);
+      insert(whole.end, `;${FOLLOW_RESTORE}${FOLLOW_MARK}}`);
+      if (node.body.type === 'BlockStatement') insert(node.body.start + 1, FOLLOW_RESTORE);
+      else { insert(node.body.start, `{${FOLLOW_MARK}${FOLLOW_RESTORE}`); insert(node.body.end, `${FOLLOW_MARK}}`); }
+    }
+    for (const key of Object.keys(node)) {
+      if (key === 'type' || key === 'start' || key === 'end' || key === 'loc' || key === 'range') continue;
+      const child = node[key];
+      if (!child || typeof child !== 'object') continue;
+      if (Array.isArray(child)) {
+        for (const item of child) if (item && typeof item.type === 'string') visit(item, framed, node);
+      } else if (typeof child.type === 'string') visit(child, framed, node);
+    }
+  };
+  visit(ast, false, undefined);
+  return edits.length ? applyReplacements(code, edits) : code;
+}
+
+/**
+ * A function's source as it was written. Playwright sends the source of the
+ * function a test evaluates to the browser, where the pass's calls do not
+ * exist; the pass only inserts, so removing its fragments gives the text back.
+ */
+function __substrateUnfollowAwaits(source: string): string {
+  if (!source.includes('__substrate')) return source;
+  return source
+    .replaceAll(`;${FOLLOW_RESTORE}${FOLLOW_MARK}}`, '')
+    .replaceAll(`{${FOLLOW_MARK}${FOLLOW_RESTORE}`, '')
+    .replaceAll(`{${FOLLOW_MARK}`, '')
+    .replaceAll(`${FOLLOW_MARK}}`, '')
+    .replaceAll(`${FOLLOW_MARK})`, '')
+    .replaceAll(FOLLOW_TAKE, '')
+    .replaceAll(FOLLOW_RESTORE, '')
+    .replaceAll(FOLLOW_RESUME_FRAMED, '')
+    .replaceAll(FOLLOW_RESUME_TAKEN, '');
+}
+forGuestRealm(() => {
+  const native = Function.prototype.toString;
+  takeFromHost(Function.prototype, 'toString', function toString(this: unknown): string { return __substrateUnfollowAwaits(native.call(this)); });
+});
+
 /** Applies insertions and replacements from the end, so earlier offsets hold. */
 function applyReplacements(code: string, replacements: Array<[number, number, string]>): string {
   replacements.sort((a, b) => b[0] - a[0] || b[1] - a[1]);
@@ -425,7 +539,7 @@ Object.defineProperty(globalThis, "__substrateEvalSource", {
   configurable: true,
   value: (source: unknown): unknown => typeof source === "string" ? __substrateRewriteDynamicImportsInScript(source) : source,
 });
-/** A file's source made a body: shebang stripped, types stripped, ESM lowered, dynamic imports rewritten. */
+/** A file's source made a body: shebang stripped, types stripped, ESM lowered, dynamic imports rewritten, awaits followed. */
 function __substratePrepareBody(rawCode: string, resolvedPath: string, format: string | undefined, process: unknown): string {
   let code = rawCode;
 
@@ -456,11 +570,15 @@ function __substratePrepareBody(rawCode: string, resolvedPath: string, format: s
     // A `.cjs` module skips the ESM transform, and with it the rewrite of
     // `import(...)` to the engine's dynamic import, so its
     // `import("fs/promises")` reached the browser's own import and failed on
-    // the bare specifier. The dynamic-import rewrite applies to `.cjs` too.
-    code = transformDynamicImportsRegex(code);
+    // the bare specifier. The dynamic-import rewrite applies to `.cjs` too,
+    // from the syntax tree as for every other CommonJS module: the text
+    // rewrite also renamed a method called `import`, and jiti's
+    // `async import(e,t){...}` became `__dynamicImport`, so `jiti.import` was
+    // undefined and every Pi extension failed to load.
+    code = __substrateRewriteDynamicImportsInScript(code);
   }
 
-  return code;
+  return __substrateFollowAwaits(code);
 }
 
 /**
@@ -472,7 +590,7 @@ function __substratePrepareBody(rawCode: string, resolvedPath: string, format: s
  * place of the passes when the file it read hashes to one.
  */
 export const PREPARED_MODULES_DIR = '/.tabnode/prepared';
-const PREPARED_MODULES_FORMAT = 'tabnode-prepared-1';
+const PREPARED_MODULES_FORMAT = 'tabnode-prepared-2';
 /** The name a prepared body goes under: the hash of the file as read, and how it is compiled. Undefined for a file no body is prepared for. */
 export function preparedModuleKey(rawCode: string, resolvedPath: string): string | undefined {
   const extension = /\.(js|cjs|mjs)$/u.exec(resolvedPath)?.[1];
@@ -726,6 +844,27 @@ async function __substrateImportChain(
   return doors.__loadFromURL(resolved.url, loaded.format ?? resolved.format, loaded.source ?? void 0);
 }
 
+/**
+ * A module's `import.meta`: `url`, `dirname`, `filename` and Node's synchronous
+ * `resolve` (Node 20.6+). Pi's extension loader resolves its own packages with
+ * `import.meta.resolve(specifier)`, and without it every Pi extension failed to
+ * load with "import_meta.resolve is not a function". A relative or URL specifier
+ * resolves against the module's URL, a builtin to `node:<name>`, and a bare one
+ * through the module's own resolver, the one `import()` uses here. Unlike Node,
+ * a relative specifier naming a missing file resolves instead of throwing.
+ */
+function createImportMeta(moduleRequire: RequireFunction, url: string, dirname: string, filename: string): Record<string, unknown> {
+  const resolve = (specifier: unknown, parent?: unknown): string => {
+    const id = typeof specifier === 'string' ? specifier : String(specifier);
+    const base = parent === undefined ? url : String(parent);
+    if (id.startsWith('./') || id.startsWith('../') || id.startsWith('/')) return new URL(id, base).href;
+    if (/^[a-zA-Z][a-zA-Z\d+.-]*:/.test(id)) return id.startsWith('node:') ? id : new URL(id).href;
+    if (Object.prototype.hasOwnProperty.call(builtinModules, id)) return `node:${id}`;
+    return 'file://' + moduleRequire.resolve(id);
+  };
+  return { url, dirname, filename, resolve };
+}
+
 function createDynamicImport(moduleRequire: RequireFunction, process: Process, parentURL?: string): (specifier: unknown) => Promise<unknown> {
   return async (specifier: unknown): Promise<unknown> => {
     try {
@@ -1962,7 +2101,7 @@ function createRequire(
         dirname,
         process,
         consoleWrapper,
-        { url: importMetaUrl, dirname, filename: resolvedPath },
+        createImportMeta(moduleRequire, importMetaUrl, dirname, resolvedPath),
         dynamicImport,
         __substrateGuestGlobal,
         __substrateGuestConstructor
@@ -2130,6 +2269,11 @@ function createRequire(
     if (id === 'module') {
       return __substrateModule();
     }
+    // Ahead of the per-process builtin table: node-lib's own modules require
+    // `vm` first and that table keeps the first answer for the process.
+    if (id === 'vm') {
+      return __substrateGuestVm(process);
+    }
     if (id === 'wasi') {
       return __substrateGuestWasi(fsShim, process);
     }
@@ -2445,8 +2589,12 @@ export class Runtime {
       // A `.cjs` module skips the ESM transform, and with it the rewrite of
       // `import(...)` to the engine's dynamic import, so its
       // `import("fs/promises")` reached the browser's own import and failed on
-      // the bare specifier. The dynamic-import rewrite applies to `.cjs` too.
-      code = transformDynamicImportsRegex(code);
+      // the bare specifier. The dynamic-import rewrite applies to `.cjs` too,
+      // from the syntax tree as for every other CommonJS module: the text
+      // rewrite also renamed a method called `import`, and jiti's
+      // `async import(e,t){...}` became `__dynamicImport`, so `jiti.import` was
+      // undefined and every Pi extension failed to load.
+      code = __substrateRewriteDynamicImportsInScript(code);
     }
 
     // Execute code
@@ -2492,7 +2640,7 @@ export class Runtime {
         dirname,
         this.process,
         consoleWrapper,
-        { url: importMetaUrl, dirname, filename },
+        createImportMeta(require, importMetaUrl, dirname, filename),
         dynamicImport,
         __substrateGuestGlobal,
         __substrateGuestConstructor

package/src/shims/async_hooks.ts

@@ -1,109 +1,105 @@
 /**
- * async_hooks shim - Async tracking is not available in browser
+ * async_hooks shim: AsyncLocalStorage and AsyncResource carry context the way
+ * Node's do; the hooks themselves are not available in a browser.
  */
 
 import { forGuestRealm, takeFromHost } from '../host-globals';
 
-export class AsyncResource {
-  constructor(_type: string, _options?: object) {}
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  runInAsyncScope<T>(fn: (...args: any[]) => T, thisArg?: unknown, ...args: any[]): T {
-    return fn.apply(thisArg, args);
-  }
-
-  emitDestroy(): this { return this; }
-  asyncId(): number { return 0; }
-  triggerAsyncId(): number { return 0; }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static bind<T extends (...args: any[]) => any>(fn: T, _type?: string): T {
-    return fn;
-  }
-}
-
 /**
- * `AsyncLocalStorage.snapshot()` captures every storage's current store and
- * answers a function that runs a call inside that capture, which Next's
- * request-store constructors use to carry a request's context into the work
- * they schedule. These storages are store slots with no such capture; every
- * storage registers itself, and a snapshot is the slots as they are, restored
- * around the call and put back after.
+ * The context a continuation runs in: every storage's store, as one frame.
+ * `run` makes a new frame for its callback and puts the old one back when the
+ * callback returns, as Node's does; a frame is never changed after it is
+ * made, so a snapshot is the frame itself.
+ *
+ * A tab has no async hooks and no AsyncContext, and an `await` of a native
+ * promise bypasses any `then` a patch installs. The engine follows it at the
+ * source instead: each module body it compiles captures its async function's
+ * frame on entry and restores it where the function resumes (after each
+ * `await`, in a `catch` or `finally`, around a `for await`), through
+ * `__substrateResume` and `__substrateRestore` below. A continuation's frame
+ * holds only for the turn it runs in; the next turn starts from the root, as
+ * a macrotask of Node's does. Code the engine did not compile (its own) runs
+ * in whichever frame is current when it is called.
  */
-const __substrateAsyncLocalStorages = new Set<AsyncLocalStorage<unknown>>();
-
-export class AsyncLocalStorage<T> {
-  private store: T | undefined;
-
-  constructor() {
-    __substrateAsyncLocalStorages.add(this as AsyncLocalStorage<unknown>);
+type ContextFrame = ReadonlyMap<AsyncLocalStorage<unknown>, unknown>;
+const ROOT_FRAME: ContextFrame = new Map();
+let currentFrame: ContextFrame = ROOT_FRAME;
+const nativeQueueMicrotask = globalThis.queueMicrotask.bind(globalThis);
+let resetQueued = false;
+const resetFrame = (): void => { resetQueued = false; currentFrame = ROOT_FRAME; };
+/** A resumed continuation's frame, current until the turn it runs in ends. */
+const resumeFrame = (frame: ContextFrame): void => {
+  if (frame === currentFrame) return;
+  currentFrame = frame;
+  if (!resetQueued) { resetQueued = true; nativeQueueMicrotask(resetFrame); }
+};
+const withFrame = <R>(frame: ContextFrame, callback: () => R): R => {
+  const previous = currentFrame;
+  currentFrame = frame;
+  try {
+    return callback();
+  } finally {
+    currentFrame = previous;
   }
+};
 
+export class AsyncLocalStorage<T> {
   static snapshot() {
-    const captured = new Map<AsyncLocalStorage<unknown>, unknown>();
-    for (const storage of __substrateAsyncLocalStorages) captured.set(storage, storage.store);
-    return (callback: (...args: unknown[]) => unknown, ...args: unknown[]) => {
-      const previous = new Map<AsyncLocalStorage<unknown>, unknown>();
-      for (const [storage, store] of captured) { previous.set(storage, storage.store); storage.store = store; }
-      try {
-        return callback(...args);
-      } finally {
-        for (const [storage, store] of previous) storage.store = store;
-      }
-    };
+    const captured = currentFrame;
+    return (callback: (...args: unknown[]) => unknown, ...args: unknown[]) => withFrame(captured, () => callback(...args));
   }
   static bind(callback: (...args: unknown[]) => unknown) {
     const snapshot = AsyncLocalStorage.snapshot();
     return (...args: unknown[]) => snapshot(callback, ...args);
   }
 
-  disable(): void {}
+  disable(): void {
+    if (!currentFrame.has(this as AsyncLocalStorage<unknown>)) return;
+    const next = new Map(currentFrame);
+    next.delete(this as AsyncLocalStorage<unknown>);
+    currentFrame = next;
+  }
 
   getStore(): T | undefined {
-    return this.store;
+    return currentFrame.get(this as AsyncLocalStorage<unknown>) as T | undefined;
   }
 
-  /**
-   * A store entered for an async callback used to be left the moment the
-   * callback returned its promise, so the first `await` inside a Server Action
-   * lost Next's request store and `cookies()` was "outside a request scope". A
-   * tab has no async_hooks and no AsyncContext, and an `await` of a native
-   * promise bypasses any `then` a patch could install, so the continuations
-   * cannot be followed. What can be done honestly is keep the store current
-   * until the callback's promise settles: exact for one run at a time, and
-   * last-entered-wins where two async runs overlap.
-   */
   run<R>(store: T, callback: (...args: unknown[]) => R, ...args: unknown[]): R {
-    const prev = this.store;
-    this.store = store;
-    let result;
-    try {
-      result = callback(...args);
-    } catch (error) {
-      this.store = prev;
-      throw error;
-    }
-    if (result && typeof (result as { then?: unknown }).then === 'function') {
-      const restore = () => { if (this.store === store) this.store = prev; };
-      (result as unknown as Promise<unknown>).then(restore, restore);
-      return result;
-    }
-    this.store = prev;
-    return result;
+    const next = new Map(currentFrame);
+    next.set(this as AsyncLocalStorage<unknown>, store);
+    return withFrame(next, () => callback(...args));
   }
 
   exit<R>(callback: () => R): R {
-    const prev = this.store;
-    this.store = undefined;
-    try {
-      return callback();
-    } finally {
-      this.store = prev;
-    }
+    const next = new Map(currentFrame);
+    next.delete(this as AsyncLocalStorage<unknown>);
+    return withFrame(next, callback);
   }
 
   enterWith(store: T): void {
-    this.store = store;
+    const next = new Map(currentFrame);
+    next.set(this as AsyncLocalStorage<unknown>, store);
+    currentFrame = next;
+  }
+}
+
+/** Runs its callbacks in the context it was made in, as Node's does. */
+export class AsyncResource {
+  private readonly frame = currentFrame;
+  constructor(_type: string, _options?: object) {}
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  runInAsyncScope<T>(fn: (...args: any[]) => T, thisArg?: unknown, ...args: any[]): T {
+    return withFrame(this.frame, () => fn.apply(thisArg, args));
+  }
+
+  emitDestroy(): this { return this; }
+  asyncId(): number { return 0; }
+  triggerAsyncId(): number { return 0; }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static bind<T extends (...args: any[]) => any>(fn: T, _type?: string): T {
+    return AsyncLocalStorage.bind(fn) as T;
   }
 }
 
@@ -112,10 +108,10 @@ export class AsyncLocalStorage<T> {
  * schedules: a timer, an immediate, a microtask, a nextTick, a promise
  * callback. A tab has no async hooks, so each of those is wrapped once to
  * capture the stores current when it was scheduled and restore them when it
- * runs. A native `await` is the one continuation this cannot follow, which
- * `run` covers by holding its store until the callback settles. React's
- * server renderer schedules its work on immediates and promises, and read
- * Next's request store through them.
+ * runs. A native `await` is the one continuation this cannot follow: the
+ * compiled module body follows it, through the three globals installed here.
+ * React's server renderer schedules its work on immediates and promises, and
+ * read Next's request store through them.
  *
  * The wrapping is a guest's, not the realm's. It used to run at load, so
  * importing the engine into a Node process replaced that process's own
@@ -145,6 +141,10 @@ forGuestRealm(() => {
   ): Promise<TFulfilled | TRejected> { return then.call(this, carried(onFulfilled), carried(onRejected)) as Promise<TFulfilled | TRejected>; };
   takeFromHost(Promise.prototype, 'then', carriedThen);
   takeFromHost(globalThis, '__substrateCarried', carried);
+  // An async function's frame, taken on entry; put back where it resumes.
+  takeFromHost(globalThis, '__substrateContext', () => currentFrame);
+  takeFromHost(globalThis, '__substrateResume', <V>(frame: ContextFrame, value: V): V => { resumeFrame(frame); return value; });
+  takeFromHost(globalThis, '__substrateRestore', (frame: ContextFrame): void => { resumeFrame(frame); });
 });
 
 export interface AsyncHook {

package/src/shims/child_process.ts

@@ -1143,7 +1143,26 @@ function readPackageJson(cwd: string): { pkgJson: PackageJson; error?: undefined
  * Handle `npm run [script]` — execute a script from package.json
  */
 async function handleNpmRun(args: string[], ctx: CommandContext): Promise<JustBashExecResult> {
-  const scriptName = args[0];
+  // npm's own options come before the script's name and are npm's
+  // (`npm run --silent vgai -- mcp .`, as a project's `.mcp.json` launches its
+  // server); what follows the name goes to the script, everything after `--`
+  // untouched. The name used to be `args[0]`, so `--silent` was looked up as a
+  // script, and the script's own arguments were dropped.
+  let scriptName: string | undefined;
+  let silent = false;
+  let ifPresent = false;
+  const passed: string[] = [];
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index]!;
+    if (arg === '--') { if (scriptName !== undefined) passed.push(...args.slice(index + 1)); break; }
+    if (arg.startsWith('-') && arg !== '-') {
+      if (arg === '--silent' || arg === '-s' || arg === '--quiet' || arg === '-q' || arg === '--loglevel=silent') silent = true;
+      else if (arg === '--if-present') ifPresent = true;
+      continue;
+    }
+    if (scriptName === undefined) scriptName = arg;
+    else passed.push(arg);
+  }
 
   // "npm run" with no script name: list available scripts
   if (!scriptName) {
@@ -1158,6 +1177,7 @@ async function handleNpmRun(args: string[], ctx: CommandContext): Promise<JustBa
   const scriptCommand = scripts[scriptName];
 
   if (!scriptCommand) {
+    if (ifPresent) return { stdout: '', stderr: '', exitCode: 0 };
     const available = Object.keys(scripts);
     let msg = `npm ERR! Missing script: "${scriptName}"\n`;
     if (available.length > 0) {
@@ -1193,7 +1213,7 @@ async function handleNpmRun(args: string[], ctx: CommandContext): Promise<JustBa
   // Run pre<script> if it exists
   const preScript = scripts[`pre${scriptName}`];
   if (preScript) {
-    allStderr += `\n> ${label} pre${scriptName}\n> ${preScript}\n\n`;
+    if (!silent) allStderr += `\n> ${label} pre${scriptName}\n> ${preScript}\n\n`;
     const preResult = await ctx.exec(preScript, { cwd: ctx.cwd, env: npmEnv });
     allStdout += preResult.stdout;
     allStderr += preResult.stderr;
@@ -1202,9 +1222,14 @@ async function handleNpmRun(args: string[], ctx: CommandContext): Promise<JustBa
     }
   }
 
-  // Run the main script
-  allStderr += `\n> ${label} ${scriptName}\n> ${scriptCommand}\n\n`;
-  const mainResult = await ctx.exec(scriptCommand, { cwd: ctx.cwd, env: npmEnv });
+  // Run the main script, with the arguments npm passes it, each quoted.
+  const command = passed.length > 0
+    ? `${scriptCommand} ${passed.map((arg) => /^[\w@%+=:,./-]+$/.test(arg) ? arg : `'${arg.replace(/'/g, `'\\''`)}'`).join(' ')}`
+    : scriptCommand;
+  if (!silent) allStderr += `\n> ${label} ${scriptName}\n> ${command}\n\n`;
+  // The script reads npm's standard input: a `.mcp.json` server launched as
+  // `npm run … -- serve` speaks JSON-RPC on it.
+  const mainResult = await ctx.exec(command, { cwd: ctx.cwd, env: npmEnv, ...(typeof ctx.stdin === 'string' ? { stdin: ctx.stdin } : {}) });
   allStdout += mainResult.stdout;
   allStderr += mainResult.stderr;
 
@@ -1215,7 +1240,7 @@ async function handleNpmRun(args: string[], ctx: CommandContext): Promise<JustBa
   // Run post<script> if it exists
   const postScript = scripts[`post${scriptName}`];
   if (postScript) {
-    allStderr += `\n> ${label} post${scriptName}\n> ${postScript}\n\n`;
+    if (!silent) allStderr += `\n> ${label} post${scriptName}\n> ${postScript}\n\n`;
     const postResult = await ctx.exec(postScript, { cwd: ctx.cwd, env: npmEnv });
     allStdout += postResult.stdout;
     allStderr += postResult.stderr;