fix(deno): use stdin/stdout IPC and prevent deno.lock creation

Deno doesn't support Node.js IPC (`process.send`/`process.on("message")`).
Switch to newline-delimited JSON over stdin/stdout for bidirectional messaging.
Add `--node-modules-dir=auto --no-lock` to use existing node_modules and skip lock file.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: pi0

src/runners/deno-process/runner.ts

@@ -81,10 +81,10 @@ export class DenoProcessEnvRunner extends BaseEnvRunner {
 
     const child = spawn(
       "deno",
-      ["run", "--allow-all", "--node-modules-dir=auto", ...(execArgv || []), this._workerEntry],
+      ["run", "-A", "--node-modules-dir=auto", "--no-lock", ...(execArgv || []), this._workerEntry],
       {
         env,
-        stdio: ["pipe", "pipe", "pipe", "ipc"],
+        stdio: ["pipe", "pipe", "pipe"],
       },
     );
 
@@ -95,7 +95,9 @@ export class DenoProcessEnvRunner extends BaseEnvRunner {
     const handle: ProcessHandle = {
       pid: child.pid!,
       kill: () => child.kill(),
-      send: (message: unknown) => child.send(message as any),
+      send: (message: unknown) => {
+        child.stdin!.write(JSON.stringify(message) + "\n");
+      },
       exited,
       _exitCode: undefined,
       removeAllListeners: () => child.removeAllListeners(),
@@ -113,8 +115,22 @@ export class DenoProcessEnvRunner extends BaseEnvRunner {
       }
     });
 
-    child.on("message", (message: any) => {
-      this._handleMessage(message);
+    // Parse newline-delimited JSON from stdout for IPC
+    let buffer = "";
+    child.stdout!.on("data", (chunk: Buffer) => {
+      buffer += chunk.toString();
+      let newlineIdx;
+      while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, newlineIdx);
+        buffer = buffer.slice(newlineIdx + 1);
+        if (line.startsWith("{")) {
+          try {
+            this._handleMessage(JSON.parse(line));
+          } catch {
+            // Not JSON, ignore
+          }
+        }
+      }
     });
 
     this.#process = handle;

src/runners/deno-process/worker.ts

@@ -4,7 +4,14 @@ import { resolveEntry, reloadEntryModule, parseServerAddress } from "../../commo
 
 const data = JSON.parse(process.env.ENV_RUNNER_DATA || "{}");
 let entry = await resolveEntry(data.entry);
-const sendMessage = (message: unknown) => process.send!(message);
+
+// Deno doesn't support Node.js IPC (process.send), so use stdin/stdout JSON lines
+const _stdout = (globalThis as any).Deno?.stdout
+  ? { write: (s: string) => (globalThis as any).Deno.stdout.writeSync(new TextEncoder().encode(s)) }
+  : process.stdout;
+const sendMessage = (message: unknown) => _stdout.write(JSON.stringify(message) + "\n");
+
+const _stdin = (globalThis as any).Deno?.stdin?.readable || process.stdin;
 
 const server = serve({
   port: 0,
@@ -28,34 +35,58 @@ if (entry.ipc) {
   await entry.ipc.onOpen?.({ sendMessage });
 }
 
-process.send!({
+sendMessage({
   address: parseServerAddress(server),
 });
 
-process.on("message", async (message: any) => {
+// Read newline-delimited JSON from stdin
+async function readMessages() {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  for await (const chunk of _stdin as AsyncIterable<Uint8Array>) {
+    buffer += decoder.decode(chunk, { stream: true });
+    let newlineIdx;
+    while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+      const line = buffer.slice(0, newlineIdx);
+      buffer = buffer.slice(newlineIdx + 1);
+      if (!line) continue;
+      let message: any;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      await handleMessage(message);
+    }
+  }
+}
+
+async function handleMessage(message: any) {
   if (message?.event === "shutdown") {
     Promise.resolve(entry.ipc?.onClose?.())
       .then(() => server.close())
       .then(() => {
-        process.send!({ event: "exit" });
+        sendMessage({ event: "exit" });
       });
     return;
   }
 
   if (message?.event === "reload-module") {
     try {
       entry = await reloadEntryModule(data.entry, entry, sendMessage);
-      process.send!({ event: "module-reloaded" });
+      sendMessage({ event: "module-reloaded" });
     } catch (error: any) {
-      process.send!({ event: "module-reloaded", error: error?.message || String(error) });
+      sendMessage({ event: "module-reloaded", error: error?.message || String(error) });
     }
     return;
   }
 
   if (message?.type === "ping") {
-    process.send!({ type: "pong", data: message.data });
+    sendMessage({ type: "pong", data: message.data });
     return;
   }
 
   entry.ipc?.onMessage?.(message);
-});
+}
+
+readMessages().catch(() => {});