happy-imou-cloud 2.0.4 → 2.0.6

package/dist/{index-vNYxNqVZ.mjs → index-Dh8UTgm4.mjs}

@@ -1,6 +1,6 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
-import { l as logger, e as encodeBase64, c as configuration, h as buildAuthenticatedHeaders, S as SigningBootstrapRequiredError, j as SIGNING_BOOTSTRAP_REQUIRED_MESSAGE, k as encodeBase64Url, f as delay, m as buildClientHeaders, n as decodeBase64, H as HAPPY_CLOUD_DAEMON_PORT, p as packageJson, A as ApiClient, o as getLatestDaemonLog } from './api-CIHTNilH.mjs';
-import { writeCredentialsLegacy, writeCredentialsDataKey, readCredentials, readSettings, updateSettings, readDaemonState, clearDaemonState, acquireDaemonLock, writeDaemonState, releaseDaemonLock, validateProfileForAgent, getProfileEnvironmentVariables, clearCredentials, clearMachineId } from './persistence-sLEqV8vk.mjs';
+import { l as logger, e as encodeBase64, c as configuration, h as buildAuthenticatedHeaders, S as SigningBootstrapRequiredError, j as SIGNING_BOOTSTRAP_REQUIRED_MESSAGE, k as encodeBase64Url, f as delay, m as buildClientHeaders, n as decodeBase64, H as HAPPY_CLOUD_DAEMON_PORT, p as packageJson, A as ApiClient, o as getLatestDaemonLog } from './api-Emo3rSZH.mjs';
+import { writeCredentialsLegacy, writeCredentialsDataKey, readCredentials, readSettings, updateSettings, readDaemonState, clearDaemonState, acquireDaemonLock, writeDaemonState, releaseDaemonLock, validateProfileForAgent, getProfileEnvironmentVariables, clearCredentials, clearMachineId } from './persistence-Blm1hTQA.mjs';
 import { z } from 'zod';
 import fs from 'fs/promises';
 import os, { homedir } from 'os';
@@ -4906,6 +4906,205 @@ function handleThinkingUpdate(update, ctx) {
   return { handled: true };
 }
 
+function buildAcpSpawnSpec(params) {
+  return {
+    command: params.command,
+    args: (params.args ?? []).map((arg) => String(arg)),
+    options: {
+      cwd: params.cwd,
+      env: params.env,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: process.platform === "win32"
+    }
+  };
+}
+
+function createAcpFilteredStdoutReadable(params) {
+  const maxMultilineBytes = typeof params.maxMultilineBytes === "number" && Number.isFinite(params.maxMultilineBytes) && params.maxMultilineBytes > 0 ? Math.trunc(params.maxMultilineBytes) : 1e6;
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async start(controller) {
+      const reader = params.readable.getReader();
+      let buffer = "";
+      let multiline = null;
+      let controllerErrored = false;
+      const drop = (reason, line) => {
+        params.onDroppedLine?.({ reason, line });
+      };
+      const enqueueLine = (line) => {
+        if (!line.trim()) {
+          return;
+        }
+        const filtered = params.transport.filterStdoutLine?.(line);
+        if (filtered === void 0) {
+          controller.enqueue(encoder.encode(line + "\n"));
+          return;
+        }
+        if (filtered === null) {
+          drop("transport_filter_null", line);
+          return;
+        }
+        controller.enqueue(encoder.encode(filtered + "\n"));
+      };
+      const tryFlushMultiline = (candidate) => {
+        const trimmed = candidate.trim();
+        if (!trimmed) {
+          return false;
+        }
+        if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+          return false;
+        }
+        try {
+          const parsed = JSON.parse(trimmed);
+          if (typeof parsed !== "object" || parsed === null) {
+            return false;
+          }
+          enqueueLine(JSON.stringify(parsed));
+          return true;
+        } catch {
+          return false;
+        }
+      };
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) {
+            break;
+          }
+          if (!value) {
+            continue;
+          }
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (multiline) {
+              const nextBuf = multiline.buf.length > 0 ? `${multiline.buf}
+${line}` : line;
+              const nextBytes = multiline.bytes + line.length + 1;
+              if (nextBytes > maxMultilineBytes) {
+                drop("multiline_overflow", multiline.buf);
+                multiline = null;
+                enqueueLine(line);
+                continue;
+              }
+              multiline = { buf: nextBuf, bytes: nextBytes };
+              if (tryFlushMultiline(multiline.buf)) {
+                multiline = null;
+              }
+              continue;
+            }
+            const trimmed = line.trim();
+            if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+              try {
+                const parsed = JSON.parse(trimmed);
+                if (typeof parsed === "object" && parsed !== null) {
+                  enqueueLine(line);
+                  continue;
+                }
+              } catch {
+                multiline = { buf: line, bytes: line.length };
+                continue;
+              }
+            }
+            enqueueLine(line);
+          }
+        }
+        if (multiline) {
+          if (!tryFlushMultiline(multiline.buf)) {
+            drop("multiline_incomplete", multiline.buf);
+          }
+          multiline = null;
+        }
+        const trailing = buffer.trim();
+        if (trailing) {
+          drop("multiline_incomplete", buffer);
+        }
+      } catch (error) {
+        controllerErrored = true;
+        controller.error(error);
+      } finally {
+        reader.releaseLock();
+        if (!controllerErrored) {
+          controller.close();
+        }
+      }
+    }
+  });
+}
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveDescendantPids(rootPid) {
+  const processes = await psList();
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const proc of processes) {
+    if (typeof proc.pid !== "number" || typeof proc.ppid !== "number") {
+      continue;
+    }
+    const children = childrenByParent.get(proc.ppid) ?? [];
+    children.push(proc.pid);
+    childrenByParent.set(proc.ppid, children);
+  }
+  const descendants = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (pid) => {
+    for (const childPid of childrenByParent.get(pid) ?? []) {
+      if (seen.has(childPid)) {
+        continue;
+      }
+      seen.add(childPid);
+      visit(childPid);
+      descendants.push(childPid);
+    }
+  };
+  visit(rootPid);
+  return descendants;
+}
+function bestEffortKillPid(pid, signal) {
+  try {
+    process.kill(pid, signal);
+  } catch {
+  }
+}
+async function waitForAllGone(pids, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (pids.every((pid) => !isAlive(pid))) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+}
+async function killProcessTree(proc, options) {
+  const pid = proc.pid;
+  if (!pid) {
+    return;
+  }
+  const graceMs = Math.max(1, options?.graceMs);
+  const descendants = await resolveDescendantPids(pid).catch(() => []);
+  const allPids = [...descendants, pid];
+  for (const targetPid of allPids) {
+    bestEffortKillPid(targetPid, "SIGTERM");
+  }
+  await waitForAllGone(allPids, graceMs);
+  const remaining = allPids.filter((targetPid) => isAlive(targetPid));
+  if (remaining.length === 0) {
+    return;
+  }
+  for (const targetPid of remaining) {
+    bestEffortKillPid(targetPid, "SIGKILL");
+  }
+  await waitForAllGone(remaining, Math.min(250, graceMs));
+}
+
 const RETRY_CONFIG = {
   /** Maximum number of retry attempts for init/newSession */
   maxAttempts: 3,
@@ -5042,15 +5241,17 @@ async function withRetry(operation, options) {
       return await operation();
     } catch (error) {
       lastError = normalizeAcpError(error);
-      if (attempt < options.maxAttempts) {
-        const delayMs = Math.min(
-          options.baseDelayMs * Math.pow(2, attempt - 1),
-          options.maxDelayMs
-        );
-        logger.debug(`[AcpBackend] ${options.operationName} failed (attempt ${attempt}/${options.maxAttempts}): ${lastError.message}. Retrying in ${delayMs}ms...`);
-        options.onRetry?.(attempt, lastError);
-        await delay(delayMs);
+      const retryable = options.shouldRetry?.(lastError) ?? true;
+      if (!retryable || attempt >= options.maxAttempts) {
+        throw lastError;
       }
+      const delayMs = Math.min(
+        options.baseDelayMs * Math.pow(2, attempt - 1),
+        options.maxDelayMs
+      );
+      logger.debug(`[AcpBackend] ${options.operationName} failed (attempt ${attempt}/${options.maxAttempts}): ${lastError.message}. Retrying in ${delayMs}ms...`);
+      options.onRetry?.(attempt, lastError);
+      await delay(delayMs);
     }
   }
   throw lastError;
@@ -5103,6 +5304,77 @@ function enrichAcpError(error, stderrExcerpt) {
   }
   return normalized;
 }
+class AcpProcessStartupError extends Error {
+  constructor(message, exitCode, signal) {
+    super(message);
+    this.exitCode = exitCode;
+    this.signal = signal;
+    this.name = "AcpProcessStartupError";
+  }
+}
+function createProcessStartupError(agentName, operationName, code, signal) {
+  if (code !== null) {
+    return new AcpProcessStartupError(
+      `${agentName} exited with code ${code} during ${operationName}`,
+      code,
+      signal
+    );
+  }
+  if (signal) {
+    return new AcpProcessStartupError(
+      `${agentName} exited due to signal ${signal} during ${operationName}`,
+      code,
+      signal
+    );
+  }
+  return new AcpProcessStartupError(
+    `${agentName} exited unexpectedly during ${operationName}`,
+    code,
+    signal
+  );
+}
+async function raceWithProcessExit(childProcess, operation, options) {
+  if (childProcess.exitCode !== null) {
+    throw createProcessStartupError(
+      options.agentName,
+      options.operationName,
+      childProcess.exitCode,
+      childProcess.signalCode ?? null
+    );
+  }
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => {
+      childProcess.off("error", handleError);
+      childProcess.off("exit", handleExit);
+    };
+    const settleResolve = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      resolve(value);
+    };
+    const settleReject = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      reject(normalizeAcpError(error));
+    };
+    const handleError = (error) => {
+      settleReject(error);
+    };
+    const handleExit = (code, signal) => {
+      settleReject(createProcessStartupError(options.agentName, options.operationName, code, signal));
+    };
+    childProcess.once("error", handleError);
+    childProcess.once("exit", handleExit);
+    operation.then(settleResolve, settleReject);
+  });
+}
 class AcpBackend {
   constructor(options) {
     this.options = options;
@@ -5221,24 +5493,13 @@ class AcpBackend {
     try {
       logger.debug(`[AcpBackend] Starting session: ${sessionId}`);
       this.recentStderrLines = [];
-      const args = this.options.args || [];
-      if (process.platform === "win32") {
-        const fullCommand = [this.options.command, ...args].join(" ");
-        this.process = spawn$2("cmd.exe", ["/c", fullCommand], {
-          cwd: this.options.cwd,
-          env: { ...process.env, ...this.options.env },
-          stdio: ["pipe", "pipe", "pipe"],
-          windowsHide: true
-        });
-      } else {
-        this.process = spawn$2(this.options.command, args, {
-          cwd: this.options.cwd,
-          env: { ...process.env, ...this.options.env },
-          // Use 'pipe' for all stdio to capture output without printing to console
-          // stdout and stderr will be handled by our event listeners
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-      }
+      const spawnSpec = buildAcpSpawnSpec({
+        command: this.options.command,
+        args: this.options.args ?? [],
+        cwd: this.options.cwd,
+        env: { ...process.env, ...this.options.env }
+      });
+      this.process = spawn$1(spawnSpec.command, spawnSpec.args, spawnSpec.options);
       if (this.process.stderr) {
       }
       if (!this.process.stdin || !this.process.stdout || !this.process.stderr) {
@@ -5286,57 +5547,20 @@ class AcpBackend {
       );
       const writable = streams.writable;
       const readable = streams.readable;
-      const transport = this.transport;
-      const filteredReadable = new ReadableStream({
-        async start(controller) {
-          const reader = readable.getReader();
-          const decoder = new TextDecoder();
-          const encoder = new TextEncoder();
-          let buffer = "";
-          let filteredCount = 0;
-          try {
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done) {
-                if (buffer.trim()) {
-                  const filtered = transport.filterStdoutLine?.(buffer);
-                  if (filtered === void 0) {
-                    controller.enqueue(encoder.encode(buffer));
-                  } else if (filtered !== null) {
-                    controller.enqueue(encoder.encode(filtered));
-                  } else {
-                    filteredCount++;
-                  }
-                }
-                if (filteredCount > 0) {
-                  logger.debug(`[AcpBackend] Filtered out ${filteredCount} non-JSON lines from ${transport.agentName} stdout`);
-                }
-                controller.close();
-                break;
-              }
-              buffer += decoder.decode(value, { stream: true });
-              const lines = buffer.split("\n");
-              buffer = lines.pop() || "";
-              for (const line of lines) {
-                if (!line.trim()) continue;
-                const filtered = transport.filterStdoutLine?.(line);
-                if (filtered === void 0) {
-                  controller.enqueue(encoder.encode(line + "\n"));
-                } else if (filtered !== null) {
-                  controller.enqueue(encoder.encode(filtered + "\n"));
-                } else {
-                  filteredCount++;
-                }
-              }
-            }
-          } catch (error) {
-            logger.debug(`[AcpBackend] Error filtering stdout stream:`, error);
-            controller.error(error);
-          } finally {
-            reader.releaseLock();
-          }
+      const droppedStdoutLines = [];
+      const filteredReadable = createAcpFilteredStdoutReadable({
+        readable,
+        transport: this.transport,
+        onDroppedLine: (entry) => {
+          droppedStdoutLines.push(entry);
         }
       });
+      if (droppedStdoutLines.length > 0) {
+        logger.debug(
+          `[AcpBackend] Filtered out ${droppedStdoutLines.length} stdout lines from ${this.transport.agentName}`,
+          droppedStdoutLines.slice(0, 5)
+        );
+      }
       const stream = ndJsonStream(writable, filteredReadable);
       const client = {
         sessionUpdate: async (params) => {
@@ -5503,20 +5727,27 @@ class AcpBackend {
         async () => {
           let timeoutHandle = null;
           try {
-            const result = await Promise.race([
-              this.connection.initialize(initRequest).then((res) => {
-                if (timeoutHandle) {
-                  clearTimeout(timeoutHandle);
-                  timeoutHandle = null;
-                }
-                return res;
-              }),
-              new Promise((_, reject) => {
-                timeoutHandle = setTimeout(() => {
-                  reject(new Error(`Initialize timeout after ${initTimeout}ms - ${this.transport.agentName} did not respond`));
-                }, initTimeout);
-              })
-            ]);
+            const result = await raceWithProcessExit(
+              this.process,
+              Promise.race([
+                this.connection.initialize(initRequest).then((res) => {
+                  if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                    timeoutHandle = null;
+                  }
+                  return res;
+                }),
+                new Promise((_, reject) => {
+                  timeoutHandle = setTimeout(() => {
+                    reject(new Error(`Initialize timeout after ${initTimeout}ms - ${this.transport.agentName} did not respond`));
+                  }, initTimeout);
+                })
+              ]),
+              {
+                agentName: this.transport.agentName,
+                operationName: "initialize"
+              }
+            );
             return result;
           } finally {
             if (timeoutHandle) {
@@ -5528,7 +5759,8 @@ class AcpBackend {
           operationName: "Initialize",
           maxAttempts: RETRY_CONFIG.maxAttempts,
           baseDelayMs: RETRY_CONFIG.baseDelayMs,
-          maxDelayMs: RETRY_CONFIG.maxDelayMs
+          maxDelayMs: RETRY_CONFIG.maxDelayMs,
+          shouldRetry: (error) => !(error instanceof AcpProcessStartupError)
         }
       );
       logger.debug(`[AcpBackend] Initialize completed`);
@@ -5547,20 +5779,27 @@ class AcpBackend {
         async () => {
           let timeoutHandle = null;
           try {
-            const result = await Promise.race([
-              this.connection.newSession(newSessionRequest).then((res) => {
-                if (timeoutHandle) {
-                  clearTimeout(timeoutHandle);
-                  timeoutHandle = null;
-                }
-                return res;
-              }),
-              new Promise((_, reject) => {
-                timeoutHandle = setTimeout(() => {
-                  reject(new Error(`New session timeout after ${initTimeout}ms - ${this.transport.agentName} did not respond`));
-                }, initTimeout);
-              })
-            ]);
+            const result = await raceWithProcessExit(
+              this.process,
+              Promise.race([
+                this.connection.newSession(newSessionRequest).then((res) => {
+                  if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                    timeoutHandle = null;
+                  }
+                  return res;
+                }),
+                new Promise((_, reject) => {
+                  timeoutHandle = setTimeout(() => {
+                    reject(new Error(`New session timeout after ${initTimeout}ms - ${this.transport.agentName} did not respond`));
+                  }, initTimeout);
+                })
+              ]),
+              {
+                agentName: this.transport.agentName,
+                operationName: "new session"
+              }
+            );
             return result;
           } finally {
             if (timeoutHandle) {
@@ -5572,7 +5811,8 @@ class AcpBackend {
           operationName: "NewSession",
           maxAttempts: RETRY_CONFIG.maxAttempts,
           baseDelayMs: RETRY_CONFIG.baseDelayMs,
-          maxDelayMs: RETRY_CONFIG.maxDelayMs
+          maxDelayMs: RETRY_CONFIG.maxDelayMs,
+          shouldRetry: (error) => !(error instanceof AcpProcessStartupError)
         }
       );
       this.acpSessionId = sessionResponse.sessionId;
@@ -5848,21 +6088,13 @@ class AcpBackend {
       }
     }
     if (this.process) {
-      this.process.kill("SIGTERM");
-      await new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-          if (this.process) {
-            logger.debug("[AcpBackend] Force killing process");
-            this.process.kill("SIGKILL");
-          }
-          resolve();
-        }, 1e3);
-        this.process?.once("exit", () => {
-          clearTimeout(timeout);
-          resolve();
-        });
-      });
-      this.process = null;
+      try {
+        await killProcessTree(this.process, { graceMs: 1e3 });
+      } catch (error) {
+        logger.debug("[AcpBackend] Failed to kill ACP process tree:", error);
+      } finally {
+        this.process = null;
+      }
     }
     this.clearIdleTimeoutState();
     this.listeners = [];
@@ -6103,6 +6335,7 @@ function registerGeminiAgent() {
   logger.debug("[Gemini] Registered with agent registry");
 }
 
+const DEFAULT_CODEX_ACP_NPX_PACKAGE = "@zed-industries/codex-acp@0.9.5";
 function readFirstEnv(...names) {
   for (const name of names) {
     const raw = process.env[name];
@@ -6157,6 +6390,10 @@ function readCodexAcpNpxMode() {
   }
   return "auto";
 }
+function readCodexAcpNpxPackage() {
+  const configured = readFirstEnv("HAPPY_CODEX_ACP_PACKAGE", "HAPPIER_CODEX_ACP_PACKAGE");
+  return configured || DEFAULT_CODEX_ACP_NPX_PACKAGE;
+}
 function isBinOnPath(baseName) {
   return resolveCommandOnPath(baseName) !== null;
 }
@@ -6222,7 +6459,7 @@ function resolveCodexAcpSpawn(options = {}) {
   }
   return {
     command: resolveNpxCommand(),
-    args: ["--prefer-offline", "-y", "@zed-industries/codex-acp", ...directArgs]
+    args: ["--prefer-offline", "-y", readCodexAcpNpxPackage(), ...directArgs]
   };
 }
 function validateCodexAcpSpawn(options = {}) {
@@ -6509,12 +6746,12 @@ async function ensureUnifiedDaemonStarted() {
 async function executeUnifiedProvider(opts) {
   const credentials = await ensureUnifiedRuntimePrerequisites(opts.credentials);
   if (opts.provider === "claude") {
-    const { runClaude } = await import('./runClaude-Dl9nIRIg.mjs');
+    const { runClaude } = await import('./runClaude-CwA5UCO-.mjs');
     await runClaude(credentials, opts.claudeOptions ?? {});
     return;
   }
   if (opts.provider === "codex") {
-    const { runCodex } = await import('./runCodex-DgKKw3IU.mjs');
+    const { runCodex } = await import('./runCodex-DTPmqCyS.mjs');
     await runCodex({
       credentials,
       startedBy: opts.startedBy,
@@ -6524,7 +6761,7 @@ async function executeUnifiedProvider(opts) {
     return;
   }
   if (opts.provider === "gemini") {
-    const { runGemini } = await import('./runGemini-CM1v3I24.mjs');
+    const { runGemini } = await import('./runGemini-DDSR8BtO.mjs');
     await runGemini({
       credentials,
       startedBy: opts.startedBy
@@ -6566,7 +6803,7 @@ function shouldRunMainClaudeFlow(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await import('./command-BERqmFB0.mjs');
+      const { renderRuntimeProviders } = await import('./command-D8Zz6B4t.mjs');
       console.log(renderRuntimeProviders());
       return;
     }
@@ -6744,8 +6981,8 @@ function shouldRunMainClaudeFlow(opts) {
       const projectId = args[3];
       try {
         const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return config; });
-        const { readCredentials: readCredentials2 } = await import('./persistence-sLEqV8vk.mjs');
-        const { ApiClient: ApiClient2 } = await import('./api-CIHTNilH.mjs').then(function (n) { return n.q; });
+        const { readCredentials: readCredentials2 } = await import('./persistence-Blm1hTQA.mjs');
+        const { ApiClient: ApiClient2 } = await import('./api-Emo3rSZH.mjs').then(function (n) { return n.q; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();

package/dist/index.cjs

@@ -1,14 +1,16 @@
 'use strict';
 
 require('chalk');
-require('./api-CyJG1mr6.cjs');
-require('./persistence-BeFVx6kI.cjs');
+require('./api-DccDghmF.cjs');
+require('./persistence-BrTyBuT7.cjs');
 require('zod');
-require('./index-1zlH6s7a.cjs');
+require('./index-Buq7nurH.cjs');
 require('node:child_process');
 require('node:fs');
+require('cross-spawn');
 require('@agentclientprotocol/sdk');
 require('node:crypto');
+require('ps-list');
 require('fs');
 require('path');
 require('os');
@@ -31,8 +33,6 @@ require('open');
 require('react');
 require('ink');
 require('url');
-require('ps-list');
-require('cross-spawn');
 require('fastify');
 require('fastify-type-provider-zod');
 require('node:readline');

package/dist/index.mjs

@@ -1,12 +1,14 @@
 import 'chalk';
-import './api-CIHTNilH.mjs';
-import './persistence-sLEqV8vk.mjs';
+import './api-Emo3rSZH.mjs';
+import './persistence-Blm1hTQA.mjs';
 import 'zod';
-import './index-vNYxNqVZ.mjs';
+import './index-Dh8UTgm4.mjs';
 import 'node:child_process';
 import 'node:fs';
+import 'cross-spawn';
 import '@agentclientprotocol/sdk';
 import 'node:crypto';
+import 'ps-list';
 import 'fs';
 import 'path';
 import 'os';
@@ -29,8 +31,6 @@ import 'open';
 import 'react';
 import 'ink';
 import 'url';
-import 'ps-list';
-import 'cross-spawn';
 import 'fastify';
 import 'fastify-type-provider-zod';
 import 'node:readline';

package/dist/lib.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var api = require('./api-CyJG1mr6.cjs');
+var api = require('./api-DccDghmF.cjs');
 var types = require('./types-DVk3crez.cjs');
 require('axios');
 require('chalk');