@shogo-ai/cli 1.4.1

package/dist/index.cjs

@@ -0,0 +1,688 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AGENT_NAME_PATTERN: () => AGENT_NAME_PATTERN,
+  NodeMissingError: () => NodeMissingError,
+  PlatformPackageManager: () => PlatformPackageManager,
+  _resetUnixNodeCache: () => _resetUnixNodeCache,
+  buildSyncPayload: () => buildSyncPayload,
+  isNodeAvailableOnUnix: () => isNodeAvailableOnUnix,
+  isNodeAvailableOnWindows: () => isNodeAvailableOnWindows,
+  normalizeToolEntry: () => normalizeToolEntry,
+  pkg: () => pkg,
+  resolveBinInvocation: () => resolveBinInvocation,
+  runDeploy: () => runDeploy,
+  validateManifest: () => validateManifest
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/deploy.ts
+var AGENT_NAME_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
+var KNOWN_KEYS = /* @__PURE__ */ new Set([
+  "systemPrompt",
+  "tools",
+  "characterName",
+  "displayName",
+  "voiceId",
+  "firstMessage",
+  "model"
+]);
+function validateManifest(raw) {
+  const issues = [];
+  if (raw == null) return { agents: {}, issues };
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    issues.push({
+      path: "agents",
+      message: "`agents` must be an object keyed by agent name"
+    });
+    return { agents: {}, issues };
+  }
+  const agents = {};
+  for (const [name, value] of Object.entries(raw)) {
+    if (!AGENT_NAME_PATTERN.test(name)) {
+      issues.push({
+        path: `agents.${name}`,
+        message: `agent name must match ${AGENT_NAME_PATTERN}`
+      });
+      continue;
+    }
+    if (value == null || typeof value !== "object" || Array.isArray(value)) {
+      issues.push({
+        path: `agents.${name}`,
+        message: "value must be an object"
+      });
+      continue;
+    }
+    const entry = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (!KNOWN_KEYS.has(k)) {
+        issues.push({
+          path: `agents.${name}.${k}`,
+          message: `unknown field; supported: ${[...KNOWN_KEYS].join(", ")}`
+        });
+        continue;
+      }
+      if (k === "tools") {
+        if (!Array.isArray(v)) {
+          issues.push({
+            path: `agents.${name}.tools`,
+            message: "must be an array of strings or { name, description?, inputSchema? } objects"
+          });
+          continue;
+        }
+        const tools = [];
+        const seenNames = /* @__PURE__ */ new Set();
+        let valid = true;
+        for (let i = 0; i < v.length; i++) {
+          const t = v[i];
+          if (typeof t === "string") {
+            if (t.length === 0) {
+              issues.push({
+                path: `agents.${name}.tools[${i}]`,
+                message: "tool name must be a non-empty string"
+              });
+              valid = false;
+              continue;
+            }
+            if (seenNames.has(t)) {
+              issues.push({
+                path: `agents.${name}.tools[${i}]`,
+                message: `duplicate tool name '${t}'`
+              });
+              valid = false;
+              continue;
+            }
+            seenNames.add(t);
+            tools.push(t);
+            continue;
+          }
+          if (t == null || typeof t !== "object" || Array.isArray(t)) {
+            issues.push({
+              path: `agents.${name}.tools[${i}]`,
+              message: "tools entries must be a string or { name, description?, inputSchema? }"
+            });
+            valid = false;
+            continue;
+          }
+          const obj = t;
+          if (typeof obj.name !== "string" || obj.name.length === 0) {
+            issues.push({
+              path: `agents.${name}.tools[${i}].name`,
+              message: "name is required and must be a non-empty string"
+            });
+            valid = false;
+            continue;
+          }
+          if (seenNames.has(obj.name)) {
+            issues.push({
+              path: `agents.${name}.tools[${i}]`,
+              message: `duplicate tool name '${obj.name}'`
+            });
+            valid = false;
+            continue;
+          }
+          if (obj.description !== void 0 && typeof obj.description !== "string") {
+            issues.push({
+              path: `agents.${name}.tools[${i}].description`,
+              message: "description must be a string"
+            });
+            valid = false;
+            continue;
+          }
+          if (obj.inputSchema !== void 0 && (obj.inputSchema === null || typeof obj.inputSchema !== "object" || Array.isArray(obj.inputSchema))) {
+            issues.push({
+              path: `agents.${name}.tools[${i}].inputSchema`,
+              message: "inputSchema must be a JSON Schema object"
+            });
+            valid = false;
+            continue;
+          }
+          seenNames.add(obj.name);
+          const descriptor = { name: obj.name };
+          if (typeof obj.description === "string") {
+            descriptor.description = obj.description;
+          }
+          if (obj.inputSchema !== void 0) {
+            descriptor.inputSchema = obj.inputSchema;
+          }
+          tools.push(descriptor);
+        }
+        if (valid) entry.tools = tools;
+        continue;
+      }
+      if (typeof v !== "string") {
+        issues.push({
+          path: `agents.${name}.${k}`,
+          message: "must be a string"
+        });
+        continue;
+      }
+      ;
+      entry[k] = v;
+    }
+    if (entry.voiceId && !entry.firstMessage) {
+      issues.push({
+        path: `agents.${name}.firstMessage`,
+        message: "voiceId is set; consider providing firstMessage so the agent has a greeting"
+      });
+    }
+    agents[name] = entry;
+  }
+  return { agents, issues };
+}
+function normalizeToolEntry(entry) {
+  if (typeof entry === "string") return { name: entry };
+  const out = { name: entry.name };
+  if (entry.description !== void 0) out.description = entry.description;
+  if (entry.inputSchema !== void 0) out.inputSchema = entry.inputSchema;
+  return out;
+}
+function buildSyncPayload(opts) {
+  const out = { agents: {}, prune: opts.prune, dryRun: opts.dryRun };
+  for (const [name, entry] of Object.entries(opts.manifest)) {
+    const a = {};
+    if (entry.systemPrompt !== void 0) a.systemPrompt = entry.systemPrompt;
+    if (entry.tools !== void 0) {
+      a.tools = entry.tools.map(normalizeToolEntry);
+    }
+    if (entry.characterName !== void 0) a.characterName = entry.characterName;
+    if (entry.displayName !== void 0) a.displayName = entry.displayName;
+    if (entry.voiceId !== void 0) a.voiceId = entry.voiceId;
+    if (entry.firstMessage !== void 0) a.firstMessage = entry.firstMessage;
+    if (entry.model !== void 0) a.model = entry.model;
+    out.agents[name] = a;
+  }
+  return out;
+}
+function resolveDeployHeaders(options) {
+  const headers = {
+    "content-type": "application/json"
+  };
+  const auth = options.auth ?? (options.shogoApiKey ? { kind: "apiKey", apiKey: options.shogoApiKey } : void 0);
+  if (!auth) {
+    throw new Error(
+      'runDeploy: missing auth \u2014 pass `auth: { kind: "apiKey", apiKey }` or `auth: { kind: "runtimeToken", token }`'
+    );
+  }
+  if (auth.kind === "apiKey") {
+    headers.authorization = `Bearer ${auth.apiKey}`;
+  } else {
+    headers["x-runtime-token"] = auth.token;
+  }
+  return headers;
+}
+async function runDeploy(options) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new Error("runDeploy: global fetch is unavailable; pass options.fetchImpl");
+  }
+  const url = `${options.apiUrl.replace(/\/+$/, "")}/api/projects/${encodeURIComponent(options.projectId)}/agents/sync`;
+  const payload = buildSyncPayload({
+    manifest: options.manifest,
+    prune: options.prune,
+    dryRun: options.dryRun
+  });
+  const res = await fetchImpl(url, {
+    method: "POST",
+    headers: resolveDeployHeaders(options),
+    body: JSON.stringify(payload)
+  });
+  let body = null;
+  try {
+    body = await res.json();
+  } catch {
+  }
+  return { status: res.status, body };
+}
+
+// src/pkg.ts
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var NodeMissingError = class extends Error {
+  constructor() {
+    super(
+      "Shogo Desktop on Windows requires Node.js 20+ to run project sandboxes. npm.cmd was not found on PATH and is not present at C:\\Program Files\\nodejs\\. Install Node.js from https://nodejs.org/ (LTS recommended), then restart Shogo."
+    );
+    this.code = "NODE_NOT_INSTALLED";
+    this.name = "NodeMissingError";
+  }
+};
+var WINDOWS_NODE_DIR = "C:\\Program Files\\nodejs";
+function isNodeAvailableOnWindows(pathEnv = process.env.PATH) {
+  if (process.platform !== "win32") return true;
+  if ((0, import_node_fs.existsSync)((0, import_node_path.join)(WINDOWS_NODE_DIR, "npm.cmd"))) return true;
+  if (!pathEnv) return false;
+  for (const dir of pathEnv.split(";")) {
+    if (dir && (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "npm.cmd"))) return true;
+  }
+  return false;
+}
+var _unixNodeAvailable = null;
+function isNodeAvailableOnUnix(pathEnv = process.env.PATH) {
+  if (process.platform === "win32") return false;
+  if (pathEnv === process.env.PATH && _unixNodeAvailable !== null) return _unixNodeAvailable;
+  let found = false;
+  if (pathEnv) {
+    for (const dir of pathEnv.split(":")) {
+      if (!dir) continue;
+      if ((0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "node"))) {
+        found = true;
+        break;
+      }
+    }
+  }
+  if (pathEnv === process.env.PATH) _unixNodeAvailable = found;
+  return found;
+}
+function _resetUnixNodeCache() {
+  _unixNodeAvailable = null;
+}
+function resolveBinInvocation(workspaceDir, binName) {
+  const binDir = (0, import_node_path.join)(workspaceDir, "node_modules", ".bin");
+  const isWindows = process.platform === "win32";
+  const candidates = isWindows ? [(0, import_node_path.join)(binDir, `${binName}.CMD`), (0, import_node_path.join)(binDir, `${binName}.cmd`), (0, import_node_path.join)(binDir, `${binName}.exe`)] : [(0, import_node_path.join)(binDir, binName)];
+  const shim = candidates.find((p) => (0, import_node_fs.existsSync)(p));
+  if (!shim) return null;
+  if (isWindows) return { cmd: shim, argsPrefix: [] };
+  if (isNodeAvailableOnUnix()) return { cmd: shim, argsPrefix: [] };
+  try {
+    const st = (0, import_node_fs.lstatSync)(shim);
+    if (!st.isSymbolicLink()) return { cmd: shim, argsPrefix: [] };
+    const target = (0, import_node_fs.readlinkSync)(shim);
+    const jsEntry = (0, import_node_path.isAbsolute)(target) ? target : (0, import_node_path.resolve)((0, import_node_path.dirname)(shim), target);
+    if (!(0, import_node_fs.existsSync)(jsEntry)) return { cmd: shim, argsPrefix: [] };
+    const bun = process.env.SHOGO_BUN_PATH || "bun";
+    return { cmd: bun, argsPrefix: [jsEntry] };
+  } catch {
+    return { cmd: shim, argsPrefix: [] };
+  }
+}
+var IS_WINDOWS = process.platform === "win32";
+var DEFAULT_INSTALL_TIMEOUT = parseInt(
+  process.env.SHOGO_INSTALL_TIMEOUT_MS || (IS_WINDOWS ? "300000" : "300000"),
+  10
+);
+var DEFAULT_EXEC_TIMEOUT = 6e4;
+var PlatformPackageManager = class {
+  constructor() {
+    this.isWindows = IS_WINDOWS;
+  }
+  /** Resolved path to the bun binary — prefers SHOGO_BUN_PATH (set by desktop app) over bare `bun`. */
+  get bunBinary() {
+    return process.env.SHOGO_BUN_PATH || "bun";
+  }
+  shellOpt() {
+    return IS_WINDOWS ? true : void 0;
+  }
+  spawnEnv(base) {
+    const source = base ?? process.env;
+    const env = {};
+    let pathValue = "";
+    for (const [k, v] of Object.entries(source)) {
+      if (v === void 0) continue;
+      if (IS_WINDOWS && k.toLowerCase() === "path") {
+        if (v) pathValue = v;
+        continue;
+      }
+      env[k] = v;
+    }
+    if (IS_WINDOWS) {
+      const nodePath = "C:\\Program Files\\nodejs";
+      env.PATH = pathValue.includes(nodePath) ? pathValue : `${nodePath};${pathValue}`;
+    }
+    return env;
+  }
+  // ---------------------------------------------------------------------------
+  // Install — synchronous
+  // ---------------------------------------------------------------------------
+  installSync(cwd, opts) {
+    const timeout = opts?.timeout ?? DEFAULT_INSTALL_TIMEOUT;
+    const stdio = opts?.stdio ?? "pipe";
+    const env = this.spawnEnv(opts?.env);
+    if (IS_WINDOWS) {
+      if (isNodeAvailableOnWindows(env.PATH)) {
+        try {
+          (0, import_node_child_process.execSync)("npm.cmd install --loglevel=error", {
+            cwd,
+            timeout,
+            stdio,
+            env,
+            shell: "cmd.exe"
+          });
+          return;
+        } catch (err) {
+          const wrapped = wrapWindowsNpmError(err);
+          if (!wrapped) throw err;
+        }
+      }
+      this.installSyncBunCopyfile(cwd, opts);
+      return;
+    }
+    const bun = this.bunBinary;
+    if (opts?.frozen) {
+      try {
+        (0, import_node_child_process.execSync)(`"${bun}" install --frozen-lockfile 2>&1`, { cwd, timeout, stdio, env });
+        return;
+      } catch {
+      }
+    }
+    (0, import_node_child_process.execSync)(`"${bun}" install`, { cwd, timeout, stdio, env });
+  }
+  /**
+   * Windows-only fallback path: `bun install [--frozen-lockfile]
+   * --backend=copyfile`. Used when npm.cmd isn't available on PATH
+   * (typically: Shogo Desktop bundles bun but the user didn't install
+   * Node.js separately).
+   *
+   * The `--backend=copyfile` flag forces bun to copy package contents
+   * into `node_modules/` instead of hardlinking from
+   * `~/.bun/install/cache`. Hardlinks are bun's default for speed but
+   * fail in confusing ways on Windows (the destination directory gets
+   * created but ends up empty, and downstream `require('webidl-conversions')`
+   * etc. then crash with MODULE_NOT_FOUND). See bun#10327 / #28653.
+   */
+  installSyncBunCopyfile(cwd, opts) {
+    const timeout = opts?.timeout ?? DEFAULT_INSTALL_TIMEOUT;
+    const stdio = opts?.stdio ?? "pipe";
+    const env = this.spawnEnv(opts?.env);
+    const bun = this.bunBinary;
+    console.warn(
+      "[platform-pkg] Node.js / npm.cmd not found on PATH \u2014 falling back to `bun install --backend=copyfile` (Shogo Desktop bundle path). This is slower than hardlink but avoids the Windows extract bug."
+    );
+    if (opts?.frozen) {
+      try {
+        (0, import_node_child_process.execSync)(`"${bun}" install --frozen-lockfile --backend=copyfile`, {
+          cwd,
+          timeout,
+          stdio,
+          env
+        });
+        return;
+      } catch {
+      }
+    }
+    (0, import_node_child_process.execSync)(`"${bun}" install --backend=copyfile`, { cwd, timeout, stdio, env });
+  }
+  // ---------------------------------------------------------------------------
+  // Install — async with spawn (used by RuntimeManager)
+  // ---------------------------------------------------------------------------
+  installAsync(cwd, opts) {
+    if (IS_WINDOWS) {
+      const env = this.spawnEnv(opts?.env);
+      if (isNodeAvailableOnWindows(env.PATH)) {
+        return this.installAsyncWindowsNpm(cwd, opts).catch((err) => {
+          if (err instanceof NodeMissingError) {
+            return this.installAsyncBunCopyfile(cwd, opts);
+          }
+          throw err;
+        });
+      }
+      return this.installAsyncBunCopyfile(cwd, opts);
+    }
+    return this.installAsyncBun(cwd, opts);
+  }
+  installAsyncWindowsNpm(cwd, opts) {
+    const timeout = opts?.timeout ?? DEFAULT_INSTALL_TIMEOUT;
+    const env = this.spawnEnv(opts?.env);
+    const cmd = "npm.cmd";
+    const args = ["install", "--loglevel=error"];
+    return new Promise((resolve, reject) => {
+      const proc = (0, import_node_child_process.spawn)(cmd, args, {
+        cwd,
+        stdio: "pipe",
+        env,
+        shell: true
+      });
+      const timer = setTimeout(() => {
+        proc.kill();
+        reject(new Error(`${cmd} install timed out after ${timeout / 1e3}s`));
+      }, timeout);
+      let stderr = "";
+      proc.stderr?.on("data", (d) => {
+        stderr += d.toString();
+      });
+      proc.on("exit", (code) => {
+        clearTimeout(timer);
+        if (code === 0) return resolve();
+        if (/not recognized as an internal or external command/i.test(stderr)) {
+          return reject(new NodeMissingError());
+        }
+        reject(new Error(`${cmd} install exited with code ${code}
+${stderr}`));
+      });
+      proc.on("error", (err) => {
+        clearTimeout(timer);
+        if (err.code === "ENOENT") return reject(new NodeMissingError());
+        reject(err);
+      });
+    });
+  }
+  installAsyncBunCopyfile(cwd, opts) {
+    console.warn(
+      "[platform-pkg] Node.js / npm.cmd not found on PATH \u2014 falling back to `bun install --backend=copyfile` (Shogo Desktop bundle path)."
+    );
+    return this.installAsyncBun(cwd, opts, ["--backend=copyfile"]);
+  }
+  installAsyncBun(cwd, opts, extraArgs = []) {
+    const timeout = opts?.timeout ?? DEFAULT_INSTALL_TIMEOUT;
+    const env = this.spawnEnv(opts?.env);
+    const bun = this.bunBinary;
+    const baseArgs = ["install", ...extraArgs];
+    const frozenArgs = opts?.frozen ? ["install", "--frozen-lockfile", ...extraArgs] : null;
+    const runOnce = (args) => new Promise((resolve, reject) => {
+      const proc = (0, import_node_child_process.spawn)(bun, args, {
+        cwd,
+        stdio: "pipe",
+        env
+      });
+      const timer = setTimeout(() => {
+        proc.kill();
+        reject(new Error(`bun ${args.join(" ")} timed out after ${timeout / 1e3}s`));
+      }, timeout);
+      let stderr = "";
+      proc.stderr?.on("data", (d) => {
+        stderr += d.toString();
+      });
+      proc.stdout?.on("data", () => {
+      });
+      proc.on("exit", (code) => {
+        clearTimeout(timer);
+        resolve({ ok: code === 0, stderr });
+      });
+      proc.on("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+    const run = async () => {
+      if (frozenArgs) {
+        const first = await runOnce(frozenArgs);
+        if (first.ok) return;
+      }
+      const second = await runOnce(baseArgs);
+      if (!second.ok) {
+        throw new Error(`bun install failed: ${second.stderr}`);
+      }
+    };
+    return run();
+  }
+  // ---------------------------------------------------------------------------
+  // Exec — run an npx/bunx tool synchronously
+  // ---------------------------------------------------------------------------
+  execToolSync(tool, args, cwd, opts) {
+    const timeout = opts?.timeout ?? DEFAULT_EXEC_TIMEOUT;
+    const stdio = opts?.stdio ?? "pipe";
+    const env = this.spawnEnv(opts?.env);
+    const argStr = args.length > 0 ? ` ${args.join(" ")}` : "";
+    const bun = this.bunBinary;
+    const cmd = IS_WINDOWS ? `npx ${tool}${argStr}` : `"${bun}" x ${opts?.useBunFlag ? "--bun " : ""}${tool}${argStr}`;
+    return (0, import_node_child_process.execSync)(cmd, {
+      cwd,
+      timeout,
+      stdio,
+      env,
+      // shellOpt() returns `true` on Windows so Node/Bun pick the platform
+      // default shell from `process.env.ComSpec`. ExecSyncOptions only
+      // narrowly types `shell` as `string | undefined`, but the runtime
+      // accepts a boolean and the cross-platform behavior depends on it
+      // (see shellOpt() doc).
+      shell: this.shellOpt(),
+      encoding: "utf-8"
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Exec — async variant that DOES NOT block the JS event loop.
+  //
+  // The sync variant above is fine for one-shot project scaffolding
+  // (template.copy.ts) where blocking is intentional. Inside the runtime's
+  // hot path (PreviewManager.runPrismaIfNeeded → /pool/assign) it caused
+  // a measured ~4.7s freeze of /pool/assign in staging because prisma's
+  // child process held the event loop for the full duration. Always
+  // prefer this variant in long-lived services.
+  // ---------------------------------------------------------------------------
+  async execToolAsync(tool, args, cwd, opts) {
+    const timeout = opts?.timeout ?? DEFAULT_EXEC_TIMEOUT;
+    const stdio = opts?.stdio ?? "pipe";
+    const env = this.spawnEnv(opts?.env);
+    let cmd;
+    let argv;
+    let useShell;
+    if (IS_WINDOWS) {
+      const argStr = args.length > 0 ? ` ${args.join(" ")}` : "";
+      cmd = `npx ${tool}${argStr}`;
+      argv = [];
+      useShell = true;
+    } else {
+      cmd = this.bunBinary;
+      argv = ["x"];
+      if (opts?.useBunFlag) argv.push("--bun");
+      argv.push(tool, ...args);
+      useShell = false;
+    }
+    return new Promise((resolvePromise, rejectPromise) => {
+      const proc = (0, import_node_child_process.spawn)(cmd, argv, {
+        cwd,
+        env,
+        stdio,
+        shell: useShell ? this.shellOpt() : false
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      proc.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      const timer = setTimeout(() => {
+        try {
+          proc.kill("SIGKILL");
+        } catch {
+        }
+        rejectPromise(
+          new Error(`${tool} ${args.join(" ")} timed out after ${timeout}ms`)
+        );
+      }, timeout);
+      proc.on("error", (err) => {
+        clearTimeout(timer);
+        rejectPromise(err);
+      });
+      proc.on("exit", (code) => {
+        clearTimeout(timer);
+        if (code === 0) {
+          resolvePromise(stdout);
+        } else {
+          const errMsg = stderr.trim() || stdout.trim() || `exit ${code}`;
+          rejectPromise(new Error(`${tool} ${args.join(" ")} failed: ${errMsg}`));
+        }
+      });
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Prisma convenience wrappers
+  // ---------------------------------------------------------------------------
+  prismaGenerate(cwd, opts) {
+    this.execToolSync("prisma", ["generate"], cwd, {
+      timeout: opts?.timeout ?? 3e4,
+      stdio: opts?.stdio,
+      env: opts?.env
+    });
+  }
+  prismaDbPush(cwd, opts) {
+    const args = ["db", "push"];
+    if (opts?.acceptDataLoss) args.push("--accept-data-loss");
+    this.execToolSync("prisma", args, cwd, {
+      timeout: opts?.timeout ?? DEFAULT_EXEC_TIMEOUT,
+      stdio: opts?.stdio,
+      env: opts?.env
+    });
+  }
+  // Async siblings of the prisma wrappers above. Use these from any
+  // long-running service (runtime, agent gateway, preview manager) so a
+  // 1-3s prisma child process doesn't freeze /health, /pool/assign, or
+  // other concurrent HTTP work. Same arg shape, same timeout defaults.
+  async prismaGenerateAsync(cwd, opts) {
+    await this.execToolAsync("prisma", ["generate"], cwd, {
+      timeout: opts?.timeout ?? 3e4,
+      stdio: opts?.stdio,
+      env: opts?.env
+    });
+  }
+  async prismaDbPushAsync(cwd, opts) {
+    const args = ["db", "push"];
+    if (opts?.acceptDataLoss) args.push("--accept-data-loss");
+    await this.execToolAsync("prisma", args, cwd, {
+      timeout: opts?.timeout ?? DEFAULT_EXEC_TIMEOUT,
+      stdio: opts?.stdio,
+      env: opts?.env
+    });
+  }
+};
+function wrapWindowsNpmError(err) {
+  if (!IS_WINDOWS) return null;
+  const blob = `${err?.stderr?.toString?.() ?? ""}
+${err?.stdout?.toString?.() ?? ""}
+${err?.message ?? ""}`;
+  if (/not recognized as an internal or external command/i.test(blob)) {
+    return new NodeMissingError();
+  }
+  if (err?.code === "ENOENT") return new NodeMissingError();
+  return null;
+}
+var pkg = new PlatformPackageManager();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGENT_NAME_PATTERN,
+  NodeMissingError,
+  PlatformPackageManager,
+  _resetUnixNodeCache,
+  buildSyncPayload,
+  isNodeAvailableOnUnix,
+  isNodeAvailableOnWindows,
+  normalizeToolEntry,
+  pkg,
+  resolveBinInvocation,
+  runDeploy,
+  validateManifest
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.d.cts

@@ -0,0 +1,3 @@
+export { AGENT_NAME_PATTERN, AgentManifestEntry, AgentToolEntry, AgentsManifest, BuildSyncPayloadOptions, DeployAuth, RunDeployOptions, RunDeployResult, SyncPayload, ToolDescriptor, ValidatedManifest, ValidationIssue, buildSyncPayload, normalizeToolEntry, runDeploy, validateManifest } from './deploy.cjs';
+export { NodeMissingError, PkgExecOptions, PkgInstallOptions, PlatformPackageManager, _resetUnixNodeCache, isNodeAvailableOnUnix, isNodeAvailableOnWindows, pkg, resolveBinInvocation } from './pkg.cjs';
+import 'node:child_process';

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { AGENT_NAME_PATTERN, AgentManifestEntry, AgentToolEntry, AgentsManifest, BuildSyncPayloadOptions, DeployAuth, RunDeployOptions, RunDeployResult, SyncPayload, ToolDescriptor, ValidatedManifest, ValidationIssue, buildSyncPayload, normalizeToolEntry, runDeploy, validateManifest } from './deploy.js';
+export { NodeMissingError, PkgExecOptions, PkgInstallOptions, PlatformPackageManager, _resetUnixNodeCache, isNodeAvailableOnUnix, isNodeAvailableOnWindows, pkg, resolveBinInvocation } from './pkg.js';
+import 'node:child_process';