@shareai-lab/kode 2.0.2 → 2.0.3

package/dist/chunks/chunk-B3MW3YGY.js

@@ -0,0 +1,1409 @@
+// packages/runtime/src/shell/BunShell.ts
+import { existsSync as existsSync5 } from "fs";
+import { isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
+
+// packages/runtime/src/shell/state.ts
+function createInitialState(cwd) {
+  return {
+    cwd,
+    isAlive: true,
+    currentProcess: null,
+    abortController: null,
+    backgroundProcesses: /* @__PURE__ */ new Map()
+  };
+}
+
+// packages/runtime/src/shell/exec.ts
+import { spawn } from "node:child_process";
+
+// packages/runtime/src/shell/sandboxCommand.ts
+import { existsSync as existsSync2, mkdirSync } from "fs";
+import which from "which";
+
+// packages/runtime/src/shell/linuxSandbox.ts
+import { existsSync, realpathSync, statSync } from "fs";
+import { homedir } from "os";
+import { dirname, isAbsolute, resolve } from "path";
+function hasGlobPattern(value) {
+  return value.includes("*") || value.includes("?") || value.includes("[") || value.includes("]");
+}
+function normalizeLinuxSandboxPath(input, options) {
+  const cwd = options?.cwd ?? process.cwd();
+  const homeDir = options?.homeDir ?? homedir();
+  let resolved = input;
+  if (input === "~") resolved = homeDir;
+  else if (input.startsWith("~/")) resolved = homeDir + input.slice(1);
+  else if (input.startsWith("./") || input.startsWith("../"))
+    resolved = resolve(cwd, input);
+  else if (!isAbsolute(input)) resolved = resolve(cwd, input);
+  if (hasGlobPattern(resolved)) {
+    const prefix = resolved.split(/[*?[\]]/)[0];
+    if (prefix && prefix !== "/") {
+      const dir = prefix.endsWith("/") ? prefix.slice(0, -1) : dirname(prefix);
+      try {
+        const real = realpathSync(dir);
+        const suffix = resolved.slice(dir.length);
+        return real + suffix;
+      } catch {
+      }
+    }
+    return resolved;
+  }
+  try {
+    resolved = realpathSync(resolved);
+  } catch {
+  }
+  return resolved;
+}
+function buildLinuxBwrapFilesystemArgs(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const homeDir = options.homeDir ?? homedir();
+  const args = [];
+  const writeConfig = options.writeConfig;
+  if (writeConfig) {
+    args.push("--ro-bind", "/", "/");
+    const allowedRoots = [];
+    if (existsSync("/tmp/kode")) {
+      args.push("--bind", "/tmp/kode", "/tmp/kode");
+      allowedRoots.push("/tmp/kode");
+    }
+    for (const raw of writeConfig.allowOnly ?? []) {
+      const resolved = normalizeLinuxSandboxPath(raw, { cwd, homeDir });
+      if (resolved.startsWith("/dev/")) continue;
+      if (!existsSync(resolved)) continue;
+      args.push("--bind", resolved, resolved);
+      allowedRoots.push(resolved);
+    }
+    const denyWithinAllow = [
+      ...writeConfig.denyWithinAllow ?? [],
+      ...options.extraDenyWithinAllow ?? []
+    ];
+    for (const raw of denyWithinAllow) {
+      const resolved = normalizeLinuxSandboxPath(raw, { cwd, homeDir });
+      if (resolved.startsWith("/dev/")) continue;
+      if (!existsSync(resolved)) continue;
+      const withinAllowed = allowedRoots.some(
+        (root) => resolved === root || resolved.startsWith(root + "/")
+      );
+      if (!withinAllowed) continue;
+      args.push("--ro-bind", resolved, resolved);
+    }
+  } else {
+    args.push("--bind", "/", "/");
+  }
+  const denyRead = [...options.readConfig?.denyOnly ?? []];
+  if (existsSync("/etc/ssh/ssh_config.d"))
+    denyRead.push("/etc/ssh/ssh_config.d");
+  for (const raw of denyRead) {
+    const resolved = normalizeLinuxSandboxPath(raw, { cwd, homeDir });
+    if (resolved.startsWith("/dev/")) continue;
+    if (!existsSync(resolved)) continue;
+    if (statSync(resolved).isDirectory()) args.push("--tmpfs", resolved);
+    else args.push("--ro-bind", "/dev/null", resolved);
+  }
+  return args;
+}
+function buildLinuxBwrapCommand(options) {
+  const args = [];
+  args.push(
+    "--die-with-parent",
+    "--new-session",
+    "--unshare-pid",
+    "--unshare-uts",
+    "--unshare-ipc"
+  );
+  if (options.needsNetworkRestriction) args.push("--unshare-net");
+  args.push(
+    ...buildLinuxBwrapFilesystemArgs({
+      cwd: options.cwd,
+      homeDir: options.homeDir,
+      readConfig: options.readConfig,
+      writeConfig: options.writeConfig
+    })
+  );
+  args.push(
+    "--dev",
+    "/dev",
+    "--setenv",
+    "SANDBOX_RUNTIME",
+    "1",
+    "--setenv",
+    "TMPDIR",
+    "/tmp/kode"
+  );
+  if (!options.enableWeakerNestedSandbox) args.push("--proc", "/proc");
+  args.push("--", options.binShellPath, "-c", options.command);
+  return [options.bwrapPath, ...args];
+}
+
+// packages/runtime/src/shell/macosSandbox.ts
+import { dirname as dirname2 } from "path";
+function buildSandboxEnvAssignments(options) {
+  const httpProxyPort = options?.httpProxyPort;
+  const socksProxyPort = options?.socksProxyPort;
+  const platform = options?.platform ?? process.platform;
+  const env = ["SANDBOX_RUNTIME=1", "TMPDIR=/tmp/kode"];
+  if (!httpProxyPort && !socksProxyPort) return env;
+  const noProxy = [
+    "localhost",
+    "127.0.0.1",
+    "::1",
+    "*.local",
+    ".local",
+    "169.254.0.0/16",
+    "10.0.0.0/8",
+    "172.16.0.0/12",
+    "192.168.0.0/16"
+  ].join(",");
+  env.push(`NO_PROXY=${noProxy}`);
+  env.push(`no_proxy=${noProxy}`);
+  if (httpProxyPort) {
+    env.push(`HTTP_PROXY=http://localhost:${httpProxyPort}`);
+    env.push(`HTTPS_PROXY=http://localhost:${httpProxyPort}`);
+    env.push(`http_proxy=http://localhost:${httpProxyPort}`);
+    env.push(`https_proxy=http://localhost:${httpProxyPort}`);
+  }
+  if (socksProxyPort) {
+    env.push(`ALL_PROXY=socks5h://localhost:${socksProxyPort}`);
+    env.push(`all_proxy=socks5h://localhost:${socksProxyPort}`);
+    if (platform === "darwin") {
+      env.push(
+        `GIT_SSH_COMMAND="ssh -o ProxyCommand='nc -X 5 -x localhost:${socksProxyPort} %h %p'"`
+      );
+    }
+    env.push(`FTP_PROXY=socks5h://localhost:${socksProxyPort}`);
+    env.push(`ftp_proxy=socks5h://localhost:${socksProxyPort}`);
+    env.push(`RSYNC_PROXY=localhost:${socksProxyPort}`);
+    env.push(
+      `DOCKER_HTTP_PROXY=http://localhost:${httpProxyPort || socksProxyPort}`
+    );
+    env.push(
+      `DOCKER_HTTPS_PROXY=http://localhost:${httpProxyPort || socksProxyPort}`
+    );
+    if (httpProxyPort) {
+      env.push("CLOUDSDK_PROXY_TYPE=https");
+      env.push("CLOUDSDK_PROXY_ADDRESS=localhost");
+      env.push(`CLOUDSDK_PROXY_PORT=${httpProxyPort}`);
+    }
+    env.push(`GRPC_PROXY=socks5h://localhost:${socksProxyPort}`);
+    env.push(`grpc_proxy=socks5h://localhost:${socksProxyPort}`);
+  }
+  return env;
+}
+function escapeRegexForSandboxGlobPattern(pattern) {
+  return "^" + pattern.replace(/[.^$+{}()|\\]/g, "\\$&").replace(/\[([^\]]*?)$/g, "\\[$1").replace(/\*\*\//g, "__GLOBSTAR_SLASH__").replace(/\*\*/g, "__GLOBSTAR__").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/__GLOBSTAR_SLASH__/g, "(.*/)?").replace(/__GLOBSTAR__/g, ".*") + "$";
+}
+function getMacosTmpDirWriteAllowPaths() {
+  const tmpdirValue = process.env.TMPDIR;
+  if (!tmpdirValue) return [];
+  if (!tmpdirValue.match(/^\/(private\/)?var\/folders\/[^/]{2}\/[^/]+\/T\/?$/))
+    return [];
+  const base = tmpdirValue.replace(/\/T\/?$/, "");
+  if (base.startsWith("/private/var/"))
+    return [base, base.replace("/private", "")];
+  if (base.startsWith("/var/")) return [base, "/private" + base];
+  return [base];
+}
+function buildMacosSandboxDenyUnlinkRules(paths, logTag) {
+  const lines = [];
+  for (const raw of paths) {
+    const normalized = normalizeLinuxSandboxPath(raw);
+    if (hasGlobPattern(normalized)) {
+      const regex = escapeRegexForSandboxGlobPattern(normalized);
+      lines.push(
+        "(deny file-write-unlink",
+        `  (regex ${JSON.stringify(regex)})`,
+        `  (with message "${logTag}"))`
+      );
+      const prefix = normalized.split(/[*?[\]]/)[0];
+      if (prefix && prefix !== "/") {
+        const literal = prefix.endsWith("/") ? prefix.slice(0, -1) : dirname2(prefix);
+        lines.push(
+          "(deny file-write-unlink",
+          `  (literal ${JSON.stringify(literal)})`,
+          `  (with message "${logTag}"))`
+        );
+      }
+      continue;
+    }
+    lines.push(
+      "(deny file-write-unlink",
+      `  (subpath ${JSON.stringify(normalized)})`,
+      `  (with message "${logTag}"))`
+    );
+  }
+  return lines;
+}
+function buildMacosSandboxFileReadRules(readConfig, logTag) {
+  if (!readConfig) return ["(allow file-read*)"];
+  const lines = ["(allow file-read*)"];
+  for (const raw of readConfig.denyOnly ?? []) {
+    const normalized = normalizeLinuxSandboxPath(raw);
+    if (hasGlobPattern(normalized)) {
+      const regex = escapeRegexForSandboxGlobPattern(normalized);
+      lines.push(
+        "(deny file-read*",
+        `  (regex ${JSON.stringify(regex)})`,
+        `  (with message "${logTag}"))`
+      );
+    } else {
+      lines.push(
+        "(deny file-read*",
+        `  (subpath ${JSON.stringify(normalized)})`,
+        `  (with message "${logTag}"))`
+      );
+    }
+  }
+  lines.push(
+    ...buildMacosSandboxDenyUnlinkRules(readConfig.denyOnly ?? [], logTag)
+  );
+  return lines;
+}
+function buildMacosSandboxFileWriteRules(writeConfig, logTag) {
+  if (!writeConfig) return ["(allow file-write*)"];
+  const lines = [];
+  lines.push(
+    "(allow file-write*",
+    `  (literal "/dev/null")`,
+    `  (with message "${logTag}"))`
+  );
+  for (const raw of getMacosTmpDirWriteAllowPaths()) {
+    const normalized = normalizeLinuxSandboxPath(raw);
+    lines.push(
+      "(allow file-write*",
+      `  (subpath ${JSON.stringify(normalized)})`,
+      `  (with message "${logTag}"))`
+    );
+  }
+  for (const raw of writeConfig.allowOnly ?? []) {
+    const normalized = normalizeLinuxSandboxPath(raw);
+    if (hasGlobPattern(normalized)) {
+      const regex = escapeRegexForSandboxGlobPattern(normalized);
+      lines.push(
+        "(allow file-write*",
+        `  (regex ${JSON.stringify(regex)})`,
+        `  (with message "${logTag}"))`
+      );
+    } else {
+      lines.push(
+        "(allow file-write*",
+        `  (subpath ${JSON.stringify(normalized)})`,
+        `  (with message "${logTag}"))`
+      );
+    }
+  }
+  for (const raw of writeConfig.denyWithinAllow ?? []) {
+    const normalized = normalizeLinuxSandboxPath(raw);
+    if (hasGlobPattern(normalized)) {
+      const regex = escapeRegexForSandboxGlobPattern(normalized);
+      lines.push(
+        "(deny file-write*",
+        `  (regex ${JSON.stringify(regex)})`,
+        `  (with message "${logTag}"))`
+      );
+    } else {
+      lines.push(
+        "(deny file-write*",
+        `  (subpath ${JSON.stringify(normalized)})`,
+        `  (with message "${logTag}"))`
+      );
+    }
+  }
+  lines.push(
+    ...buildMacosSandboxDenyUnlinkRules(
+      writeConfig.denyWithinAllow ?? [],
+      logTag
+    )
+  );
+  return lines;
+}
+function buildMacosSandboxExecCommand(options) {
+  const logTag = "KODE_SANDBOX";
+  const profileLines = [
+    "(version 1)",
+    `(deny default (with message "${logTag}"))`,
+    "",
+    "; Kode sandbox-exec profile (reference CLI compatible)",
+    "",
+    // Keep this permissive enough for typical CLI tools (git, node, etc).
+    "(allow process*)",
+    "(allow sysctl-read)",
+    "(allow mach-lookup)",
+    "",
+    "; Network"
+  ];
+  const allowUnixSockets = options.allowUnixSockets ?? [];
+  if (!options.needsNetworkRestriction) {
+    profileLines.push("(allow network*)");
+  } else {
+    if (options.allowLocalBinding) {
+      profileLines.push('(allow network-bind (local ip "localhost:*"))');
+      profileLines.push('(allow network-inbound (local ip "localhost:*"))');
+      profileLines.push('(allow network-outbound (local ip "localhost:*"))');
+    }
+    if (options.allowAllUnixSockets) {
+      profileLines.push('(allow network* (subpath "/"))');
+    } else if (allowUnixSockets.length > 0) {
+      for (const socketPath of allowUnixSockets) {
+        const normalized = normalizeLinuxSandboxPath(socketPath);
+        profileLines.push(
+          `(allow network* (subpath ${JSON.stringify(normalized)}))`
+        );
+      }
+    }
+    if (options.httpProxyPort !== void 0) {
+      profileLines.push(
+        `(allow network-bind (local ip "localhost:${options.httpProxyPort}"))`
+      );
+      profileLines.push(
+        `(allow network-inbound (local ip "localhost:${options.httpProxyPort}"))`
+      );
+      profileLines.push(
+        `(allow network-outbound (remote ip "localhost:${options.httpProxyPort}"))`
+      );
+    }
+    if (options.socksProxyPort !== void 0) {
+      profileLines.push(
+        `(allow network-bind (local ip "localhost:${options.socksProxyPort}"))`
+      );
+      profileLines.push(
+        `(allow network-inbound (local ip "localhost:${options.socksProxyPort}"))`
+      );
+      profileLines.push(
+        `(allow network-outbound (remote ip "localhost:${options.socksProxyPort}"))`
+      );
+    }
+  }
+  profileLines.push("");
+  profileLines.push("; File read");
+  profileLines.push(
+    ...buildMacosSandboxFileReadRules(options.readConfig, logTag)
+  );
+  profileLines.push("");
+  profileLines.push("; File write");
+  profileLines.push(
+    ...buildMacosSandboxFileWriteRules(options.writeConfig, logTag)
+  );
+  const profile = profileLines.join("\n");
+  const envAssignments = buildSandboxEnvAssignments({
+    httpProxyPort: options.httpProxyPort,
+    socksProxyPort: options.socksProxyPort,
+    platform: "darwin"
+  });
+  const envPrefix = envAssignments.length ? `export ${envAssignments.join(" ")} && ` : "";
+  return [
+    options.sandboxExecPath,
+    "-p",
+    profile,
+    options.binShellPath,
+    "-c",
+    `${envPrefix}${options.command}`
+  ];
+}
+
+// packages/runtime/src/shell/sandboxCommand.ts
+function maybeAnnotateMacosSandboxStderr(stderr, sandbox) {
+  if (!stderr) return stderr;
+  if (!sandbox || sandbox.enabled !== true) return stderr;
+  const platform = sandbox.__platformOverride ?? process.platform;
+  if (platform !== "darwin") return stderr;
+  if (stderr.includes("[sandbox]")) return stderr;
+  const lower = stderr.toLowerCase();
+  const looksLikeSandboxViolation = stderr.includes("KODE_SANDBOX") || lower.includes("sandbox-exec") && (lower.includes("deny") || lower.includes("operation not permitted")) || lower.includes("operation not permitted") && lower.includes("sandbox");
+  if (!looksLikeSandboxViolation) return stderr;
+  return [
+    stderr.trimEnd(),
+    "",
+    "[sandbox] This failure looks like a macOS sandbox denial. Adjust sandbox settings (e.g. /sandbox or .kode/settings.json) to grant the minimal required access."
+  ].join("\n");
+}
+function isSandboxInitFailure(stderr) {
+  const s = stderr.toLowerCase();
+  return s.includes("bwrap:") || s.includes("bubblewrap") || s.includes("namespace") && s.includes("failed");
+}
+function buildSandboxCommand(options) {
+  const sandbox = options.sandbox;
+  if (!sandbox.enabled) return null;
+  const platform = sandbox.__platformOverride ?? process.platform;
+  const needsNetworkRestriction = sandbox.needsNetworkRestriction !== void 0 ? sandbox.needsNetworkRestriction : sandbox.allowNetwork === true ? false : true;
+  const writeConfig = sandbox.writeConfig ?? (sandbox.writableRoots && sandbox.writableRoots.length > 0 ? { allowOnly: sandbox.writableRoots.filter(Boolean) } : void 0);
+  const readConfig = sandbox.readConfig;
+  const hasReadRestrictions = (readConfig?.denyOnly?.length ?? 0) > 0;
+  const hasWriteRestrictions = writeConfig !== void 0;
+  const hasNetworkRestrictions = needsNetworkRestriction === true;
+  if (!hasReadRestrictions && !hasWriteRestrictions && !hasNetworkRestrictions) {
+    return null;
+  }
+  const binShell = sandbox.binShell ?? (which.sync("bash", { nothrow: true }) ? "bash" : "sh");
+  const binShellPath = which.sync(binShell, { nothrow: true }) ?? binShell;
+  const cwd = sandbox.chdir || options.cwd;
+  if (platform === "linux") {
+    const bwrapPath = sandbox.__bwrapPathOverride !== void 0 ? sandbox.__bwrapPathOverride : which.sync("bwrap", { nothrow: true }) ?? which.sync("bubblewrap", { nothrow: true });
+    if (!bwrapPath) return null;
+    try {
+      mkdirSync("/tmp/kode", { recursive: true });
+    } catch {
+    }
+    const cmd = buildLinuxBwrapCommand({
+      bwrapPath,
+      command: options.command,
+      needsNetworkRestriction,
+      readConfig,
+      writeConfig,
+      enableWeakerNestedSandbox: sandbox.enableWeakerNestedSandbox,
+      binShellPath,
+      cwd
+    });
+    return { cmd };
+  }
+  if (platform === "darwin") {
+    const sandboxExecPath = sandbox.__sandboxExecPathOverride !== void 0 ? sandbox.__sandboxExecPathOverride : existsSync2("/usr/bin/sandbox-exec") ? "/usr/bin/sandbox-exec" : which.sync("sandbox-exec", { nothrow: true });
+    if (!sandboxExecPath) return null;
+    try {
+      mkdirSync("/tmp/kode", { recursive: true });
+    } catch {
+    }
+    try {
+      mkdirSync("/private/tmp/kode", { recursive: true });
+    } catch {
+    }
+    return {
+      cmd: buildMacosSandboxExecCommand({
+        sandboxExecPath,
+        binShellPath,
+        command: options.command,
+        needsNetworkRestriction,
+        httpProxyPort: sandbox.httpProxyPort,
+        socksProxyPort: sandbox.socksProxyPort,
+        allowUnixSockets: sandbox.allowUnixSockets,
+        allowAllUnixSockets: sandbox.allowAllUnixSockets,
+        allowLocalBinding: sandbox.allowLocalBinding,
+        readConfig,
+        writeConfig
+      })
+    };
+  }
+  return null;
+}
+
+// packages/runtime/src/shell/streamReaders.ts
+function logError(error) {
+  if (process.env.NODE_ENV === "test") {
+    console.error(error);
+  }
+}
+function startStreamReader(stream, append) {
+  if (!stream) return;
+  try {
+    stream.setEncoding("utf8");
+  } catch {
+  }
+  stream.on("data", (chunk) => {
+    const text = typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+    if (text) append(text);
+  });
+  stream.on("error", (err) => {
+    logError(
+      `Stream read error: ${err instanceof Error ? err.message : String(err)}`
+    );
+  });
+}
+function createCancellableTextCollector(stream, options) {
+  let text = "";
+  const collectText = options?.collectText !== false;
+  if (!stream) {
+    return {
+      getText: () => text,
+      done: Promise.resolve(),
+      cancel: async () => {
+      }
+    };
+  }
+  let doneResolve = null;
+  const done = new Promise((resolve3) => {
+    doneResolve = resolve3;
+  });
+  let finished = false;
+  let cancelled = false;
+  const finish = () => {
+    if (finished) return;
+    finished = true;
+    cleanup();
+    doneResolve?.();
+    doneResolve = null;
+  };
+  const onData = (chunk) => {
+    const value = typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+    if (!value) return;
+    if (collectText) text += value;
+    options?.onChunk?.(value);
+  };
+  const onError = (err) => {
+    if (!cancelled) {
+      logError(
+        `Stream read error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    finish();
+  };
+  const onEnd = () => finish();
+  const onClose = () => finish();
+  const hasDestroy = (value) => {
+    return typeof value.destroy === "function";
+  };
+  const cleanup = () => {
+    stream.removeListener("data", onData);
+    stream.removeListener("error", onError);
+    stream.removeListener("end", onEnd);
+    stream.removeListener("close", onClose);
+  };
+  try {
+    stream.setEncoding("utf8");
+  } catch {
+  }
+  stream.on("data", onData);
+  stream.on("error", onError);
+  stream.on("end", onEnd);
+  stream.on("close", onClose);
+  return {
+    getText: () => text,
+    done,
+    cancel: async () => {
+      cancelled = true;
+      try {
+        if (hasDestroy(stream)) {
+          stream.destroy();
+        }
+      } catch {
+      }
+      finish();
+    }
+  };
+}
+
+// packages/runtime/src/shell/shellCmd.ts
+import { existsSync as existsSync3 } from "fs";
+function getShellCmdForPlatform(platform, command, env = process.env) {
+  if (platform === "win32") {
+    const comspec = typeof env.ComSpec === "string" && env.ComSpec.length > 0 ? env.ComSpec : "cmd";
+    return [comspec, "/c", command];
+  }
+  const sh = existsSync3("/bin/sh") ? "/bin/sh" : "sh";
+  return [sh, "-c", command];
+}
+
+// packages/runtime/src/shell/exec.ts
+function logError2(error) {
+  if (process.env.NODE_ENV === "test") {
+    console.error(error);
+  }
+}
+function normalizeExitCode(exitCode, interrupted) {
+  if (typeof exitCode === "number" && Number.isFinite(exitCode)) return exitCode;
+  return interrupted ? 143 : 0;
+}
+async function exec(state, command, abortSignal, timeout, options) {
+  const DEFAULT_TIMEOUT = 12e4;
+  const commandTimeout = timeout ?? DEFAULT_TIMEOUT;
+  state.abortController = new AbortController();
+  let wasAborted = false;
+  const onAbort = () => {
+    wasAborted = true;
+    try {
+      state.abortController?.abort();
+    } catch {
+    }
+    try {
+      state.currentProcess?.kill();
+    } catch {
+    }
+  };
+  if (abortSignal) {
+    abortSignal.addEventListener("abort", onAbort, { once: true });
+  }
+  const sandbox = options?.sandbox;
+  const shouldAttemptSandbox = sandbox?.enabled === true;
+  const executionCwd = shouldAttemptSandbox && sandbox?.chdir ? sandbox.chdir : state.cwd;
+  const runOnce = async (cmd, cwdOverride) => {
+    state.currentProcess = spawn(cmd[0], cmd.slice(1), {
+      cwd: cwdOverride ?? executionCwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const processRef = state.currentProcess;
+    const exitPromise = new Promise((resolve3) => {
+      processRef.once("exit", (code) => resolve3({ kind: "exit", code }));
+      processRef.once("error", (error) => resolve3({ kind: "error", error }));
+    });
+    const stdoutCollector = createCancellableTextCollector(processRef.stdout, {
+      onChunk: options?.onStdoutChunk
+    });
+    const stderrCollector = createCancellableTextCollector(processRef.stderr, {
+      onChunk: options?.onStderrChunk
+    });
+    let timeoutHandle = null;
+    const timeoutPromise = new Promise((resolve3) => {
+      timeoutHandle = setTimeout(() => resolve3("timeout"), commandTimeout);
+    });
+    const result = await Promise.race([
+      exitPromise.then(() => "completed"),
+      timeoutPromise
+    ]);
+    if (timeoutHandle) clearTimeout(timeoutHandle);
+    if (result === "timeout") {
+      try {
+        processRef.kill();
+      } catch {
+      }
+      try {
+        state.abortController?.abort();
+      } catch {
+      }
+      try {
+        await exitPromise;
+      } catch {
+      }
+      await Promise.race([
+        Promise.allSettled([stdoutCollector.done, stderrCollector.done]),
+        new Promise((resolve3) => setTimeout(resolve3, 250))
+      ]);
+      await Promise.allSettled([
+        stdoutCollector.cancel(),
+        stderrCollector.cancel()
+      ]);
+      return {
+        stdout: "",
+        stderr: "Command timed out",
+        code: 143,
+        interrupted: true
+      };
+    }
+    await Promise.race([
+      Promise.allSettled([stdoutCollector.done, stderrCollector.done]),
+      new Promise((resolve3) => setTimeout(resolve3, 250))
+    ]);
+    await Promise.allSettled([
+      stdoutCollector.cancel(),
+      stderrCollector.cancel()
+    ]);
+    const stdout = stdoutCollector.getText();
+    let stderr = stderrCollector.getText();
+    const interrupted = wasAborted || abortSignal?.aborted === true || state.abortController?.signal.aborted === true;
+    const exitOutcome = await exitPromise;
+    if (exitOutcome.kind === "error") {
+      stderr = [stderr, exitOutcome.error.message].filter(Boolean).join("\n");
+    }
+    let exitCode = exitOutcome.kind === "exit" ? exitOutcome.code : null;
+    if (exitOutcome.kind === "error") exitCode = 2;
+    return {
+      stdout,
+      stderr,
+      code: normalizeExitCode(exitCode, interrupted),
+      interrupted
+    };
+  };
+  try {
+    if (shouldAttemptSandbox) {
+      const sandboxCmd = buildSandboxCommand({
+        command,
+        sandbox,
+        cwd: state.cwd
+      });
+      if (!sandboxCmd) {
+        if (sandbox?.require) {
+          return {
+            stdout: "",
+            stderr: "System sandbox is required but unavailable (missing bubblewrap or unsupported platform).",
+            code: 2,
+            interrupted: false
+          };
+        }
+        const fallback = await runOnce(
+          getShellCmdForPlatform(process.platform, command, process.env)
+        );
+        return {
+          ...fallback,
+          stderr: `[sandbox] unavailable, ran without isolation.
+${fallback.stderr}`.trim()
+        };
+      }
+      const sandboxed = await runOnce(sandboxCmd.cmd);
+      sandboxed.stderr = maybeAnnotateMacosSandboxStderr(
+        sandboxed.stderr,
+        sandbox
+      );
+      if (!sandboxed.interrupted && sandboxed.code !== 0 && isSandboxInitFailure(sandboxed.stderr) && !sandbox?.require) {
+        const fallback = await runOnce(
+          getShellCmdForPlatform(process.platform, command, process.env)
+        );
+        return {
+          ...fallback,
+          stderr: `[sandbox] failed to start, ran without isolation.
+${fallback.stderr}`.trim()
+        };
+      }
+      return sandboxed;
+    }
+    return await runOnce(
+      getShellCmdForPlatform(process.platform, command, process.env)
+    );
+  } catch (error) {
+    if (state.abortController?.signal.aborted) {
+      state.currentProcess?.kill();
+      return {
+        stdout: "",
+        stderr: "Command was interrupted",
+        code: 143,
+        interrupted: true
+      };
+    }
+    const errorStr = error instanceof Error ? error.message : String(error);
+    logError2(`Shell execution error: ${errorStr}`);
+    return {
+      stdout: "",
+      stderr: errorStr,
+      code: 2,
+      interrupted: false
+    };
+  } finally {
+    if (abortSignal) {
+      abortSignal.removeEventListener("abort", onAbort);
+    }
+    state.currentProcess = null;
+    state.abortController = null;
+  }
+}
+
+// packages/runtime/src/shell/execPromotable.ts
+import { spawn as spawn2 } from "node:child_process";
+
+// packages/runtime/src/taskOutputStore.ts
+import {
+  appendFileSync,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  readFileSync,
+  statSync as statSync2,
+  writeFileSync
+} from "fs";
+import { dirname as dirname3, join } from "path";
+import { homedir as homedir2 } from "os";
+function getKodeBaseDir() {
+  return process.env.KODE_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR ?? join(homedir2(), ".kode");
+}
+function getProjectDir(cwd) {
+  return cwd.replace(/[^a-zA-Z0-9]/g, "-");
+}
+var PROJECT_ROOT = process.cwd();
+function getTaskOutputsDir() {
+  return join(getKodeBaseDir(), getProjectDir(PROJECT_ROOT), "tasks");
+}
+function getTaskOutputFilePath(taskId) {
+  return join(getTaskOutputsDir(), `${taskId}.output`);
+}
+function ensureTaskOutputsDirExists() {
+  const dir = getTaskOutputsDir();
+  if (existsSync4(dir)) return;
+  mkdirSync2(dir, { recursive: true });
+}
+function touchTaskOutputFile(taskId) {
+  ensureTaskOutputsDirExists();
+  const filePath = getTaskOutputFilePath(taskId);
+  if (!existsSync4(filePath)) {
+    const parent = dirname3(filePath);
+    if (!existsSync4(parent)) mkdirSync2(parent, { recursive: true });
+    writeFileSync(filePath, "", "utf8");
+  }
+  return filePath;
+}
+function appendTaskOutput(taskId, chunk) {
+  try {
+    ensureTaskOutputsDirExists();
+    appendFileSync(getTaskOutputFilePath(taskId), chunk, "utf8");
+  } catch {
+  }
+}
+function readTaskOutput(taskId) {
+  try {
+    const filePath = getTaskOutputFilePath(taskId);
+    if (!existsSync4(filePath)) return "";
+    return readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+// packages/runtime/src/shell/ids.ts
+import { randomUUID } from "crypto";
+function makeBackgroundTaskId() {
+  return `b${randomUUID().replace(/-/g, "").slice(0, 6)}`;
+}
+
+// packages/runtime/src/shell/execPromotable.ts
+function normalizeExitCode2(code, interrupted) {
+  if (typeof code === "number" && Number.isFinite(code)) return code;
+  return interrupted ? 143 : 0;
+}
+function execPromotable(state, command, abortSignal, timeout, options) {
+  const DEFAULT_TIMEOUT = 12e4;
+  const commandTimeout = timeout ?? DEFAULT_TIMEOUT;
+  const startedAt = Date.now();
+  const sandbox = options?.sandbox;
+  const shouldAttemptSandbox = sandbox?.enabled === true;
+  const executionCwd = shouldAttemptSandbox && sandbox?.chdir ? sandbox.chdir : state.cwd;
+  if (abortSignal?.aborted) {
+    return {
+      get status() {
+        return "killed";
+      },
+      background: () => null,
+      kill: () => {
+      },
+      result: Promise.resolve({
+        stdout: "",
+        stderr: "Command aborted before execution",
+        code: 145,
+        interrupted: true
+      })
+    };
+  }
+  const sandboxCmd = shouldAttemptSandbox ? buildSandboxCommand({ command, sandbox, cwd: state.cwd }) : null;
+  if (shouldAttemptSandbox && sandbox?.require && !sandboxCmd) {
+    return {
+      get status() {
+        return "killed";
+      },
+      background: () => null,
+      kill: () => {
+      },
+      result: Promise.resolve({
+        stdout: "",
+        stderr: "System sandbox is required but unavailable (missing bubblewrap or unsupported platform).",
+        code: 2,
+        interrupted: false
+      })
+    };
+  }
+  const cmdToRun = sandboxCmd ? sandboxCmd.cmd : getShellCmdForPlatform(process.platform, command, process.env);
+  const internalAbortController = new AbortController();
+  state.abortController = internalAbortController;
+  let status = "running";
+  let backgroundProcess = null;
+  let backgroundTaskId = null;
+  let stdout = "";
+  let stderr = "";
+  let wasAborted = false;
+  let wasBackgrounded = false;
+  let timeoutHandle = null;
+  let timedOut = false;
+  let onTimeoutCb = null;
+  const countNonEmptyLines = (chunk) => chunk.split("\n").filter((line) => line.length > 0).length;
+  const spawnedProcess = spawn2(cmdToRun[0], cmdToRun.slice(1), {
+    cwd: executionCwd,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  state.currentProcess = spawnedProcess;
+  const exitPromise = new Promise((resolve3) => {
+    spawnedProcess.once("exit", (code) => resolve3({ kind: "exit", code }));
+    spawnedProcess.once("error", (error) => resolve3({ kind: "error", error }));
+  });
+  const onAbort = () => {
+    if (status === "backgrounded") return;
+    wasAborted = true;
+    try {
+      internalAbortController.abort();
+    } catch {
+    }
+    try {
+      spawnedProcess.kill();
+    } catch {
+    }
+    if (backgroundProcess) backgroundProcess.interrupted = true;
+  };
+  const clearForegroundGuards = () => {
+    if (timeoutHandle) {
+      clearTimeout(timeoutHandle);
+      timeoutHandle = null;
+    }
+    if (abortSignal) {
+      abortSignal.removeEventListener("abort", onAbort);
+    }
+  };
+  if (abortSignal) {
+    abortSignal.addEventListener("abort", onAbort, { once: true });
+    if (abortSignal.aborted) onAbort();
+  }
+  const stdoutCollector = createCancellableTextCollector(
+    spawnedProcess.stdout,
+    {
+      collectText: false,
+      onChunk: (chunk) => {
+        stdout += chunk;
+        options?.onStdoutChunk?.(chunk);
+        if (backgroundProcess) {
+          backgroundProcess.stdout = stdout;
+          appendTaskOutput(backgroundProcess.id, chunk);
+          backgroundProcess.stdoutLineCount += countNonEmptyLines(chunk);
+        }
+      }
+    }
+  );
+  const stderrCollector = createCancellableTextCollector(
+    spawnedProcess.stderr,
+    {
+      collectText: false,
+      onChunk: (chunk) => {
+        stderr += chunk;
+        options?.onStderrChunk?.(chunk);
+        if (backgroundProcess) {
+          backgroundProcess.stderr = stderr;
+          appendTaskOutput(backgroundProcess.id, chunk);
+          backgroundProcess.stderrLineCount += countNonEmptyLines(chunk);
+        }
+      }
+    }
+  );
+  timeoutHandle = setTimeout(() => {
+    if (status !== "running") return;
+    if (onTimeoutCb) {
+      onTimeoutCb(background);
+      return;
+    }
+    timedOut = true;
+    try {
+      spawnedProcess.kill();
+    } catch {
+    }
+    try {
+      internalAbortController.abort();
+    } catch {
+    }
+  }, commandTimeout);
+  const background = (bashId) => {
+    if (backgroundTaskId) return { bashId: backgroundTaskId };
+    if (status !== "running") return null;
+    backgroundTaskId = bashId ?? makeBackgroundTaskId();
+    const outputFile = touchTaskOutputFile(backgroundTaskId);
+    if (stdout) appendTaskOutput(backgroundTaskId, stdout);
+    if (stderr) appendTaskOutput(backgroundTaskId, stderr);
+    status = "backgrounded";
+    wasBackgrounded = true;
+    clearForegroundGuards();
+    backgroundProcess = {
+      id: backgroundTaskId,
+      command,
+      stdout,
+      stderr,
+      stdoutCursor: 0,
+      stderrCursor: 0,
+      stdoutLineCount: countNonEmptyLines(stdout),
+      stderrLineCount: countNonEmptyLines(stderr),
+      lastReportedStdoutLines: 0,
+      lastReportedStderrLines: 0,
+      code: null,
+      interrupted: false,
+      killed: false,
+      timedOut: false,
+      completionStatusSentInAttachment: false,
+      notified: false,
+      startedAt,
+      timeoutAt: Number.POSITIVE_INFINITY,
+      process: spawnedProcess,
+      abortController: internalAbortController,
+      timeoutHandle: null,
+      cwd: executionCwd,
+      outputFile
+    };
+    state.backgroundProcesses.set(backgroundTaskId, backgroundProcess);
+    state.currentProcess = null;
+    state.abortController = null;
+    return { bashId: backgroundTaskId };
+  };
+  const kill = () => {
+    status = "killed";
+    try {
+      spawnedProcess.kill();
+    } catch {
+    }
+    try {
+      internalAbortController.abort();
+    } catch {
+    }
+    if (backgroundProcess) {
+      backgroundProcess.interrupted = true;
+      backgroundProcess.killed = true;
+    }
+  };
+  const result = (async () => {
+    try {
+      const exitOutcome = await exitPromise;
+      if (exitOutcome.kind === "error") {
+        stderr = [stderr, exitOutcome.error.message].filter(Boolean).join("\n");
+      }
+      if (status === "running" || status === "backgrounded")
+        status = "completed";
+      if (backgroundProcess) {
+        backgroundProcess.code = exitOutcome.kind === "exit" ? exitOutcome.code ?? 0 : 2;
+        backgroundProcess.interrupted = backgroundProcess.interrupted || wasAborted || internalAbortController.signal.aborted;
+      }
+      if (!wasBackgrounded) {
+        await Promise.race([
+          Promise.allSettled([stdoutCollector.done, stderrCollector.done]),
+          new Promise((resolve3) => setTimeout(resolve3, 250))
+        ]);
+        await Promise.allSettled([
+          stdoutCollector.cancel(),
+          stderrCollector.cancel()
+        ]);
+      }
+      const interrupted = wasAborted || abortSignal?.aborted === true || internalAbortController.signal.aborted === true || timedOut;
+      let code = exitOutcome.kind === "exit" ? exitOutcome.code : null;
+      if (exitOutcome.kind === "error") code = 2;
+      const stderrWithTimeout = timedOut ? [`Command timed out`, stderr].filter(Boolean).join("\n") : stderr;
+      const stderrAnnotated = sandboxCmd ? maybeAnnotateMacosSandboxStderr(stderrWithTimeout, sandbox) : stderrWithTimeout;
+      return {
+        stdout,
+        stderr: stderrAnnotated,
+        code: normalizeExitCode2(code, interrupted),
+        interrupted
+      };
+    } finally {
+      clearForegroundGuards();
+      if (state.currentProcess === spawnedProcess) {
+        state.currentProcess = null;
+        state.abortController = null;
+      }
+    }
+  })();
+  const execHandle = {
+    get status() {
+      return status;
+    },
+    background,
+    kill,
+    result
+  };
+  execHandle.onTimeout = (cb) => {
+    onTimeoutCb = cb;
+  };
+  result.then((r) => {
+    if (!backgroundProcess || !backgroundTaskId) return;
+    backgroundProcess.code = r.code;
+    backgroundProcess.interrupted = r.interrupted;
+  }).catch(() => {
+    if (!backgroundProcess) return;
+    backgroundProcess.code = backgroundProcess.code ?? 2;
+  });
+  return execHandle;
+}
+
+// packages/runtime/src/shell/background.ts
+import { spawn as spawn3 } from "node:child_process";
+function execInBackground(state, command, timeout, options) {
+  const DEFAULT_TIMEOUT = 12e4;
+  const commandTimeout = timeout ?? DEFAULT_TIMEOUT;
+  const abortController = new AbortController();
+  const sandbox = options?.sandbox;
+  const sandboxCmd = sandbox?.enabled === true ? buildSandboxCommand({ command, sandbox, cwd: state.cwd }) : null;
+  const executionCwd = sandbox?.enabled === true && sandbox?.chdir ? sandbox.chdir : state.cwd;
+  if (sandbox?.enabled === true && sandbox?.require && !sandboxCmd) {
+    throw new Error(
+      "System sandbox is required but unavailable (missing bubblewrap or unsupported platform)."
+    );
+  }
+  const cmdToRun = sandboxCmd ? sandboxCmd.cmd : getShellCmdForPlatform(process.platform, command, process.env);
+  const bashId = makeBackgroundTaskId();
+  const outputFile = touchTaskOutputFile(bashId);
+  const childProcess = spawn3(cmdToRun[0], cmdToRun.slice(1), {
+    cwd: executionCwd,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const exitPromise = new Promise((resolve3) => {
+    childProcess.once("exit", (code) => resolve3({ kind: "exit", code }));
+    childProcess.once("error", (error) => resolve3({ kind: "error", error }));
+  });
+  const timeoutHandle = setTimeout(() => {
+    abortController.abort();
+    backgroundProcess.timedOut = true;
+    childProcess.kill();
+  }, commandTimeout);
+  const backgroundProcess = {
+    id: bashId,
+    command,
+    stdout: "",
+    stderr: "",
+    stdoutCursor: 0,
+    stderrCursor: 0,
+    stdoutLineCount: 0,
+    stderrLineCount: 0,
+    lastReportedStdoutLines: 0,
+    lastReportedStderrLines: 0,
+    code: null,
+    interrupted: false,
+    killed: false,
+    timedOut: false,
+    completionStatusSentInAttachment: false,
+    notified: false,
+    startedAt: Date.now(),
+    timeoutAt: Date.now() + commandTimeout,
+    process: childProcess,
+    abortController,
+    timeoutHandle,
+    cwd: executionCwd,
+    outputFile
+  };
+  const countNonEmptyLines = (chunk) => chunk.split("\n").filter((line) => line.length > 0).length;
+  startStreamReader(childProcess.stdout, (chunk) => {
+    backgroundProcess.stdout += chunk;
+    appendTaskOutput(bashId, chunk);
+    backgroundProcess.stdoutLineCount += countNonEmptyLines(chunk);
+  });
+  startStreamReader(childProcess.stderr, (chunk) => {
+    backgroundProcess.stderr += chunk;
+    appendTaskOutput(bashId, chunk);
+    backgroundProcess.stderrLineCount += countNonEmptyLines(chunk);
+  });
+  exitPromise.then((exitOutcome) => {
+    backgroundProcess.code = exitOutcome.kind === "exit" ? exitOutcome.code ?? 0 : 2;
+    if (exitOutcome.kind === "error") {
+      backgroundProcess.stderr = [
+        backgroundProcess.stderr,
+        exitOutcome.error.message
+      ].filter(Boolean).join("\n");
+    }
+    backgroundProcess.interrupted = backgroundProcess.interrupted || abortController.signal.aborted;
+    if (sandbox?.enabled === true) {
+      backgroundProcess.stderr = maybeAnnotateMacosSandboxStderr(
+        backgroundProcess.stderr,
+        sandbox
+      );
+    }
+    if (backgroundProcess.timeoutHandle) {
+      clearTimeout(backgroundProcess.timeoutHandle);
+      backgroundProcess.timeoutHandle = null;
+    }
+  });
+  state.backgroundProcesses.set(bashId, backgroundProcess);
+  return { bashId };
+}
+function getBackgroundOutput(state, shellId) {
+  const proc = state.backgroundProcesses.get(shellId);
+  if (!proc) return null;
+  const running = proc.code === null && !proc.interrupted;
+  return {
+    stdout: proc.stdout,
+    stderr: proc.stderr,
+    code: proc.code,
+    interrupted: proc.interrupted,
+    killed: proc.killed,
+    timedOut: proc.timedOut,
+    running,
+    command: proc.command,
+    cwd: proc.cwd,
+    startedAt: proc.startedAt,
+    timeoutAt: proc.timeoutAt,
+    outputFile: proc.outputFile
+  };
+}
+function readBackgroundOutput(state, bashId, options) {
+  const proc = state.backgroundProcesses.get(bashId);
+  if (!proc) return null;
+  const stdoutDelta = proc.stdout.slice(proc.stdoutCursor);
+  const stderrDelta = proc.stderr.slice(proc.stderrCursor);
+  proc.stdoutCursor = proc.stdout.length;
+  proc.stderrCursor = proc.stderr.length;
+  const stdoutLines = stdoutDelta === "" ? 0 : stdoutDelta.split("\n").length;
+  const stderrLines = stderrDelta === "" ? 0 : stderrDelta.split("\n").length;
+  let stdoutToReturn = stdoutDelta;
+  let stderrToReturn = stderrDelta;
+  const filter = options?.filter?.trim();
+  if (filter) {
+    const regex = new RegExp(filter, "i");
+    stdoutToReturn = stdoutDelta.split("\n").filter((line) => regex.test(line)).join("\n");
+    stderrToReturn = stderrDelta.split("\n").filter((line) => regex.test(line)).join("\n");
+  }
+  const status = proc.killed ? "killed" : proc.code === null ? "running" : proc.code === 0 ? "completed" : "failed";
+  return {
+    shellId: bashId,
+    command: proc.command,
+    cwd: proc.cwd,
+    startedAt: proc.startedAt,
+    timeoutAt: proc.timeoutAt,
+    status,
+    exitCode: proc.code,
+    stdout: stdoutToReturn,
+    stderr: stderrToReturn,
+    stdoutLines,
+    stderrLines,
+    ...filter ? { filterPattern: filter } : {}
+  };
+}
+function killBackgroundShell(state, shellId) {
+  const proc = state.backgroundProcesses.get(shellId);
+  if (!proc) return false;
+  try {
+    proc.interrupted = true;
+    proc.killed = true;
+    proc.abortController.abort();
+    proc.process.kill();
+    if (proc.timeoutHandle) {
+      clearTimeout(proc.timeoutHandle);
+      proc.timeoutHandle = null;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listBackgroundShells(state) {
+  return Array.from(state.backgroundProcesses.values());
+}
+function flushBashNotifications(state) {
+  const processes = Array.from(state.backgroundProcesses.values());
+  const statusFor = (proc) => proc.killed ? "killed" : proc.code === null ? "running" : proc.code === 0 ? "completed" : "failed";
+  const notifications = [];
+  for (const proc of processes) {
+    if (proc.notified) continue;
+    const status = statusFor(proc);
+    if (status === "running") continue;
+    notifications.push({
+      type: "bash_notification",
+      taskId: proc.id,
+      description: proc.command,
+      outputFile: proc.outputFile || getTaskOutputFilePath(proc.id),
+      status,
+      ...proc.code !== null ? { exitCode: proc.code } : {}
+    });
+    proc.notified = true;
+  }
+  return notifications;
+}
+function flushBackgroundShellStatusAttachments(state) {
+  const processes = Array.from(state.backgroundProcesses.values());
+  const statusFor = (proc) => proc.killed ? "killed" : proc.code === null ? "running" : proc.code === 0 ? "completed" : "failed";
+  const progressAttachments = [];
+  for (const proc of processes) {
+    if (statusFor(proc) !== "running") continue;
+    const stdoutDelta = proc.stdoutLineCount - proc.lastReportedStdoutLines;
+    const stderrDelta = proc.stderrLineCount - proc.lastReportedStderrLines;
+    if (stdoutDelta === 0 && stderrDelta === 0) continue;
+    proc.lastReportedStdoutLines = proc.stdoutLineCount;
+    proc.lastReportedStderrLines = proc.stderrLineCount;
+    progressAttachments.push({
+      type: "task_progress",
+      taskId: proc.id,
+      stdoutLineDelta: stdoutDelta,
+      stderrLineDelta: stderrDelta,
+      outputFile: proc.outputFile || getTaskOutputFilePath(proc.id)
+    });
+  }
+  return progressAttachments;
+}
+
+// packages/runtime/src/shell/BunShell.ts
+var BunShell = class _BunShell {
+  state;
+  constructor(cwd) {
+    this.state = createInitialState(cwd);
+  }
+  static instance = null;
+  static restart() {
+    if (_BunShell.instance) {
+      _BunShell.instance.close();
+      _BunShell.instance = null;
+    }
+  }
+  static getInstance() {
+    if (!_BunShell.instance || !_BunShell.instance.state.isAlive) {
+      _BunShell.instance = new _BunShell(process.cwd());
+    }
+    return _BunShell.instance;
+  }
+  static getShellCmdForPlatform(platform, command, env = process.env) {
+    return getShellCmdForPlatform(platform, command, env);
+  }
+  execPromotable(command, abortSignal, timeout, options) {
+    return execPromotable(this.state, command, abortSignal, timeout, options);
+  }
+  async exec(command, abortSignal, timeout, options) {
+    return exec(this.state, command, abortSignal, timeout, options);
+  }
+  execInBackground(command, timeout, options) {
+    return execInBackground(this.state, command, timeout, options);
+  }
+  getBackgroundOutput(shellId) {
+    return getBackgroundOutput(this.state, shellId);
+  }
+  readBackgroundOutput(bashId, options) {
+    return readBackgroundOutput(this.state, bashId, options);
+  }
+  killBackgroundShell(shellId) {
+    return killBackgroundShell(this.state, shellId);
+  }
+  listBackgroundShells() {
+    return listBackgroundShells(this.state);
+  }
+  pwd() {
+    return this.state.cwd;
+  }
+  async setCwd(cwd) {
+    const resolved = isAbsolute2(cwd) ? cwd : resolve2(this.state.cwd, cwd);
+    if (!existsSync5(resolved)) {
+      throw new Error(`Path "${resolved}" does not exist`);
+    }
+    this.state.cwd = resolved;
+  }
+  killChildren() {
+    this.state.abortController?.abort();
+    this.state.currentProcess?.kill();
+    for (const bg of Array.from(this.state.backgroundProcesses.keys())) {
+      killBackgroundShell(this.state, bg);
+    }
+  }
+  close() {
+    this.state.isAlive = false;
+    this.killChildren();
+  }
+  flushBashNotifications() {
+    return flushBashNotifications(this.state);
+  }
+  flushBackgroundShellStatusAttachments() {
+    return flushBackgroundShellStatusAttachments(this.state);
+  }
+};
+
+// packages/runtime/src/shell/notifications.ts
+function renderBackgroundShellStatusAttachment(attachment) {
+  const parts = [];
+  if (attachment.stdoutLineDelta > 0) {
+    const n = attachment.stdoutLineDelta;
+    parts.push(`${n} line${n > 1 ? "s" : ""} of stdout`);
+  }
+  if (attachment.stderrLineDelta > 0) {
+    const n = attachment.stderrLineDelta;
+    parts.push(`${n} line${n > 1 ? "s" : ""} of stderr`);
+  }
+  if (parts.length === 0) return "";
+  return `Background bash ${attachment.taskId} has new output: ${parts.join(", ")}. Read ${attachment.outputFile} to see output.`;
+}
+function renderBashNotification(notification) {
+  const status = notification.status;
+  const exitCode = notification.exitCode;
+  const summarySuffix = status === "completed" ? `completed${exitCode !== void 0 ? ` (exit code ${exitCode})` : ""}` : status === "failed" ? `failed${exitCode !== void 0 ? ` with exit code ${exitCode}` : ""}` : "was killed";
+  return [
+    "<bash-notification>",
+    `<shell-id>${notification.taskId}</shell-id>`,
+    `<output-file>${notification.outputFile || getTaskOutputFilePath(notification.taskId)}</output-file>`,
+    `<status>${status}</status>`,
+    `<summary>Background command "${notification.description}" ${summarySuffix}.</summary>`,
+    "Read the output file to retrieve the output.",
+    "</bash-notification>"
+  ].join("\n");
+}
+
+export {
+  getTaskOutputFilePath,
+  readTaskOutput,
+  renderBackgroundShellStatusAttachment,
+  renderBashNotification,
+  BunShell
+};