newtype-profile 1.0.18 → 1.0.19

package/dist/cli/index.js

@@ -2253,7 +2253,7 @@ var require_picocolors = __commonJS((exports, module) => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "newtype-profile",
-    version: "1.0.18",
+    version: "1.0.19",
     description: "AI Agent Collaboration System for Content Creation - Based on oh-my-opencode",
     main: "dist/index.js",
     types: "dist/index.d.ts",

package/dist/index.js

@@ -8502,7 +8502,7 @@ var require_cross_spawn = __commonJS((exports, module) => {
   var cp = __require("child_process");
   var parse7 = require_parse2();
   var enoent = require_enoent();
-  function spawn12(command, args, options) {
+  function spawn5(command, args, options) {
     const parsed = parse7(command, args, options);
     const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
     enoent.hookChildProcess(spawned, parsed);
@@ -8514,8 +8514,8 @@ var require_cross_spawn = __commonJS((exports, module) => {
     result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
     return result;
   }
-  module.exports = spawn12;
-  module.exports.spawn = spawn12;
+  module.exports = spawn5;
+  module.exports.spawn = spawn5;
   module.exports.sync = spawnSync2;
   module.exports._parse = parse7;
   module.exports._enoent = enoent;
@@ -9050,8 +9050,57 @@ ${CONTEXT_REMINDER}
 // src/hooks/session-notification.ts
 import { platform } from "os";
 
+// src/shared/spawn.ts
+import { spawn as nodeSpawn } from "child_process";
+import { writeFile } from "fs/promises";
+function spawnAsync(command, options = {}) {
+  return new Promise((resolve, reject) => {
+    const [cmd, ...args] = command;
+    const proc = nodeSpawn(cmd, args, {
+      cwd: options.cwd,
+      stdio: [options.stdin ? "pipe" : "ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let killed = false;
+    const timeoutId = options.timeout ? setTimeout(() => {
+      killed = true;
+      proc.kill();
+      reject(new Error(`Timeout after ${options.timeout}ms`));
+    }, options.timeout) : null;
+    if (options.stdin && proc.stdin) {
+      proc.stdin.write(options.stdin);
+      proc.stdin.end();
+    }
+    proc.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (timeoutId)
+        clearTimeout(timeoutId);
+      if (!killed) {
+        resolve({ stdout, stderr, exitCode: code ?? 1 });
+      }
+    });
+    proc.on("error", (err) => {
+      if (timeoutId)
+        clearTimeout(timeoutId);
+      reject(err);
+    });
+  });
+}
+async function writeFileSafe(path3, data) {
+  if (data instanceof ArrayBuffer) {
+    await writeFile(path3, Buffer.from(data));
+  } else {
+    await writeFile(path3, data);
+  }
+}
+
 // src/hooks/session-notification-utils.ts
-var {spawn } = globalThis.Bun;
 var notifySendPath = null;
 var notifySendPromise = null;
 var osascriptPath = null;
@@ -9068,16 +9117,11 @@ async function findCommand(commandName) {
   const isWindows = process.platform === "win32";
   const cmd = isWindows ? "where" : "which";
   try {
-    const proc = spawn([cmd, commandName], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
+    const result = await spawnAsync([cmd, commandName]);
+    if (result.exitCode !== 0) {
       return null;
     }
-    const stdout = await new Response(proc.stdout).text();
-    const path3 = stdout.trim().split(`
+    const path3 = result.stdout.trim().split(`
 `)[0];
     if (!path3) {
       return null;
@@ -9965,7 +10009,6 @@ function createSessionRecoveryHook(ctx, options) {
   };
 }
 // src/hooks/comment-checker/cli.ts
-var {spawn: spawn3 } = globalThis.Bun;
 import { createRequire as createRequire2 } from "module";
 import { dirname, join as join9 } from "path";
 import { existsSync as existsSync5 } from "fs";
@@ -9973,7 +10016,6 @@ import * as fs2 from "fs";
 import { tmpdir as tmpdir3 } from "os";
 
 // src/hooks/comment-checker/downloader.ts
-var {spawn: spawn2 } = globalThis.Bun;
 import { existsSync as existsSync4, mkdirSync as mkdirSync3, chmodSync, unlinkSync as unlinkSync2, appendFileSync as appendFileSync2 } from "fs";
 import { join as join8 } from "path";
 import { homedir as homedir2, tmpdir as tmpdir2 } from "os";
@@ -10023,29 +10065,17 @@ function getPackageVersion() {
 }
 async function extractTarGz(archivePath, destDir) {
   debugLog("Extracting tar.gz:", archivePath, "to", destDir);
-  const proc = spawn2(["tar", "-xzf", archivePath, "-C", destDir], {
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    const stderr = await new Response(proc.stderr).text();
-    throw new Error(`tar extraction failed (exit ${exitCode}): ${stderr}`);
+  const result = await spawnAsync(["tar", "-xzf", archivePath, "-C", destDir]);
+  if (result.exitCode !== 0) {
+    throw new Error(`tar extraction failed (exit ${result.exitCode}): ${result.stderr}`);
   }
 }
 async function extractZip(archivePath, destDir) {
   debugLog("Extracting zip:", archivePath, "to", destDir);
-  const proc = process.platform === "win32" ? spawn2(["powershell", "-command", `Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`], {
-    stdout: "pipe",
-    stderr: "pipe"
-  }) : spawn2(["unzip", "-o", archivePath, "-d", destDir], {
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    const stderr = await new Response(proc.stderr).text();
-    throw new Error(`zip extraction failed (exit ${exitCode}): ${stderr}`);
+  const command = process.platform === "win32" ? ["powershell", "-command", `Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`] : ["unzip", "-o", archivePath, "-d", destDir];
+  const result = await spawnAsync(command);
+  if (result.exitCode !== 0) {
+    throw new Error(`zip extraction failed (exit ${result.exitCode}): ${result.stderr}`);
   }
 }
 async function downloadCommentChecker() {
@@ -10078,7 +10108,7 @@ async function downloadCommentChecker() {
     }
     const archivePath = join8(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
-    await Bun.write(archivePath, arrayBuffer);
+    await writeFileSafe(archivePath, arrayBuffer);
     debugLog(`Downloaded archive to: ${archivePath}`);
     if (ext === "tar.gz") {
       await extractTarGz(archivePath, cacheDir);
@@ -10205,24 +10235,15 @@ async function runCommentChecker(input, cliPath, customPrompt) {
     if (customPrompt) {
       args.push("--prompt", customPrompt);
     }
-    const proc = spawn3(args, {
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    proc.stdin.write(jsonInput);
-    proc.stdin.end();
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-    const exitCode = await proc.exited;
-    debugLog2("exit code:", exitCode, "stdout length:", stdout.length, "stderr length:", stderr.length);
-    if (exitCode === 0) {
+    const result = await spawnAsync(args, { stdin: jsonInput });
+    debugLog2("exit code:", result.exitCode, "stdout length:", result.stdout.length, "stderr length:", result.stderr.length);
+    if (result.exitCode === 0) {
       return { hasComments: false, message: "" };
     }
-    if (exitCode === 2) {
-      return { hasComments: true, message: stderr };
+    if (result.exitCode === 2) {
+      return { hasComments: true, message: result.stderr };
     }
-    debugLog2("unexpected exit code:", exitCode, "stderr:", stderr);
+    debugLog2("unexpected exit code:", result.exitCode, "stderr:", result.stderr);
     return { hasComments: false, message: "" };
   } catch (err) {
     debugLog2("failed to run comment-checker:", err);
@@ -15374,7 +15395,7 @@ function parseFrontmatter(content) {
   }
 }
 // src/shared/command-executor.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn } from "child_process";
 import { exec } from "child_process";
 import { promisify } from "util";
 import { existsSync as existsSync17 } from "fs";
@@ -15419,7 +15440,7 @@ async function executeHookCommand(command, stdin, cwd, options) {
     }
   }
   return new Promise((resolve3) => {
-    const proc = spawn4(finalCommand, {
+    const proc = spawn(finalCommand, {
       cwd,
       shell: true,
       env: { ...process.env, HOME: home, CLAUDE_PROJECT_DIR: cwd }
@@ -19703,6 +19724,9 @@ function createNonInteractiveEnvHook(_ctx) {
     }
   };
 }
+// src/hooks/interactive-bash-session/index.ts
+import { spawn as spawn2 } from "child_process";
+
 // src/hooks/interactive-bash-session/storage.ts
 import {
   existsSync as existsSync32,
@@ -19867,11 +19891,13 @@ function createInteractiveBashSessionHook(_ctx) {
   async function killAllTrackedSessions(state2) {
     for (const sessionName of state2.tmuxSessions) {
       try {
-        const proc = Bun.spawn(["tmux", "kill-session", "-t", sessionName], {
-          stdout: "ignore",
-          stderr: "ignore"
+        await new Promise((resolve5) => {
+          const proc = spawn2("tmux", ["kill-session", "-t", sessionName], {
+            stdio: "ignore"
+          });
+          proc.on("close", () => resolve5());
+          proc.on("error", () => resolve5());
         });
-        await proc.exited;
       } catch {}
     }
   }
@@ -28379,7 +28405,7 @@ function getAllServers() {
   return result;
 }
 // src/tools/lsp/client.ts
-var {spawn: spawn5 } = globalThis.Bun;
+import { spawn as spawn3 } from "child_process";
 import { readFileSync as readFileSync28 } from "fs";
 import { extname, resolve as resolve6 } from "path";
 class LSPServerManager {
@@ -28534,6 +28560,7 @@ class LSPClient {
   root;
   server;
   proc = null;
+  procExitCode = null;
   buffer = new Uint8Array(0);
   pending = new Map;
   requestIdCounter = 0;
@@ -28546,10 +28573,9 @@ class LSPClient {
     this.server = server;
   }
   async start() {
-    this.proc = spawn5(this.server.command, {
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "pipe",
+    const [cmd, ...args] = this.server.command;
+    this.proc = spawn3(cmd, args, {
+      stdio: ["pipe", "pipe", "pipe"],
       cwd: this.root,
       env: {
         ...process.env,
@@ -28559,62 +28585,54 @@ class LSPClient {
     if (!this.proc) {
       throw new Error(`Failed to spawn LSP server: ${this.server.command.join(" ")}`);
     }
+    this.proc.on("exit", (code) => {
+      this.procExitCode = code;
+      this.processExited = true;
+    });
+    this.proc.on("error", (err) => {
+      this.processExited = true;
+      this.rejectAllPending(`LSP spawn error: ${err.message}`);
+    });
     this.startReading();
     this.startStderrReading();
     await new Promise((resolve7) => setTimeout(resolve7, 100));
-    if (this.proc.exitCode !== null) {
+    if (this.procExitCode !== null) {
       const stderr = this.stderrBuffer.join(`
 `);
-      throw new Error(`LSP server exited immediately with code ${this.proc.exitCode}` + (stderr ? `
+      throw new Error(`LSP server exited immediately with code ${this.procExitCode}` + (stderr ? `
 stderr: ${stderr}` : ""));
     }
   }
   startReading() {
-    if (!this.proc)
+    if (!this.proc?.stdout)
       return;
-    const reader = this.proc.stdout.getReader();
-    const read = async () => {
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) {
-            this.processExited = true;
-            this.rejectAllPending("LSP server stdout closed");
-            break;
-          }
-          const newBuf = new Uint8Array(this.buffer.length + value.length);
-          newBuf.set(this.buffer);
-          newBuf.set(value, this.buffer.length);
-          this.buffer = newBuf;
-          this.processBuffer();
-        }
-      } catch (err) {
-        this.processExited = true;
-        this.rejectAllPending(`LSP stdout read error: ${err}`);
-      }
-    };
-    read();
+    this.proc.stdout.on("data", (chunk) => {
+      const value = new Uint8Array(chunk);
+      const newBuf = new Uint8Array(this.buffer.length + value.length);
+      newBuf.set(this.buffer);
+      newBuf.set(value, this.buffer.length);
+      this.buffer = newBuf;
+      this.processBuffer();
+    });
+    this.proc.stdout.on("close", () => {
+      this.processExited = true;
+      this.rejectAllPending("LSP server stdout closed");
+    });
+    this.proc.stdout.on("error", (err) => {
+      this.processExited = true;
+      this.rejectAllPending(`LSP stdout read error: ${err}`);
+    });
   }
   startStderrReading() {
-    if (!this.proc)
+    if (!this.proc?.stderr)
       return;
-    const reader = this.proc.stderr.getReader();
-    const read = async () => {
-      const decoder = new TextDecoder;
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done)
-            break;
-          const text = decoder.decode(value);
-          this.stderrBuffer.push(text);
-          if (this.stderrBuffer.length > 100) {
-            this.stderrBuffer.shift();
-          }
-        }
-      } catch {}
-    };
-    read();
+    this.proc.stderr.on("data", (chunk) => {
+      const text = chunk.toString();
+      this.stderrBuffer.push(text);
+      if (this.stderrBuffer.length > 100) {
+        this.stderrBuffer.shift();
+      }
+    });
   }
   rejectAllPending(reason) {
     for (const [id, handler] of this.pending) {
@@ -28686,10 +28704,10 @@ stderr: ${stderr}` : ""));
   send(method, params) {
     if (!this.proc)
       throw new Error("LSP client not started");
-    if (this.processExited || this.proc.exitCode !== null) {
+    if (this.processExited || this.procExitCode !== null) {
       const stderr = this.stderrBuffer.slice(-10).join(`
 `);
-      throw new Error(`LSP server already exited (code: ${this.proc.exitCode})` + (stderr ? `
+      throw new Error(`LSP server already exited (code: ${this.procExitCode})` + (stderr ? `
 stderr: ${stderr}` : ""));
     }
     const id = ++this.requestIdCounter;
@@ -28697,7 +28715,7 @@ stderr: ${stderr}` : ""));
     const header = `Content-Length: ${Buffer.byteLength(msg)}\r
 \r
 `;
-    this.proc.stdin.write(header + msg);
+    this.proc.stdin?.write(header + msg);
     return new Promise((resolve7, reject) => {
       this.pending.set(id, { resolve: resolve7, reject });
       setTimeout(() => {
@@ -28712,9 +28730,9 @@ recent stderr: ${stderr}` : "")));
     });
   }
   notify(method, params) {
-    if (!this.proc)
+    if (!this.proc?.stdin)
       return;
-    if (this.processExited || this.proc.exitCode !== null)
+    if (this.processExited || this.procExitCode !== null)
       return;
     const msg = JSON.stringify({ jsonrpc: "2.0", method, params });
     this.proc.stdin.write(`Content-Length: ${Buffer.byteLength(msg)}\r
@@ -28722,9 +28740,9 @@ recent stderr: ${stderr}` : "")));
 ${msg}`);
   }
   respond(id, result) {
-    if (!this.proc)
+    if (!this.proc?.stdin)
       return;
-    if (this.processExited || this.proc.exitCode !== null)
+    if (this.processExited || this.procExitCode !== null)
       return;
     const msg = JSON.stringify({ jsonrpc: "2.0", id, result });
     this.proc.stdin.write(`Content-Length: ${Buffer.byteLength(msg)}\r
@@ -28910,7 +28928,7 @@ ${msg}`);
     return this.send("codeAction/resolve", codeAction);
   }
   isAlive() {
-    return this.proc !== null && !this.processExited && this.proc.exitCode === null;
+    return this.proc !== null && !this.processExited && this.procExitCode === null;
   }
   async stop() {
     try {
@@ -41902,7 +41920,6 @@ import { dirname as dirname11, join as join52 } from "path";
 import { existsSync as existsSync44, statSync as statSync4 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
-var {spawn: spawn6 } = globalThis.Bun;
 import { existsSync as existsSync43, mkdirSync as mkdirSync12, chmodSync as chmodSync2, unlinkSync as unlinkSync10 } from "fs";
 import { join as join51 } from "path";
 import { homedir as homedir16 } from "os";
@@ -41945,16 +41962,15 @@ function getCachedBinaryPath2() {
   return existsSync43(binaryPath) ? binaryPath : null;
 }
 async function extractZip2(archivePath, destDir) {
-  const proc = process.platform === "win32" ? spawn6([
+  const command = process.platform === "win32" ? [
     "powershell",
     "-command",
     `Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`
-  ], { stdout: "pipe", stderr: "pipe" }) : spawn6(["unzip", "-o", archivePath, "-d", destDir], { stdout: "pipe", stderr: "pipe" });
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    const stderr = await new Response(proc.stderr).text();
+  ] : ["unzip", "-o", archivePath, "-d", destDir];
+  const result = await spawnAsync(command);
+  if (result.exitCode !== 0) {
     const toolHint = process.platform === "win32" ? "Ensure PowerShell is available on your system." : "Please install 'unzip' (e.g., apt install unzip, brew install unzip).";
-    throw new Error(`zip extraction failed (exit ${exitCode}): ${stderr}
+    throw new Error(`zip extraction failed (exit ${result.exitCode}): ${result.stderr}
 
 ${toolHint}`);
   }
@@ -41986,7 +42002,7 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
     }
     const archivePath = join51(cacheDir, assetName);
     const arrayBuffer = await response2.arrayBuffer();
-    await Bun.write(archivePath, arrayBuffer);
+    await writeFileSafe(archivePath, arrayBuffer);
     await extractZip2(archivePath, cacheDir);
     if (existsSync43(archivePath)) {
       unlinkSync10(archivePath);
@@ -42117,7 +42133,6 @@ var DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024;
 var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/cli.ts
-var {spawn: spawn7 } = globalThis.Bun;
 import { existsSync as existsSync45 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
@@ -42171,27 +42186,17 @@ async function runSg(options) {
     }
   }
   const timeout = DEFAULT_TIMEOUT_MS;
-  const proc = spawn7([cliPath, ...args], {
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const timeoutPromise = new Promise((_3, reject) => {
-    const id = setTimeout(() => {
-      proc.kill();
-      reject(new Error(`Search timeout after ${timeout}ms`));
-    }, timeout);
-    proc.exited.then(() => clearTimeout(id));
-  });
   let stdout;
   let stderr;
   let exitCode;
   try {
-    stdout = await Promise.race([new Response(proc.stdout).text(), timeoutPromise]);
-    stderr = await new Response(proc.stderr).text();
-    exitCode = await proc.exited;
+    const result = await spawnAsync([cliPath, ...args], { timeout });
+    stdout = result.stdout;
+    stderr = result.stderr;
+    exitCode = result.exitCode;
   } catch (e2) {
     const error45 = e2;
-    if (error45.message?.includes("timeout")) {
+    if (error45.message?.includes("Timeout")) {
       return {
         matches: [],
         totalMatches: 0,
@@ -42424,9 +42429,6 @@ var ast_grep_replace = tool({
     }
   }
 });
-// src/tools/grep/cli.ts
-var {spawn: spawn9 } = globalThis.Bun;
-
 // src/tools/grep/constants.ts
 import { existsSync as existsSync47 } from "fs";
 import { join as join54, dirname as dirname12 } from "path";
@@ -42435,7 +42437,6 @@ import { spawnSync } from "child_process";
 // src/tools/grep/downloader.ts
 import { existsSync as existsSync46, mkdirSync as mkdirSync13, chmodSync as chmodSync3, unlinkSync as unlinkSync11, readdirSync as readdirSync15 } from "fs";
 import { join as join53 } from "path";
-var {spawn: spawn8 } = globalThis.Bun;
 function findFileRecursive(dir, filename) {
   try {
     const entries = readdirSync15(dir, { withFileTypes: true, recursive: true });
@@ -42474,7 +42475,7 @@ async function downloadFile(url2, destPath) {
     throw new Error(`Failed to download: ${response2.status} ${response2.statusText}`);
   }
   const buffer = await response2.arrayBuffer();
-  await Bun.write(destPath, buffer);
+  await writeFileSafe(destPath, buffer);
 }
 async function extractTarGz2(archivePath, destDir) {
   const platformKey = getPlatformKey();
@@ -42484,21 +42485,14 @@ async function extractTarGz2(archivePath, destDir) {
   } else if (platformKey.endsWith("-linux")) {
     args.push("--wildcards", "*/rg");
   }
-  const proc = spawn8(args, {
-    cwd: destDir,
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    const stderr = await new Response(proc.stderr).text();
-    throw new Error(`Failed to extract tar.gz: ${stderr}`);
+  const result = await spawnAsync(args, { cwd: destDir });
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to extract tar.gz: ${result.stderr}`);
   }
 }
 async function extractZipWindows(archivePath, destDir) {
-  const proc = spawn8(["powershell", "-Command", `Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`], { stdout: "pipe", stderr: "pipe" });
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
+  const result = await spawnAsync(["powershell", "-Command", `Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`]);
+  if (result.exitCode !== 0) {
     throw new Error("Failed to extract zip with PowerShell");
   }
   const foundPath = findFileRecursive(destDir, "rg.exe");
@@ -42511,12 +42505,8 @@ async function extractZipWindows(archivePath, destDir) {
   }
 }
 async function extractZipUnix(archivePath, destDir) {
-  const proc = spawn8(["unzip", "-o", archivePath, "-d", destDir], {
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
+  const result = await spawnAsync(["unzip", "-o", archivePath, "-d", destDir]);
+  if (result.exitCode !== 0) {
     throw new Error("Failed to extract zip");
   }
   const foundPath = findFileRecursive(destDir, "rg");
@@ -42768,21 +42758,9 @@ async function runRg(options) {
   }
   const paths = options.paths?.length ? options.paths : ["."];
   args.push(...paths);
-  const proc = spawn9([cli.path, ...args], {
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const timeoutPromise = new Promise((_3, reject) => {
-    const id = setTimeout(() => {
-      proc.kill();
-      reject(new Error(`Search timeout after ${timeout}ms`));
-    }, timeout);
-    proc.exited.then(() => clearTimeout(id));
-  });
   try {
-    const stdout = await Promise.race([new Response(proc.stdout).text(), timeoutPromise]);
-    const stderr = await new Response(proc.stderr).text();
-    const exitCode = await proc.exited;
+    const result = await spawnAsync([cli.path, ...args], { timeout });
+    const { stdout, stderr, exitCode } = result;
     const truncated = stdout.length >= DEFAULT_MAX_OUTPUT_BYTES2;
     const outputToProcess = truncated ? stdout.substring(0, DEFAULT_MAX_OUTPUT_BYTES2) : stdout;
     if (exitCode > 1 && stderr.trim()) {
@@ -42869,9 +42847,6 @@ var grep = tool({
   }
 });
 
-// src/tools/glob/cli.ts
-var {spawn: spawn10 } = globalThis.Bun;
-
 // src/tools/glob/constants.ts
 var DEFAULT_TIMEOUT_MS3 = 60000;
 var DEFAULT_LIMIT = 100;
@@ -42952,22 +42927,9 @@ async function runRgFiles(options, resolvedCli) {
     cwd = paths[0] || ".";
     command = [cli.path, ...args];
   }
-  const proc = spawn10(command, {
-    stdout: "pipe",
-    stderr: "pipe",
-    cwd
-  });
-  const timeoutPromise = new Promise((_3, reject) => {
-    const id = setTimeout(() => {
-      proc.kill();
-      reject(new Error(`Glob search timeout after ${timeout}ms`));
-    }, timeout);
-    proc.exited.then(() => clearTimeout(id));
-  });
   try {
-    const stdout = await Promise.race([new Response(proc.stdout).text(), timeoutPromise]);
-    const stderr = await new Response(proc.stderr).text();
-    const exitCode = await proc.exited;
+    const result = await spawnAsync(command, { cwd, timeout });
+    const { stdout, stderr, exitCode } = result;
     if (exitCode > 1 && stderr.trim()) {
       return {
         files: [],
@@ -43822,6 +43784,9 @@ var session_info = tool({
     }
   }
 });
+// src/tools/interactive-bash/tools.ts
+import { spawn as spawn4 } from "child_process";
+
 // src/tools/interactive-bash/constants.ts
 var DEFAULT_TIMEOUT_MS4 = 60000;
 var BLOCKED_TMUX_SUBCOMMANDS = [
@@ -43841,33 +43806,23 @@ For: server processes, long-running tasks, background jobs, interactive CLI tool
 Blocked (use bash instead): capture-pane, save-buffer, show-buffer, pipe-pane.`;
 
 // src/tools/interactive-bash/utils.ts
-var {spawn: spawn11 } = globalThis.Bun;
 var tmuxPath = null;
 var initPromise3 = null;
 async function findTmuxPath() {
   const isWindows2 = process.platform === "win32";
   const cmd = isWindows2 ? "where" : "which";
   try {
-    const proc = spawn11([cmd, "tmux"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
+    const result = await spawnAsync([cmd, "tmux"]);
+    if (result.exitCode !== 0) {
       return null;
     }
-    const stdout = await new Response(proc.stdout).text();
-    const path9 = stdout.trim().split(`
+    const path9 = result.stdout.trim().split(`
 `)[0];
     if (!path9) {
       return null;
     }
-    const verifyProc = spawn11([path9, "-V"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const verifyExitCode = await verifyProc.exited;
-    if (verifyExitCode !== 0) {
+    const verifyResult = await spawnAsync([path9, "-V"]);
+    if (verifyResult.exitCode !== 0) {
       return null;
     }
     return path9;
@@ -43952,30 +43907,40 @@ var interactive_bash = tool({
       if (BLOCKED_TMUX_SUBCOMMANDS.includes(subcommand)) {
         return `Error: '${parts[0]}' is blocked. Use bash tool instead for capturing/printing terminal output.`;
       }
-      const proc = Bun.spawn([tmuxPath2, ...parts], {
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const timeoutPromise = new Promise((_3, reject) => {
-        const id = setTimeout(() => {
+      const result = await new Promise((resolve8, reject) => {
+        const proc = spawn4(tmuxPath2, parts, {
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        let killed = false;
+        const timeout = setTimeout(() => {
+          killed = true;
           proc.kill();
           reject(new Error(`Timeout after ${DEFAULT_TIMEOUT_MS4}ms`));
         }, DEFAULT_TIMEOUT_MS4);
-        proc.exited.then(() => clearTimeout(id));
+        proc.stdout?.on("data", (data) => {
+          stdout += data.toString();
+        });
+        proc.stderr?.on("data", (data) => {
+          stderr += data.toString();
+        });
+        proc.on("close", (code) => {
+          clearTimeout(timeout);
+          if (!killed) {
+            resolve8({ stdout, stderr, exitCode: code ?? 1 });
+          }
+        });
+        proc.on("error", (err) => {
+          clearTimeout(timeout);
+          reject(err);
+        });
       });
-      const [stdout, stderr, exitCode] = await Promise.race([
-        Promise.all([
-          new Response(proc.stdout).text(),
-          new Response(proc.stderr).text(),
-          proc.exited
-        ]),
-        timeoutPromise
-      ]);
-      if (exitCode !== 0) {
-        const errorMsg = stderr.trim() || `Command failed with exit code ${exitCode}`;
+      if (result.exitCode !== 0) {
+        const errorMsg = result.stderr.trim() || `Command failed with exit code ${result.exitCode}`;
         return `Error: ${errorMsg}`;
       }
-      return stdout || "(no output)";
+      return result.stdout || "(no output)";
     } catch (e2) {
       return `Error: ${e2 instanceof Error ? e2.message : String(e2)}`;
     }

package/dist/shared/spawn.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Node.js-compatible spawn utilities
+ * Replaces Bun.spawn for Node.js runtime compatibility
+ */
+export interface SpawnResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export interface SpawnWithPipeOptions {
+    cwd?: string;
+    stdin?: string;
+    timeout?: number;
+}
+/**
+ * Spawn a process and collect stdout/stderr
+ */
+export declare function spawnAsync(command: string[], options?: SpawnWithPipeOptions): Promise<SpawnResult>;
+/**
+ * Simple spawn that returns exit code only (for fire-and-forget)
+ */
+export declare function spawnSimple(command: string[], options?: {
+    cwd?: string;
+    stdio?: "ignore" | "pipe";
+}): Promise<number>;
+/**
+ * Write file to disk (replacement for Bun.write)
+ */
+export declare function writeFileSafe(path: string, data: ArrayBuffer | Buffer | string): Promise<void>;

package/dist/tools/lsp/client.d.ts

@@ -21,6 +21,7 @@ export declare class LSPClient {
     private root;
     private server;
     private proc;
+    private procExitCode;
     private buffer;
     private pending;
     private requestIdCounter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newtype-profile",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "description": "AI Agent Collaboration System for Content Creation - Based on oh-my-opencode",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",