@tangle-network/agent-app 0.22.0 → 0.24.0

package/dist/chunk-XDCHKFBX.js

@@ -0,0 +1,897 @@
+import {
+  assertHarnessModelCompatible
+} from "./chunk-5VXPDXZJ.js";
+import {
+  buildAppToolMcpServer
+} from "./chunk-A76ZHWNF.js";
+
+// src/sandbox/index.ts
+import {
+  Sandbox
+} from "@tangle-network/sandbox";
+
+// src/sandbox/workspace-terminal.ts
+function createWorkspaceSandboxManager(opts) {
+  return {
+    async ensureWorkspaceSandbox(workspaceId, userId, options) {
+      if (!workspaceId) throw new Error("workspaceId is required");
+      if (!userId) throw new Error("userId is required");
+      const ctx = { workspaceId, userId };
+      const client = await opts.getClient(ctx);
+      const name = opts.nameForWorkspace(workspaceId, ctx);
+      let listError;
+      let existing = [];
+      try {
+        existing = await opts.listSandboxes(client, ctx);
+      } catch (err) {
+        listError = err;
+        opts.onListError?.(err, ctx);
+      }
+      const found = existing.find((box) => box.name === name);
+      if (found) {
+        return await opts.prepareExisting?.(found, ctx, options) ?? found;
+      }
+      const created = await opts.createSandbox({
+        client,
+        ctx,
+        name,
+        options,
+        listError
+      });
+      await opts.waitForRunning?.(created, ctx);
+      return await opts.prepareCreated?.(created, ctx, options) ?? created;
+    }
+  };
+}
+var DEFAULT_TERMINAL_TOKEN_PREFIX = "sbxt_";
+var DEFAULT_TERMINAL_TOKEN_TTL_MS = 15 * 60 * 1e3;
+var BEARER_SUBPROTOCOL_PREFIX = "bearer.";
+async function createSandboxTerminalToken(subject, opts) {
+  validateTerminalSubject(subject);
+  const secret = opts.secret?.trim();
+  if (!secret) throw new Error("terminal token secret is required");
+  const now = opts.now ?? Date.now;
+  const expiresInMs = opts.expiresInMs ?? DEFAULT_TERMINAL_TOKEN_TTL_MS;
+  if (!Number.isFinite(expiresInMs) || expiresInMs <= 0) throw new Error("expiresInMs must be a positive number");
+  const expiresAt = new Date(now() + expiresInMs);
+  const payload = {
+    ...subject,
+    exp: Math.floor(expiresAt.getTime() / 1e3),
+    n: crypto.randomUUID()
+  };
+  const encodedPayload = base64urlText(JSON.stringify(payload));
+  const signature = await signText(encodedPayload, secret);
+  return {
+    token: `${opts.prefix ?? DEFAULT_TERMINAL_TOKEN_PREFIX}${encodedPayload}.${signature}`,
+    expiresAt
+  };
+}
+async function verifySandboxTerminalToken(token, expected, opts) {
+  validateTerminalSubject(expected);
+  const secret = opts.secret?.trim();
+  const prefix = opts.prefix ?? DEFAULT_TERMINAL_TOKEN_PREFIX;
+  if (!secret || !token.startsWith(prefix)) return false;
+  const body = token.slice(prefix.length);
+  const dot = body.lastIndexOf(".");
+  if (dot <= 0 || dot === body.length - 1) return false;
+  const encodedPayload = body.slice(0, dot);
+  const signature = body.slice(dot + 1);
+  if (!timingSafeEqual(signature, await signText(encodedPayload, secret))) return false;
+  let payload;
+  try {
+    payload = JSON.parse(textFromBase64url(encodedPayload));
+  } catch {
+    return false;
+  }
+  const now = opts.now ?? Date.now;
+  return payload.userId === expected.userId && payload.workspaceId === expected.workspaceId && payload.sandboxId === expected.sandboxId && Number.isFinite(payload.exp) && payload.exp > Math.floor(now() / 1e3);
+}
+function createWorkspaceSandboxConnectionHandler(opts) {
+  return async function handleWorkspaceSandboxConnection({ request, params }) {
+    const user = await opts.requireUser(request);
+    const workspaceId = params.workspaceId;
+    if (!workspaceId) return Response.json({ error: "workspaceId is required" }, { status: 400 });
+    await opts.requireWorkspaceAccess({ request, userId: user.id, workspaceId });
+    let box;
+    try {
+      box = await opts.ensureWorkspaceSandbox(workspaceId, user.id);
+    } catch (err) {
+      return Response.json(
+        { error: err instanceof Error ? err.message : "Failed to provision workspace sandbox" },
+        { status: 500 }
+      );
+    }
+    const directSidecarUrl = box.connection?.sidecarUrl ?? (box.connection?.authToken ? box.connection?.runtimeUrl : void 0);
+    const directSidecarToken = box.connection?.authToken ?? box.connection?.sidecarToken;
+    const directSidecarExpiresAt = box.connection?.authTokenExpiresAt;
+    if (opts.exposeDirectSidecar && directSidecarUrl && directSidecarToken && directSidecarExpiresAt) {
+      return Response.json({
+        runtimeUrl: directSidecarUrl,
+        sidecarUrl: directSidecarUrl,
+        token: directSidecarToken,
+        expiresAt: directSidecarExpiresAt,
+        status: box.status,
+        sandboxId: box.id
+      });
+    }
+    if (!box.connection?.runtimeUrl) {
+      return Response.json(
+        {
+          error: "Workspace sandbox runtime not ready. The sandbox is still initializing -- retry in a few seconds.",
+          status: box.status
+        },
+        { status: 503 }
+      );
+    }
+    const secret = typeof opts.tokenSecret === "function" ? opts.tokenSecret() : opts.tokenSecret;
+    let scoped;
+    try {
+      scoped = await createSandboxTerminalToken(
+        { userId: user.id, workspaceId, sandboxId: box.id },
+        { secret, expiresInMs: opts.tokenExpiresInMs, prefix: opts.tokenPrefix }
+      );
+    } catch (err) {
+      return Response.json(
+        { error: err instanceof Error ? err.message : "Failed to mint sandbox token" },
+        { status: 503 }
+      );
+    }
+    const runtimeUrl = opts.proxyRuntimeUrl ? opts.proxyRuntimeUrl({ request, workspaceId, sandboxId: box.id, box }) : `/api/workspaces/${encodeURIComponent(workspaceId)}/sandbox/runtime/${encodeURIComponent(box.id)}`;
+    return Response.json({
+      runtimeUrl,
+      sidecarUrl: runtimeUrl,
+      token: scoped.token,
+      expiresAt: scoped.expiresAt.toISOString(),
+      status: box.status,
+      sandboxId: box.id
+    });
+  };
+}
+function createWorkspaceSandboxRuntimeProxyHandler(opts) {
+  return async function handleWorkspaceSandboxRuntimeProxy({ request, params }) {
+    const user = await opts.requireUser(request);
+    const workspaceId = params.workspaceId;
+    const sandboxId = params.sandboxId;
+    const runtimePath = params["*"];
+    if (!workspaceId || !sandboxId || !runtimePath) {
+      return Response.json({ error: "workspaceId, sandboxId, and runtime path are required" }, { status: 400 });
+    }
+    const encodedRuntimePath = encodeSandboxRuntimePath(runtimePath);
+    if (!encodedRuntimePath) return Response.json({ error: "Invalid sandbox runtime path" }, { status: 400 });
+    await opts.requireWorkspaceAccess({ request, userId: user.id, workspaceId, sandboxId });
+    const token = terminalTokenFromRequest(request.headers);
+    const secret = typeof opts.tokenSecret === "function" ? opts.tokenSecret() : opts.tokenSecret;
+    if (!token || !await verifySandboxTerminalToken(token, { userId: user.id, workspaceId, sandboxId }, { secret, prefix: opts.tokenPrefix })) {
+      return Response.json({ error: "Invalid terminal token" }, { status: 403 });
+    }
+    const requestUrl = new URL(request.url);
+    const runtimeConnection = await opts.getSandboxRuntimeConnection?.({ request, userId: user.id, workspaceId, sandboxId });
+    const credentials = runtimeConnection ? null : await opts.getSandboxApiCredentials({ request, userId: user.id, workspaceId, sandboxId });
+    const upstreamUrl = runtimeConnection ? new URL(encodedRuntimePath, `${runtimeConnection.runtimeUrl.replace(/\/+$/, "")}/`) : new URL(
+      `/v1/sandboxes/${encodeURIComponent(sandboxId)}/runtime/${encodedRuntimePath}`,
+      credentials.baseUrl
+    );
+    upstreamUrl.search = requestUrl.search;
+    const headers = buildSandboxRuntimeProxyHeaders(
+      request.headers,
+      runtimeConnection?.authToken ?? credentials.apiKey,
+      opts.forwardHeaders
+    );
+    const init = {
+      method: request.method,
+      headers,
+      redirect: "manual"
+    };
+    if (request.method !== "GET" && request.method !== "HEAD" && request.body) {
+      init.body = request.body;
+      init.duplex = "half";
+    }
+    const fetchImpl = opts.fetch ?? fetch;
+    const response = await fetchImpl(upstreamUrl, init);
+    const responseHeaders = new Headers(response.headers);
+    responseHeaders.delete("set-cookie");
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: responseHeaders
+    });
+  };
+}
+var SANDBOX_TERMINAL_WS_PATHNAME = /^\/api\/workspaces\/([^/]+)\/sandbox\/runtime\/([^/]+)\/(terminals\/[^/]+\/ws)$/;
+function matchSandboxTerminalWsPath(pathname) {
+  const m = SANDBOX_TERMINAL_WS_PATHNAME.exec(pathname);
+  if (!m) return null;
+  const [, workspaceId, sandboxId, subPath] = m;
+  if (!workspaceId || !sandboxId || !subPath) return null;
+  return { workspaceId: decodeURIComponent(workspaceId), sandboxId: decodeURIComponent(sandboxId), subPath };
+}
+function isSandboxTerminalWsUpgrade(request) {
+  if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket") return false;
+  try {
+    return matchSandboxTerminalWsPath(new URL(request.url).pathname) !== null;
+  } catch {
+    return false;
+  }
+}
+function createWorkspaceSandboxTerminalUpgradeHandler(opts) {
+  return async function handleWorkspaceSandboxTerminalUpgrade(request) {
+    if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket") return null;
+    let url;
+    try {
+      url = new URL(request.url);
+    } catch {
+      return null;
+    }
+    const match = matchSandboxTerminalWsPath(url.pathname);
+    if (!match) return null;
+    const { workspaceId, sandboxId, subPath } = match;
+    let user;
+    try {
+      user = await opts.requireUser(request);
+    } catch {
+      return new Response("Unauthorized", { status: 401 });
+    }
+    try {
+      await opts.requireWorkspaceAccess({ request, userId: user.id, workspaceId, sandboxId });
+    } catch {
+      return new Response("Forbidden", { status: 403 });
+    }
+    const token = terminalTokenFromRequest(request.headers);
+    const secret = typeof opts.tokenSecret === "function" ? opts.tokenSecret() : opts.tokenSecret;
+    if (!token || !await verifySandboxTerminalToken(token, { userId: user.id, workspaceId, sandboxId }, { secret, prefix: opts.tokenPrefix })) {
+      return new Response("Invalid terminal token", { status: 403 });
+    }
+    const runtimeConnection = await opts.getSandboxRuntimeConnection?.({ request, userId: user.id, workspaceId, sandboxId });
+    const credentials = runtimeConnection ? null : await opts.getSandboxApiCredentials({ request, userId: user.id, workspaceId, sandboxId });
+    const upstreamUrl = runtimeConnection ? new URL(subPath, `${runtimeConnection.runtimeUrl.replace(/\/+$/, "")}/`) : new URL(`/v1/sandboxes/${encodeURIComponent(sandboxId)}/runtime/${subPath}`, credentials.baseUrl);
+    upstreamUrl.search = url.search;
+    const upstreamHeaders = new Headers(request.headers);
+    upstreamHeaders.set("Authorization", `Bearer ${runtimeConnection?.authToken ?? credentials.apiKey}`);
+    upstreamHeaders.delete("host");
+    const fetchImpl = opts.fetch ?? fetch;
+    return fetchImpl(upstreamUrl.toString(), { method: request.method, headers: upstreamHeaders });
+  };
+}
+var DEFAULT_RUNTIME_PROXY_HEADERS = ["accept", "content-type", "last-event-id", "x-session-id"];
+function buildSandboxRuntimeProxyHeaders(source, sandboxApiKey, forwardHeaders = DEFAULT_RUNTIME_PROXY_HEADERS) {
+  const headers = new Headers();
+  headers.set("Authorization", `Bearer ${sandboxApiKey}`);
+  for (const name of forwardHeaders) {
+    const value = source.get(name);
+    if (value) headers.set(name, value);
+  }
+  return headers;
+}
+function encodeSandboxRuntimePath(runtimePath) {
+  const segments = runtimePath.split("/");
+  if (segments.some((segment) => !segment || segment === "." || segment === "..")) return null;
+  return segments.map((segment) => encodeURIComponent(segment)).join("/");
+}
+function bearerToken(value) {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (trimmed.toLowerCase() === "bearer") return null;
+  if (trimmed.toLowerCase().startsWith("bearer ")) {
+    const token = trimmed.slice("bearer ".length).trim();
+    return token || null;
+  }
+  return trimmed;
+}
+function bearerSubprotocolToken(value) {
+  if (!value) return null;
+  for (const part of value.split(",")) {
+    const protocol = part.trim();
+    if (!protocol.toLowerCase().startsWith(BEARER_SUBPROTOCOL_PREFIX)) continue;
+    const encoded = protocol.slice(BEARER_SUBPROTOCOL_PREFIX.length);
+    if (!encoded) return null;
+    try {
+      const token = textFromBase64url(encoded).trim();
+      return token || null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function terminalTokenFromRequest(headers) {
+  return bearerToken(headers.get("Authorization")) ?? bearerSubprotocolToken(headers.get("Sec-WebSocket-Protocol"));
+}
+function validateTerminalSubject(subject) {
+  if (!subject.userId) throw new Error("userId is required");
+  if (!subject.workspaceId) throw new Error("workspaceId is required");
+  if (!subject.sandboxId) throw new Error("sandboxId is required");
+}
+async function signText(message, secret) {
+  const enc = new TextEncoder();
+  const key = await crypto.subtle.importKey("raw", enc.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  const sig = await crypto.subtle.sign("HMAC", key, enc.encode(message));
+  return base64url(new Uint8Array(sig));
+}
+function base64urlText(text) {
+  return base64url(new TextEncoder().encode(text));
+}
+function textFromBase64url(value) {
+  const b64 = value.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
+  const bin = atob(b64);
+  const bytes = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+  return new TextDecoder().decode(bytes);
+}
+function base64url(bytes) {
+  let s = "";
+  for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i]);
+  return btoa(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+
+// src/sandbox/index.ts
+var ok = (value) => ({ succeeded: true, value });
+var fail = (error) => ({
+  succeeded: false,
+  error: error instanceof Error ? error : new Error(String(error))
+});
+var DEFAULT_SANDBOX_RESOURCES = {
+  image: "universal",
+  cpuCores: 2,
+  memoryMB: 4096,
+  diskGB: 10,
+  maxLifetimeSeconds: 86400,
+  idleTimeoutSeconds: 3600
+};
+var _cached = null;
+function getClientFromCreds(creds) {
+  const fingerprint = `${creds.apiKey} ${creds.baseUrl}`;
+  if (_cached && _cached.fingerprint === fingerprint) return _cached.client;
+  const client = new Sandbox({ apiKey: creds.apiKey, baseUrl: creds.baseUrl });
+  _cached = { client, fingerprint };
+  return client;
+}
+function getClient(shell) {
+  const creds = shell.credentials();
+  if (creds && typeof creds.then === "function") {
+    throw new Error("getClient: scoped (async) credentials require the async sandbox path");
+  }
+  if (!creds) throw new Error("sandbox credentials are required (apiKey/baseUrl)");
+  return getClientFromCreds(creds);
+}
+function resetClientCache() {
+  _cached = null;
+}
+function buildAppToolMcpServers(options) {
+  const entries = {};
+  for (const { tool, key, description } of options.tools) {
+    entries[key] = buildAppToolMcpServer({
+      tool,
+      baseUrl: options.baseUrl,
+      token: options.token,
+      ctx: options.ctx,
+      description,
+      headerNames: options.headerNames
+    });
+  }
+  return entries;
+}
+function shellSingleQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+async function listRunning(client, name) {
+  try {
+    const running = await client.list({ status: "running" });
+    return ok(running.find((s) => s.name === name) ?? null);
+  } catch (err) {
+    return fail(err);
+  }
+}
+async function deleteBox(box) {
+  try {
+    await box.delete();
+    return ok(void 0);
+  } catch (err) {
+    return fail(err);
+  }
+}
+async function isBoxAlive(box, harness, probe) {
+  if (!probe) return true;
+  const execTimeout = probe.execTimeoutMs ?? 5e3;
+  const psTimeout = probe.psTimeoutMs ?? 3e3;
+  const race = (p, ms, label) => Promise.race([
+    p,
+    new Promise((_, reject) => setTimeout(() => reject(new Error(label)), ms))
+  ]);
+  try {
+    const alive = await race(box.exec("echo alive"), execTimeout, "alive check timeout");
+    if (!alive.stdout.includes("alive")) return false;
+    const pattern = probe.sidecarProcessPattern(harness);
+    try {
+      const ps = await race(
+        box.exec(`pgrep -f ${shellSingleQuote(pattern)} || echo no-sidecar`),
+        psTimeout,
+        "ps check timeout"
+      );
+      if (ps.stdout.includes("no-sidecar")) return false;
+    } catch {
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resumeStoppedBox(client, name, timeoutMs) {
+  try {
+    const stopped = await client.list({ status: "stopped" });
+    const match = stopped.find((s) => s.name === name) ?? null;
+    if (!match) return ok(null);
+    await match.resume();
+    await match.waitFor("running", { timeoutMs });
+    return ok(match);
+  } catch (err) {
+    return fail(err);
+  }
+}
+async function ensureWorkspaceSandbox(shell, options) {
+  const { workspaceId, userId, harness, forceNew } = options;
+  const scope = { workspaceId, ...userId ? { userId } : {} };
+  const creds = await shell.credentials(scope);
+  if (!creds) throw new Error("sandbox credentials are required (apiKey/baseUrl)");
+  const client = getClientFromCreds(creds);
+  const name = shell.boxKey ? shell.boxKey(scope) : shell.name(workspaceId);
+  const resources = shell.resources ?? DEFAULT_SANDBOX_RESOURCES;
+  const resumeTimeout = 12e4;
+  const existing = await listRunning(client, name);
+  if (existing.succeeded && existing.value) {
+    const found = existing.value;
+    if (forceNew) {
+      const dropped = await deleteBox(found);
+      if (!dropped.succeeded) {
+        throw new Error(`forceNew: sandbox ${name} could not be deleted`, { cause: dropped.error });
+      }
+    } else if (found.metadata?.harness === harness && await isBoxAlive(found, harness, shell.livenessProbe)) {
+      if (shell.bootstrap) {
+        const boot = await shell.bootstrap(found, scope);
+        if (!boot.succeeded) {
+          throw new Error(`bootstrap failed on reused box ${name}`, { cause: boot.error });
+        }
+      }
+      return found;
+    } else {
+      const dropped = await deleteBox(found);
+      if (!dropped.succeeded) {
+        throw new Error(
+          `sandbox ${name} (was ${String(found.metadata?.harness ?? "unknown")}, want ${harness}, or unresponsive) could not be deleted`,
+          { cause: dropped.error }
+        );
+      }
+    }
+  }
+  if (!forceNew && shell.resumeStopped !== false) {
+    const resumed = await resumeStoppedBox(client, name, resumeTimeout);
+    if (resumed.succeeded && resumed.value && await isBoxAlive(resumed.value, harness, shell.livenessProbe)) {
+      const box2 = resumed.value;
+      if (shell.bootstrap) {
+        const boot = await shell.bootstrap(box2, scope);
+        if (!boot.succeeded) {
+          throw new Error(`bootstrap failed on resumed box ${name}`, { cause: boot.error });
+        }
+      }
+      return box2;
+    }
+  }
+  const connectedIntegrationIds = await shell.connectedIntegrationIds(workspaceId);
+  const buildCtx = {
+    workspaceId,
+    connectedIntegrationIds,
+    ...userId ? { userId } : {}
+  };
+  const [secrets, env, files] = await Promise.all([
+    shell.secrets(workspaceId),
+    shell.env(buildCtx),
+    shell.files(buildCtx)
+  ]);
+  const profile = shell.profile({ extraFiles: files });
+  const role = userId && shell.permissionRole ? shell.permissionRole("developer") : void 0;
+  let model = shell.backendModelAtCreate ? resolveModel(shell.provider) : void 0;
+  if (model && shell.childKeyMint && model.provider === "openai-compat") {
+    const minted = await shell.childKeyMint(scope);
+    if (minted.succeeded) model = { ...model, apiKey: minted.value };
+    else {
+      console.error(
+        `[sandbox] childKeyMint failed for ${workspaceId}; using parent key:`,
+        minted.error.message
+      );
+    }
+  }
+  const storage = shell.storage?.(buildCtx);
+  const restore = shell.restore?.(buildCtx);
+  const payload = {
+    name,
+    image: resources.image,
+    metadata: shell.metadata(harness),
+    ...userId ? { permissions: { initialUsers: [{ userId, role }] } } : {},
+    env,
+    secrets,
+    backend: { type: harness, profile, ...model ? { model } : {} },
+    ...storage ? { storage } : {},
+    ...restore ? restore : {},
+    maxLifetimeSeconds: resources.maxLifetimeSeconds,
+    idleTimeoutSeconds: resources.idleTimeoutSeconds,
+    resources: {
+      cpuCores: resources.cpuCores,
+      memoryMB: resources.memoryMB,
+      diskGB: resources.diskGB
+    }
+  };
+  const box = await client.create(payload);
+  await box.waitFor("running", { timeoutMs: 12e4 });
+  if (!box.connection?.runtimeUrl) await box.refresh();
+  if (shell.bootstrap) {
+    const boot = await shell.bootstrap(box, scope);
+    if (!boot.succeeded) {
+      throw new Error(`bootstrap failed on new box ${name}`, { cause: boot.error });
+    }
+  }
+  return box;
+}
+function resolveModel(config, override) {
+  const c = config ?? {};
+  const explicitBaseUrl = c.routerBaseUrl;
+  const explicitApiKey = override?.modelApiKey ?? c.apiKey;
+  const provider = c.providerName ?? (explicitApiKey ? "openai-compat" : c.openaiApiKey ? "openai" : void 0);
+  const modelName = override?.model ?? c.modelName ?? (provider === "openai" || provider === "openai-compat" ? c.defaultModel : void 0);
+  const apiKey = explicitApiKey ?? (provider === "openai" ? c.openaiApiKey : void 0);
+  if (!provider || !modelName || !apiKey) return void 0;
+  return {
+    model: modelName,
+    provider,
+    apiKey,
+    ...explicitBaseUrl ? { baseUrl: explicitBaseUrl } : {}
+  };
+}
+function flattenHistory(message, history) {
+  if (!history?.length) return message;
+  const transcript = history.map((entry) => `${entry.role === "assistant" ? "Assistant" : "User"}: ${entry.content}`).join("\n\n");
+  return `${transcript}
+
+User: ${message}`;
+}
+function mergeExtraMcp(appToolMcp, baseProfileMcp, extra) {
+  for (const key of Object.keys(extra ?? {})) {
+    if (key in appToolMcp || key in baseProfileMcp) {
+      throw new Error(`extraMcp key '${key}' collides with an existing profile MCP server`);
+    }
+  }
+  return { ...appToolMcp, ...extra ?? {} };
+}
+function attachReasoningEffort(profile, harness, effort) {
+  if (!effort || effort === "auto") return profile;
+  return {
+    ...profile,
+    extensions: {
+      ...profile.extensions ?? {},
+      [harness]: {
+        ...profile.extensions?.[harness] ?? {},
+        reasoningEffort: effort
+      }
+    }
+  };
+}
+async function* streamSandboxPrompt(shell, box, message, options) {
+  const harness = options?.harness ?? "opencode";
+  const model = resolveModel(shell.provider, {
+    model: options?.model,
+    modelApiKey: options?.modelApiKey
+  });
+  if (model?.model) assertHarnessModelCompatible(harness, model.model);
+  const prompt = flattenHistory(message, options?.history);
+  const appToolMcp = options?.appToolMcp ?? {};
+  const extraMcp = mergeExtraMcp(appToolMcp, options?.baseProfileMcp ?? {}, options?.extraMcp);
+  const profile = shell.profile({ systemPrompt: options?.systemPrompt, extraMcp });
+  const profileWithEffort = attachReasoningEffort(profile, harness, options?.effort);
+  const stream = box.streamPrompt(prompt, {
+    sessionId: options?.sessionId,
+    executionId: options?.executionId,
+    lastEventId: options?.lastEventId,
+    ...options?.signal ? { signal: options.signal } : {},
+    ...options?.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {},
+    backend: {
+      type: harness,
+      profile: profileWithEffort,
+      ...model ? { model } : {}
+    }
+  });
+  let severedFinishReason = null;
+  for await (const event of stream) {
+    const step = classifySeveredStream(event);
+    if (step) severedFinishReason = step.kind === "step-finish" && step.severed ? step.reason : null;
+    if (severedFinishReason && isTerminalPromptEvent(event)) {
+      throw new Error(`sandbox model stream severed mid-turn (reason="${severedFinishReason}")`);
+    }
+    if (options?.disallowQuestions) {
+      const q = detectInteractiveQuestion(event);
+      if (q) {
+        throw new Error(`sandbox agent asked an interactive question during an autonomous run: ${q}`);
+      }
+    }
+    yield event;
+  }
+  if (severedFinishReason) {
+    throw new Error(`sandbox model stream severed mid-turn (reason="${severedFinishReason}")`);
+  }
+}
+async function runSandboxPrompt(shell, box, message, options) {
+  let fullText = "";
+  let firstTextSeen = false;
+  for await (const rawEvent of streamSandboxPrompt(shell, box, message, options)) {
+    const event = rawEvent;
+    if (!event.type) continue;
+    if (event.type === "message.part.updated") {
+      const part = event.data?.part;
+      const delta = typeof event.data?.delta === "string" ? event.data.delta : null;
+      if (String(part?.type ?? "") === "text") {
+        if (!firstTextSeen) {
+          firstTextSeen = true;
+          continue;
+        }
+        if (delta) fullText += delta;
+        else if (typeof part?.text === "string") fullText = part.text;
+      }
+    } else if (event.type === "result") {
+      const finalText = typeof event.data?.finalText === "string" ? event.data.finalText : null;
+      if (finalText) fullText = finalText;
+    }
+  }
+  return fullText;
+}
+async function syncSandboxMemberAdd(box, seam, userId, role) {
+  try {
+    await box.permissions.add({ userId, role: seam.roleToSandboxRole(role) });
+    return ok(void 0);
+  } catch (err) {
+    return fail(err);
+  }
+}
+async function syncSandboxMemberRemove(box, userId) {
+  try {
+    await box.permissions.remove(userId, { preserveHomeDir: true });
+    return ok(void 0);
+  } catch (err) {
+    return fail(err);
+  }
+}
+async function syncSandboxMemberRole(box, seam, userId, role) {
+  try {
+    await box.permissions.update(userId, { role: seam.roleToSandboxRole(role) });
+    return ok(void 0);
+  } catch (err) {
+    return fail(err);
+  }
+}
+function secretStoreFromClient(shell) {
+  const client = getClient(shell);
+  return {
+    create: async (name, value) => {
+      await client.secrets.create(name, value);
+    },
+    update: async (name, value) => {
+      await client.secrets.update(name, value);
+    },
+    get: (name) => client.secrets.get(name),
+    delete: async (name) => {
+      await client.secrets.delete(name);
+    }
+  };
+}
+async function storeSecret(store, name, value) {
+  try {
+    await store.create(name, value);
+    return ok(void 0);
+  } catch {
+    try {
+      await store.update(name, value);
+      return ok(void 0);
+    } catch (err) {
+      return fail(new Error(`Failed to store sandbox secret ${name}`, { cause: err }));
+    }
+  }
+}
+async function readSecret(store, name) {
+  try {
+    return ok(await store.get(name));
+  } catch (err) {
+    return fail(err);
+  }
+}
+async function deleteSecret(store, name) {
+  try {
+    await store.delete(name);
+    return ok(void 0);
+  } catch (err) {
+    return fail(err);
+  }
+}
+async function mintSandboxScopedToken(box, options) {
+  try {
+    const token = await box.mintScopedToken({
+      scope: options.scope,
+      ...options.sessionId ? { sessionId: options.sessionId } : {},
+      ...options.ttlMinutes ? { ttlMinutes: options.ttlMinutes } : {}
+    });
+    return ok({ token: token.token, expiresAt: token.expiresAt, scope: token.scope });
+  } catch (err) {
+    return fail(err);
+  }
+}
+async function driveSandboxTurn(shell, box, message, options) {
+  const harness = options.harness ?? "opencode";
+  const model = resolveModel(shell.provider, {
+    model: options.model,
+    modelApiKey: options.modelApiKey
+  });
+  if (model?.model) assertHarnessModelCompatible(harness, model.model);
+  const prompt = flattenHistory(message, options.history);
+  const appToolMcp = options.appToolMcp ?? {};
+  const extraMcp = mergeExtraMcp(appToolMcp, options.baseProfileMcp ?? {}, options.extraMcp);
+  const profile = attachReasoningEffort(
+    shell.profile({ systemPrompt: options.systemPrompt, extraMcp }),
+    harness,
+    options.effort
+  );
+  try {
+    const result = await box.prompt(prompt, {
+      sessionId: options.sessionId,
+      ...options.executionId ? { executionId: options.executionId } : {},
+      ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {},
+      ...options.signal ? { signal: options.signal } : {},
+      backend: { type: harness, profile, ...model ? { model } : {} }
+    });
+    if (!result.success) return fail(new Error(result.error ?? "sandbox turn failed"));
+    return ok(result);
+  } catch (err) {
+    return fail(err);
+  }
+}
+var TERMINAL_PROXY_TOKEN_TTL_MS = 15 * 60 * 1e3;
+async function signTerminalProxyToken(secret, encodedPayload) {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const sig = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(encodedPayload));
+  return base64UrlEncodeBytes(new Uint8Array(sig));
+}
+async function mintTerminalProxyToken(secret, identity, ttlMs = TERMINAL_PROXY_TOKEN_TTL_MS) {
+  if (!secret) return fail(new Error("mintTerminalProxyToken: secret is required"));
+  if (!identity.userId || !identity.workspaceId || !identity.sandboxId) {
+    return fail(new Error("mintTerminalProxyToken: userId/workspaceId/sandboxId are required"));
+  }
+  const expiresAt = new Date(Date.now() + ttlMs);
+  const payload = { ...identity, exp: Math.floor(expiresAt.getTime() / 1e3) };
+  const encoded = base64UrlEncodeUtf8(JSON.stringify(payload));
+  const sig = await signTerminalProxyToken(secret, encoded);
+  return ok({ token: `${encoded}.${sig}`, expiresAt });
+}
+async function verifyTerminalProxyToken(secret, token, expected) {
+  if (!secret) return false;
+  const [encoded, sig, extra] = token.split(".");
+  if (!encoded || !sig || extra !== void 0) return false;
+  const expectedSig = await signTerminalProxyToken(secret, encoded);
+  if (!constantTimeEqual(sig, expectedSig)) return false;
+  let payload;
+  try {
+    payload = JSON.parse(base64UrlDecodeUtf8(encoded));
+  } catch {
+    return false;
+  }
+  return payload.userId === expected.userId && payload.workspaceId === expected.workspaceId && payload.sandboxId === expected.sandboxId && Number.isFinite(payload.exp) && payload.exp > Math.floor(Date.now() / 1e3);
+}
+function base64UrlEncodeBytes(bytes) {
+  let bin = "";
+  for (const b of bytes) bin += String.fromCharCode(b);
+  return btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlEncodeUtf8(v) {
+  return base64UrlEncodeBytes(new TextEncoder().encode(v));
+}
+function base64UrlDecodeUtf8(v) {
+  const padded = v.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(v.length / 4) * 4, "=");
+  const bin = atob(padded);
+  const bytes = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i += 1) bytes[i] = bin.charCodeAt(i);
+  return new TextDecoder().decode(bytes);
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let r = 0;
+  for (let i = 0; i < a.length; i += 1) r |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return r === 0;
+}
+var SEVERED_FINISH_REASONS = /* @__PURE__ */ new Set(["error", "other", "unknown"]);
+function asPlainRecord(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function classifySeveredStream(event) {
+  const root = asPlainRecord(event);
+  if (!root || root.type !== "message.part.updated") return null;
+  const body = asPlainRecord(root.properties) ?? asPlainRecord(root.data) ?? root;
+  const part = asPlainRecord(body.part);
+  if (!part) return null;
+  if (part.type === "step-start") return { kind: "step-start" };
+  if (part.type !== "step-finish") return null;
+  const reason = typeof part.reason === "string" && part.reason ? part.reason : "unknown";
+  return { kind: "step-finish", reason, severed: SEVERED_FINISH_REASONS.has(reason) };
+}
+function isTerminalPromptEvent(event) {
+  const t = asPlainRecord(event)?.type;
+  return t === "result" || t === "done";
+}
+function detectInteractiveQuestion(event) {
+  const root = asPlainRecord(event);
+  if (!root) return null;
+  const type = typeof root.type === "string" ? root.type : void 0;
+  const data = asPlainRecord(root.data);
+  const props = asPlainRecord(root.properties);
+  const body = props ?? data ?? root;
+  if (type === "question.asked" || type === "question") return firstQuestionText(body);
+  const part = asPlainRecord(data?.part) ?? asPlainRecord(body.part);
+  const tool = typeof part?.tool === "string" && part.tool || typeof part?.name === "string" && part.name || typeof body.tool === "string" && body.tool || void 0;
+  const isQ = type === "message.part.updated" && (tool === "question" || asPlainRecord(part)?.type === "question");
+  if (!isQ) return null;
+  const state = asPlainRecord(asPlainRecord(part)?.state);
+  return firstQuestionText(asPlainRecord(state?.input) ?? state ?? part ?? body);
+}
+function firstQuestionText(value) {
+  const arr = Array.isArray(value?.questions) ? value.questions : Array.isArray(asPlainRecord(value?.input)?.questions) ? asPlainRecord(value.input).questions : [];
+  const first = asPlainRecord(arr[0]);
+  const q = typeof first?.question === "string" && first.question || typeof first?.prompt === "string" && first.prompt || void 0;
+  return q ?? "interactive question";
+}
+
+export {
+  createWorkspaceSandboxManager,
+  createSandboxTerminalToken,
+  verifySandboxTerminalToken,
+  createWorkspaceSandboxConnectionHandler,
+  createWorkspaceSandboxRuntimeProxyHandler,
+  matchSandboxTerminalWsPath,
+  isSandboxTerminalWsUpgrade,
+  createWorkspaceSandboxTerminalUpgradeHandler,
+  buildSandboxRuntimeProxyHeaders,
+  encodeSandboxRuntimePath,
+  bearerToken,
+  bearerSubprotocolToken,
+  terminalTokenFromRequest,
+  DEFAULT_SANDBOX_RESOURCES,
+  getClient,
+  resetClientCache,
+  buildAppToolMcpServers,
+  ensureWorkspaceSandbox,
+  resolveModel,
+  flattenHistory,
+  mergeExtraMcp,
+  attachReasoningEffort,
+  streamSandboxPrompt,
+  runSandboxPrompt,
+  syncSandboxMemberAdd,
+  syncSandboxMemberRemove,
+  syncSandboxMemberRole,
+  secretStoreFromClient,
+  storeSecret,
+  readSecret,
+  deleteSecret,
+  mintSandboxScopedToken,
+  driveSandboxTurn,
+  mintTerminalProxyToken,
+  verifyTerminalProxyToken,
+  classifySeveredStream,
+  isTerminalPromptEvent,
+  detectInteractiveQuestion
+};
+//# sourceMappingURL=chunk-XDCHKFBX.js.map