Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

feat(server): add persistent Tenki sandbox workspaces (#304)

usehoplite[bot]017f6e0c6835
diff --git a/.changeset/tenki-persistent-sandboxes.md b/.changeset/tenki-persistent-sandboxes.md
new file mode 100644
index 000000000..041360170
--- /dev/null
+++ b/.changeset/tenki-persistent-sandboxes.md
@@ -0,0 +1,7 @@
+---
+"akeru-bot": minor
+---
+
+Add Tenki sandboxes with persistent Linux VMs and snapshot-backed pause and resume. Connect a Tenki API key in Sandbox settings to use it for bots. Sandbox browser control is unavailable because Tenki previews are public.
+
+Preserve persistent workspaces after connector failures and retry idle pauses after readiness failures without racing active acquisitions.
diff --git a/apps/server/package.json b/apps/server/package.json
index 8a142682a..3721a5701 100644
--- a/apps/server/package.json
+++ b/apps/server/package.json
@@ -44,6 +44,7 @@
"@mastra/telegram": "0.1.0",
"@opencode-ai/sdk": "^1.3.15",
"@photon-ai/chat-adapter-imessage": "3.2.0",
+ "@tenkicloud/sandbox": "1.3.0",
"@upstash/box": "0.5.3",
"@vercel/sandbox": "^2.5.0",
"chat": "4.39.0",
diff --git a/apps/server/src/provider/AkeruSessionResources.test.ts b/apps/server/src/provider/AkeruSessionResources.test.ts
index 6f5d2e211..d67299290 100644
--- a/apps/server/src/provider/AkeruSessionResources.test.ts
+++ b/apps/server/src/provider/AkeruSessionResources.test.ts
@@ -8,6 +8,7 @@ import { BotId, McpServerId, ThreadId } from "@akeru/contracts";
import { afterEach, describe, expect, it, vi } from "vite-plus/test";
import { AkeruSessionResources } from "./AkeruSessionResources.ts";
+import { createBotBrowserTools } from "./botBrowser.ts";
import { computerRegistry } from "./computerRegistry.ts";
import { WorkspaceComputer } from "./workspaceComputer.ts";
import { CODEX_COMPUTER_USE_SERVER_ID } from "./CodexComputerUse.ts";
@@ -137,6 +138,53 @@ describe("AkeruSessionResources", () => {
expect(sharedBrowser.close).toHaveBeenCalledOnce();
});
+ it("retries failed workspace sleeps after releasing sessions during shutdown", async () => {
+ const remote = workspace();
+ const botWorkspace = {
+ ...localBotWorkspace(remote),
+ provider: "vercel" as const,
+ sleep: vi
+ .fn()
+ .mockRejectedValueOnce(new Error("pause unavailable"))
+ .mockResolvedValue(undefined),
+ };
+ const resources = new AkeruSessionResources({
+ stateDir: stateDir(),
+ makeRemoteWorkspace: async () => botWorkspace,
+ makeBotBrowser: () => browser(),
+ toMcpServerConfigs: () => ({}),
+ });
+
+ await resources.acquire({ ...remoteInput, threadId: "shutdown-retry" });
+ await expect(resources.shutdown()).rejects.toThrow("pause unavailable");
+ expect(botWorkspace.sleep).toHaveBeenCalledTimes(2);
+ await resources.retryFailedWorkspaceSleeps();
+ });
+
+ it("retries a failed workspace sleep with no active session", async () => {
+ const remote = workspace();
+ const botWorkspace = {
+ ...localBotWorkspace(remote),
+ provider: "vercel" as const,
+ sleep: vi
+ .fn()
+ .mockRejectedValueOnce(new Error("pause unavailable"))
+ .mockResolvedValue(undefined),
+ };
+ const resources = new AkeruSessionResources({
+ stateDir: stateDir(),
+ makeRemoteWorkspace: async () => botWorkspace,
+ makeBotBrowser: () => browser(),
+ toMcpServerConfigs: () => ({}),
+ });
+
+ await resources.acquire({ ...remoteInput, threadId: "idle-retry" });
+ await expect(resources.release("idle-retry")).rejects.toThrow("pause unavailable");
+ await resources.retryFailedWorkspaceSleeps();
+ expect(botWorkspace.sleep).toHaveBeenCalledTimes(2);
+ await resources.shutdown();
+ });
+
it("attributes shared browser failures and recovery to every active bot", async () => {
const browserFailure = vi.fn();
const browserReady = vi.fn();
@@ -284,7 +332,7 @@ describe("AkeruSessionResources", () => {
await resources.shutdown();
});
- it.each(["local", "vercel", "e2b", "daytona", "upstash"] as const)(
+ it.each(["local", "vercel", "e2b", "daytona", "upstash", "tenki"] as const)(
"acquires only usable connector browser attachments in %s workspaces",
async (botSandbox) => {
for (const transport of ["stdio", "url"] as const) {
@@ -321,6 +369,7 @@ describe("AkeruSessionResources", () => {
mcpServers: [server, exaServer],
});
const requiresBrowser =
+ botSandbox !== "tenki" &&
(id === "builtin-executor" || id === "builtin-tinyfish") &&
(transport === "stdio" || botSandbox !== "local");
expect(acquireAttachment).toHaveBeenCalledTimes(requiresBrowser ? 1 : 0);
@@ -368,6 +417,74 @@ describe("AkeruSessionResources", () => {
expect(close).toHaveBeenCalledOnce();
});
+ it("does not advertise browser tools for Tenki while retaining MCP tools", async () => {
+ const resources = new AkeruSessionResources({
+ stateDir: stateDir(),
+ makeRemoteWorkspace: async () => workspace(),
+ makeBotBrowser: () => ({
+ ...browser(),
+ tools: createBotBrowserTools({
+ call: async () => "",
+ attachment: async () => undefined,
+ reconnect: async () => undefined,
+ close: async () => undefined,
+ }),
+ }),
+ makeMcpManager: () =>
+ mcpManager({ connected: true, toolCount: 1 }, { exa_search: {}, other_tool: {} }) as never,
+ toMcpServerConfigs: () => ({}),
+ });
+ try {
+ await resources.acquire({
+ ...remoteInput,
+ botSandbox: "tenki",
+ threadId: "tenki-tools",
+ mcpServers: [exaServer],
+ });
+ expect(resources.getConnectorTools("tenki-tools")).toEqual({
+ exa_search: {},
+ other_tool: {},
+ });
+ } finally {
+ await resources.shutdown();
+ }
+ });
+
+ it("preserves the Tenki workspace when MCP initialization fails", async () => {
+ const remote: AkeruBotWorkspace = { ...localBotWorkspace(workspace()), provider: "tenki" };
+ const destroy = vi.spyOn(remote, "destroy");
+ const sleep = vi.spyOn(remote, "sleep");
+ const manager = mcpManager({ connected: true, toolCount: 1 });
+ manager.init.mockRejectedValueOnce(new Error("connector failed"));
+ const resources = new AkeruSessionResources({
+ stateDir: stateDir(),
+ makeRemoteWorkspace: async () => remote,
+ makeMcpManager: () => manager as never,
+ toMcpServerConfigs: () => ({}),
+ });
+
+ await expect(
+ resources.acquire({
+ ...remoteInput,
+ botSandbox: "tenki",
+ threadId: "tenki-init-failure",
+ mcpServers: [exaServer],
+ }),
+ ).rejects.toThrow("connector failed");
+ expect(destroy).not.toHaveBeenCalled();
+ expect(sleep).toHaveBeenCalledOnce();
+ expect(manager.disconnect).toHaveBeenCalledOnce();
+ const recovered = await resources.acquire({
+ ...remoteInput,
+ botSandbox: "tenki",
+ threadId: "tenki-init-failure",
+ mcpServers: [exaServer],
+ });
+ expect(recovered.botWorkspace).toBe(remote.workspace);
+ await resources.shutdown();
+ expect(destroy).not.toHaveBeenCalled();
+ });
+
it("coalesces concurrent acquisition for the same thread", async () => {
const remote = workspace();
const stop = vi.spyOn(remote, "stop");
diff --git a/apps/server/src/provider/AkeruSessionResources.ts b/apps/server/src/provider/AkeruSessionResources.ts
index 42535cbcc..9e122f860 100644
--- a/apps/server/src/provider/AkeruSessionResources.ts
+++ b/apps/server/src/provider/AkeruSessionResources.ts
@@ -114,6 +114,7 @@ export class AkeruSessionResources {
private readonly browserFailures = new Map<string, string>();
private readonly browserThreadBots = new Map<string, string>();
private readonly computerUseTemporaryDirectories = new Map<string, string>();
+ private readonly tenkiThreads = new Set<string>();
private controllingThreadId: string | undefined;
private shuttingDown = false;
@@ -303,11 +304,11 @@ export class AkeruSessionResources {
const previewMcpServerConfig = this.options.getPreviewMcpServerConfig?.(key);
if (input.mcpServers.length > 0 || previewMcpServerConfig) {
- const attachment = input.mcpServers.some((server) =>
- mcpServerNeedsBrowserAttachment(server, remote),
- )
- ? await browser.attachment()
- : undefined;
+ const attachment =
+ input.botSandbox !== "tenki" &&
+ input.mcpServers.some((server) => mcpServerNeedsBrowserAttachment(server, remote))
+ ? await browser.attachment()
+ : undefined;
const configs = this.options.toMcpServerConfigs(input.mcpServers, attachment);
if (previewMcpServerConfig) {
configs[AKERU_PREVIEW_MCP_SERVER_NAME] = previewMcpServerConfig;
@@ -362,20 +363,22 @@ export class AkeruSessionResources {
}
}
+ if (input.botSandbox === "tenki") this.tenkiThreads.add(key);
return {
workspace:
userComputerWorkspaceLease?.workspace.workspace ?? workspaceLease.workspace.workspace,
botWorkspace: workspaceLease.workspace.workspace,
};
} catch (cause) {
- await this.releaseOnce(key, { destroy: true }).catch(() => undefined);
+ await this.releaseOnce(key, { destroy: input.botSandbox !== "tenki" }).catch(() => undefined);
throw cause;
}
}
getConnectorTools(threadId: string): ToolsInput {
+ const browserTools = this.threadBrowsers.get(threadId)?.tools;
const tools: ToolsInput = {
- ...this.threadBrowsers.get(threadId)?.tools,
+ ...(!this.tenkiThreads.has(threadId) ? browserTools : undefined),
...this.mcpManagers.get(threadId)?.getTools(),
};
return Object.fromEntries(
@@ -429,6 +432,10 @@ export class AkeruSessionResources {
);
}
+ retryFailedWorkspaceSleeps(): Promise<void> {
+ return this.workspacePool.retryFailedSleeps();
+ }
+
async release(threadId: string, options?: { readonly destroy?: boolean }): Promise<void> {
await this.acquisitions.get(threadId)?.catch(() => undefined);
await this.releaseOnce(threadId, options);
@@ -441,6 +448,7 @@ export class AkeruSessionResources {
const failures: unknown[] = [];
const manager = this.mcpManagers.get(threadId);
this.mcpManagers.delete(threadId);
+ this.tenkiThreads.delete(threadId);
if (manager) await manager.disconnect().catch((cause) => failures.push(cause));
const computerUseTemporaryDirectory = this.computerUseTemporaryDirectories.get(threadId);
this.computerUseTemporaryDirectories.delete(threadId);
@@ -530,6 +538,7 @@ export class AkeruSessionResources {
}
async shutdown(): Promise<void> {
+ const failures: unknown[] = [];
this.shuttingDown = true;
await Promise.allSettled(this.acquisitions.values());
const threadIds = new Set([
@@ -539,8 +548,23 @@ export class AkeruSessionResources {
...this.mcpManagers.keys(),
...this.threadBrowsers.keys(),
]);
- await Promise.allSettled([...threadIds].map((threadId) => this.release(threadId)));
- await Promise.allSettled([...this.resourceBrowsers.values()].map((browser) => browser.close()));
+ const releases = await Promise.allSettled(
+ [...threadIds].map((threadId) => this.release(threadId)),
+ );
+ for (const result of releases) {
+ if (result.status === "rejected") failures.push(result.reason);
+ }
+ try {
+ await this.workspacePool.retryFailedSleeps();
+ } catch (cause) {
+ failures.push(cause);
+ }
+ const browserClosures = await Promise.allSettled(
+ [...this.resourceBrowsers.values()].map((browser) => browser.close()),
+ );
+ for (const result of browserClosures) {
+ if (result.status === "rejected") failures.push(result.reason);
+ }
this.resourceBrowsers.clear();
this.browserReferences.clear();
this.browserDestroyRequests.clear();
@@ -548,5 +572,6 @@ export class AkeruSessionResources {
this.browserAttributions.clear();
this.browserFailures.clear();
this.browserThreadBots.clear();
+ if (failures.length > 0) throw failures[0];
}
}
diff --git a/apps/server/src/provider/Layers/AgentController.test.ts b/apps/server/src/provider/Layers/AgentController.test.ts
index a5020971b..046963033 100644
--- a/apps/server/src/provider/Layers/AgentController.test.ts
+++ b/apps/server/src/provider/Layers/AgentController.test.ts
@@ -48,6 +48,7 @@ import { it } from "@effect/vitest";
import * as Context from "effect/Context";
import * as Data from "effect/Data";
import * as Deferred from "effect/Deferred";
+import * as TestClock from "effect/testing/TestClock";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
@@ -60,7 +61,6 @@ import * as PubSub from "effect/PubSub";
import * as Schema from "effect/Schema";
import * as Scope from "effect/Scope";
import * as Stream from "effect/Stream";
-import * as TestClock from "effect/testing/TestClock";
import * as SqlClient from "effect/unstable/sql/SqlClient";
import { assert, describe, expect, vi } from "vite-plus/test";
@@ -7237,6 +7237,66 @@ describe("AgentControllerLive", () => {
}).pipe(Effect.provide(layer.pipe(Layer.provideMerge(NodeServices.layer))), Effect.orDie);
});
+ it.effect("retries failed remote pauses in the background without a new session", () => {
+ const bridge = makeBridge();
+ const mastra = makeMastraHarness();
+ const workspace = new Workspace({
+ filesystem: new LocalFilesystem({ basePath: process.cwd() }),
+ sandbox: new LocalSandbox({ workingDirectory: process.cwd() }),
+ });
+ let paused!: () => void;
+ const pauseRetried = new Promise<void>((resolve) => {
+ paused = resolve;
+ });
+ const sleep = vi
+ .fn()
+ .mockRejectedValueOnce(new Error("pause unavailable"))
+ .mockImplementation(async () => {
+ paused();
+ });
+ const destroy = vi.fn(async () => undefined);
+ const layer = makeAgentControllerLive({
+ makeMastraHarness: mastra.factory,
+ makeRemoteWorkspace: async () => ({
+ id: "tenki-retry",
+ provider: "tenki",
+ workspace,
+ inspect: async () => "running",
+ wake: async () => undefined,
+ sleep,
+ destroy,
+ }),
+ }).pipe(
+ Layer.provide(
+ Layer.mergeAll(
+ Layer.succeed(LegacyProviderBridge, bridge.service),
+ Layer.succeed(BotUsageLedger, makeUsageLedger().service),
+ ServerConfig.layerTest(process.cwd(), { prefix: "akeru-pause-retry-" }).pipe(
+ Layer.provide(NodeServices.layer),
+ ),
+ ),
+ ),
+ );
+ return Effect.gen(function* () {
+ const controller = yield* AgentController;
+ yield* resolveCodex(controller);
+ yield* controller.startSession(codexThreadId, {
+ threadId: codexThreadId,
+ provider: ProviderDriverKind.make("codex"),
+ providerInstanceId: codexInstanceId,
+ modelSelection: codexSelection,
+ runtimeMode: "full-access",
+ botSandbox: "tenki",
+ });
+ yield* controller.stopSession({ threadId: codexThreadId }).pipe(Effect.ignore);
+ expect(sleep).toHaveBeenCalledOnce();
+ yield* TestClock.adjust("30 seconds");
+ yield* Effect.promise(() => pauseRetried);
+ expect(sleep).toHaveBeenCalledTimes(2);
+ expect(destroy).not.toHaveBeenCalled();
+ }).pipe(Effect.provide(layer.pipe(Layer.provideMerge(NodeServices.layer))), Effect.orDie);
+ });
+
it.effect("destroys obsolete and stops final pooled remote workspaces", () => {
const bridge = makeBridge();
const mastra = makeMastraHarness();
diff --git a/apps/server/src/provider/Layers/AgentController.ts b/apps/server/src/provider/Layers/AgentController.ts
index 7807399cd..26f1206d0 100644
--- a/apps/server/src/provider/Layers/AgentController.ts
+++ b/apps/server/src/provider/Layers/AgentController.ts
@@ -61,6 +61,7 @@ import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as PubSub from "effect/PubSub";
+import * as Schedule from "effect/Schedule";
import * as Ref from "effect/Ref";
import type * as Scope from "effect/Scope";
import * as Semaphore from "effect/Semaphore";
@@ -4448,6 +4449,14 @@ const make = (options?: AgentControllerLiveOptions) =>
}),
);
+ yield* runMastra("resources.retryFailedWorkspaceSleeps", () =>
+ sessionResources.retryFailedWorkspaceSleeps(),
+ ).pipe(
+ Effect.ignoreCause({ log: true }),
+ Effect.repeat(Schedule.spaced("30 seconds")),
+ Effect.forkScoped,
+ );
+
return AgentController.of({
configurePluginRuntime: (input: AkeruPluginRuntimeOptions) =>
Ref.update(lateWiring, (current) => ({
diff --git a/apps/server/src/provider/botWorkspace.tenki.test.ts b/apps/server/src/provider/botWorkspace.tenki.test.ts
new file mode 100644
index 000000000..e8565ee8c
--- /dev/null
+++ b/apps/server/src/provider/botWorkspace.tenki.test.ts
@@ -0,0 +1,214 @@
+// @effect-diagnostics nodeBuiltinImport:off
+import * as NodeFS from "node:fs";
+import * as NodeOS from "node:os";
+import * as NodePath from "node:path";
+import type { Session, SessionState } from "@tenkicloud/sandbox";
+import { describe, expect, it, vi } from "vite-plus/test";
+import { createRemoteBotWorkspace, tenki, tenkiWorkspaceState } from "./botWorkspace.ts";
+import { BotWorkspacePool } from "./botWorkspacePool.ts";
+
+const sdk = vi.hoisted(() => ({ create: vi.fn(), get: vi.fn(), constructor: vi.fn() }));
+vi.mock("@tenkicloud/sandbox", () => ({
+ TenkiSandbox: class {
+ constructor(options: unknown) {
+ sdk.constructor(options);
+ }
+ create = sdk.create;
+ get = sdk.get;
+ },
+}));
+
+function mockSession(state: SessionState = "RUNNING") {
+ const session = {
+ id: "tenki-session",
+ state,
+ refresh: vi.fn(async () => {}),
+ pause: vi.fn(async () => {
+ session.state = "PAUSING";
+ }),
+ waitPaused: vi.fn(async () => {
+ session.state = "PAUSED";
+ }),
+ resume: vi.fn(async () => {
+ session.state = "RESUMING";
+ }),
+ waitResumed: vi.fn(async () => {
+ session.state = "RUNNING";
+ }),
+ waitReady: vi.fn(async () => {}),
+ close: vi.fn(async () => {}),
+ exposePort: vi.fn(async () => ({ previewUrl: "https://preview.example.test" })),
+ exec: vi.fn(async () => ({
+ stdout: new TextEncoder().encode("hello 世界"),
+ stderr: new TextEncoder().encode("command failed"),
+ exitCode: 7,
+ })),
+ };
+ return { session, adapter: tenki(session as unknown as Session) };
+}
+
+describe("Tenki workspace", () => {
+ it("creates a sticky VM, reattaches its saved identity, and deletes it only on destroy", async () => {
+ const root = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-tenki-"));
+ const identityFile = NodePath.join(root, "identity.json");
+ const { session } = mockSession();
+ sdk.create.mockClear().mockResolvedValue(session);
+ sdk.get.mockClear().mockResolvedValue(session);
+ const input = {
+ sandbox: "tenki" as const,
+ threadId: "thread-tenki",
+ workspaceId: "bot-tenki",
+ identityFile,
+ environment: { TENKI_API_KEY: " test-key " },
+ };
+ try {
+ const first = await createRemoteBotWorkspace(input);
+ expect(sdk.constructor).toHaveBeenLastCalledWith({ apiKey: "test-key" });
+ expect(sdk.create).toHaveBeenCalledExactlyOnceWith({
+ name: "bot-tenki",
+ sticky: true,
+ waitReady: false,
+ });
+ await first.sleep();
+ expect(session.close).not.toHaveBeenCalled();
+ const second = await createRemoteBotWorkspace(input);
+ expect(sdk.get).toHaveBeenCalledExactlyOnceWith("tenki-session");
+ expect(sdk.create).toHaveBeenCalledTimes(1);
+ await second.wake();
+ expect(session.resume).toHaveBeenCalledOnce();
+ expect(await second.inspect()).toBe("running");
+ await second.destroy();
+ expect(session.close).toHaveBeenCalledOnce();
+ expect(NodeFS.existsSync(identityFile)).toBe(false);
+ } finally {
+ NodeFS.rmSync(root, { recursive: true, force: true });
+ }
+ });
+
+ it("retains a newly created VM's identity when readiness fails and retries the same VM", async () => {
+ const root = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-tenki-"));
+ const identityFile = NodePath.join(root, "identity.json");
+ const { session } = mockSession("CREATING");
+ sdk.create.mockClear().mockResolvedValue(session);
+ sdk.get.mockClear().mockResolvedValue(session);
+ session.waitReady.mockRejectedValueOnce(new Error("readiness unavailable"));
+ const pool = new BotWorkspacePool();
+ const create = () =>
+ createRemoteBotWorkspace({
+ sandbox: "tenki",
+ threadId: "thread",
+ workspaceId: "bot",
+ identityFile,
+ environment: { TENKI_API_KEY: "key" },
+ });
+ try {
+ await expect(pool.acquire("tenki", create)).rejects.toThrow("readiness unavailable");
+ expect(JSON.parse(NodeFS.readFileSync(identityFile, "utf8"))).toEqual({
+ provider: "tenki",
+ providerId: "tenki-session",
+ });
+ expect(session.close).not.toHaveBeenCalled();
+ session.state = "RUNNING";
+ const lease = await pool.acquire("tenki", create);
+ expect(sdk.create).toHaveBeenCalledTimes(1);
+ expect(sdk.get).not.toHaveBeenCalled();
+ expect(session.waitReady).toHaveBeenCalledTimes(2);
+ await lease.release({ destroy: true });
+ expect(session.close).toHaveBeenCalledOnce();
+ } finally {
+ NodeFS.rmSync(root, { recursive: true, force: true });
+ }
+ });
+
+ it("fails closed for a missing saved VM and requires credentials", async () => {
+ const root = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-tenki-"));
+ const identityFile = NodePath.join(root, "identity.json");
+ const input = {
+ sandbox: "tenki" as const,
+ threadId: "thread",
+ workspaceId: "bot",
+ identityFile,
+ };
+ try {
+ await expect(createRemoteBotWorkspace(input)).rejects.toThrow("TENKI_API_KEY");
+ NodeFS.writeFileSync(
+ identityFile,
+ JSON.stringify({ provider: "tenki", providerId: "missing" }),
+ );
+ sdk.create.mockClear();
+ sdk.get.mockRejectedValueOnce(new Error("not found"));
+ await expect(
+ createRemoteBotWorkspace({ ...input, environment: { TENKI_API_KEY: "key" } }),
+ ).rejects.toThrow("missing");
+ expect(sdk.create).not.toHaveBeenCalled();
+ expect(NodeFS.existsSync(identityFile)).toBe(true);
+ } finally {
+ NodeFS.rmSync(root, { recursive: true, force: true });
+ }
+ });
+
+ it.each<SessionState>(["PAUSED", "USER_SHUTDOWN", "PAUSING", "RESUMING", "RUNNING"])(
+ "waits for readiness when waking %s",
+ async (state) => {
+ const { adapter, session } = mockSession(state);
+ await adapter.wake();
+ expect(session.refresh).toHaveBeenCalledOnce();
+ if (state === "RUNNING") {
+ expect(session.waitReady).toHaveBeenCalledOnce();
+ expect(session.resume).not.toHaveBeenCalled();
+ } else {
+ expect(session.waitResumed).toHaveBeenCalledOnce();
+ expect(session.resume).toHaveBeenCalledTimes(state === "RESUMING" ? 0 : 1);
+ }
+ if (state === "PAUSING") expect(session.waitPaused).toHaveBeenCalledOnce();
+ },
+ );
+
+ it("waits for the pause snapshot and propagates lifecycle failures", async () => {
+ const { adapter, session } = mockSession();
+ await adapter.sleep();
+ expect(session.pause).toHaveBeenCalledOnce();
+ expect(session.waitPaused).toHaveBeenCalledOnce();
+ expect(await adapter.inspect()).toBe("sleeping");
+ session.waitResumed.mockRejectedValueOnce(new Error("resume failed"));
+ await expect(adapter.wake()).rejects.toThrow("resume failed");
+ session.waitPaused.mockRejectedValueOnce(new Error("snapshot failed"));
+ await expect(adapter.sleep()).rejects.toThrow("snapshot failed");
+ });
+
+ it("preserves argv, command options, output and nonzero exit codes", async () => {
+ const { adapter, session } = mockSession();
+ expect(
+ await adapter.run("printf", ["hello world", "$(false)"], {
+ cwd: "/home/tenki",
+ env: { TEST: "value" },
+ timeout: 1200,
+ }),
+ ).toEqual({ stdout: "hello 世界", stderr: "command failed", exitCode: 7 });
+ expect(session.exec).toHaveBeenCalledWith(["printf", "hello world", "$(false)"], {
+ cwd: "/home/tenki",
+ env: { TEST: "value" },
+ timeoutMs: 1200,
+ });
+ });
+
+ it("does not publish unauthenticated browser control through a public preview", async () => {
+ const { adapter, session } = mockSession();
+ await expect(adapter.browserEndpoint(9223)).rejects.toThrow("authenticated endpoint");
+ expect(session.exposePort).not.toHaveBeenCalled();
+ });
+
+ it.each<[SessionState, string]>([
+ ["RUNNING", "running"],
+ ["CREATING", "sleeping"],
+ ["PAUSED", "sleeping"],
+ ["USER_SHUTDOWN", "sleeping"],
+ ["PAUSING", "sleeping"],
+ ["RESUMING", "sleeping"],
+ ["TERMINATED", "missing"],
+ ["TERMINATING", "missing"],
+ ["UNSPECIFIED", "missing"],
+ ])("maps %s to %s", (state, expected) => {
+ expect(tenkiWorkspaceState(state)).toBe(expected);
+ });
+});
diff --git a/apps/server/src/provider/botWorkspace.ts b/apps/server/src/provider/botWorkspace.ts
index 68721c0c6..f38295950 100644
--- a/apps/server/src/provider/botWorkspace.ts
+++ b/apps/server/src/provider/botWorkspace.ts
@@ -17,7 +17,7 @@ import { BotWorkspaceFilesystem } from "./botWorkspaceFilesystem.ts";
import { DaytonaComputer } from "./daytonaComputer.ts";
import { WorkspaceComputer } from "./workspaceComputer.ts";
-export const REMOTE_BOT_SANDBOXES = ["e2b", "daytona", "vercel", "upstash"] as const;
+export const REMOTE_BOT_SANDBOXES = ["e2b", "daytona", "vercel", "upstash", "tenki"] as const;
export type RemoteBotSandbox = (typeof REMOTE_BOT_SANDBOXES)[number];
export type AkeruWorkspaceState = "running" | "sleeping" | "missing";
@@ -312,6 +312,12 @@ async function create(
environment,
);
}
+ if (provider === "tenki") {
+ const { TenkiSandbox } = await import("@tenkicloud/sandbox");
+ const client = new TenkiSandbox({ apiKey: credential(environment, "TENKI_API_KEY") });
+ // Persist the VM identity before wake waits for readiness, which can fail transiently.
+ return tenki(await client.create({ name: id, sticky: true, waitReady: false }));
+ }
const { Box } = await import("@upstash/box");
return upstash(await Box.create({ apiKey: credential(environment, "UPSTASH_BOX_API_KEY") }));
}
@@ -344,10 +350,77 @@ async function open(
environment,
);
}
+ if (provider === "tenki") {
+ const { TenkiSandbox } = await import("@tenkicloud/sandbox");
+ const client = new TenkiSandbox({ apiKey: credential(environment, "TENKI_API_KEY") });
+ return tenki(await client.get(id));
+ }
const { Box } = await import("@upstash/box");
return upstash(await Box.get(id, { apiKey: credential(environment, "UPSTASH_BOX_API_KEY") }));
}
+export function tenki(session: import("@tenkicloud/sandbox").Session): AkeruRemoteSession {
+ return {
+ providerId: session.id,
+ inspect: async () => {
+ await session.refresh();
+ return tenkiWorkspaceState(session.state);
+ },
+ run: async (command, args, options) => {
+ const result = await session.exec([command, ...args], {
+ ...(options?.cwd ? { cwd: options.cwd } : {}),
+ ...(options?.env ? { env: options.env } : {}),
+ ...(options?.timeout !== undefined ? { timeoutMs: options.timeout } : {}),
+ });
+ return {
+ stdout: new TextDecoder().decode(result.stdout),
+ stderr: new TextDecoder().decode(result.stderr),
+ exitCode: result.exitCode,
+ };
+ },
+ browserEndpoint: async () => {
+ // Public application previews must not expose the browser's unauthenticated MCP server.
+ throw new Error(
+ "Tenki sandbox browser requires an authenticated endpoint; public previews are not supported for browser control.",
+ );
+ },
+ wake: async () => {
+ await session.refresh();
+ if (session.state === "PAUSING") await session.waitPaused();
+ if (session.state === "PAUSED" || session.state === "USER_SHUTDOWN") {
+ await session.resume();
+ await session.waitResumed();
+ } else if (session.state === "RESUMING") {
+ await session.waitResumed();
+ } else {
+ await session.waitReady();
+ }
+ },
+ sleep: async () => {
+ await session.pause();
+ await session.waitPaused();
+ },
+ destroy: () => session.close(),
+ };
+}
+
+export function tenkiWorkspaceState(
+ state: import("@tenkicloud/sandbox").SessionState,
+): AkeruWorkspaceState {
+ switch (state) {
+ case "RUNNING":
+ return "running";
+ case "CREATING":
+ case "PAUSED":
+ case "USER_SHUTDOWN":
+ case "PAUSING":
+ case "RESUMING":
+ return "sleeping";
+ default:
+ return "missing";
+ }
+}
+
export function e2b(initial: import("e2b").Sandbox, apiKey?: string): AkeruRemoteSession {
let sandbox = initial;
const providerId = sandbox.sandboxId;
diff --git a/apps/server/src/provider/botWorkspacePool.test.ts b/apps/server/src/provider/botWorkspacePool.test.ts
index 9b35b987f..c299a8895 100644
--- a/apps/server/src/provider/botWorkspacePool.test.ts
+++ b/apps/server/src/provider/botWorkspacePool.test.ts
@@ -4,15 +4,13 @@ import { BotId } from "@akeru/contracts";
import * as Clock from "effect/Clock";
import * as Effect from "effect/Effect";
import * as TestClock from "effect/testing/TestClock";
-import { describe, expect, vi } from "vite-plus/test";
+import { describe, expect, it, vi } from "vite-plus/test";
import type { AkeruBotWorkspace } from "./botWorkspace.ts";
-
import {
botRuntimeResourceScope,
BotWorkspacePool,
botWorkspaceCredentialFingerprint,
botWorkspaceIdentity,
- botWorkspaceResourceKey,
} from "./botWorkspacePool.ts";
const localWorkspace = () =>
@@ -21,6 +19,19 @@ const localWorkspace = () =>
sandbox: new LocalSandbox({ workingDirectory: process.cwd() }),
});
+function remoteWorkspace(overrides: Partial<AkeruBotWorkspace> = {}): AkeruBotWorkspace {
+ return {
+ id: "akeru-persistent",
+ provider: "tenki",
+ workspace: localWorkspace(),
+ inspect: vi.fn(async () => "running" as const),
+ wake: vi.fn(async () => undefined),
+ sleep: vi.fn(async () => undefined),
+ destroy: vi.fn(async () => undefined),
+ ...overrides,
+ };
+}
+
describe("BotWorkspacePool", () => {
effectIt.effect("derives workspace identities", () =>
Effect.sync(() => {
@@ -68,6 +79,165 @@ describe("BotWorkspacePool", () => {
}).pipe(Effect.provide(TestClock.layer())),
);
+ it("retries failed creation", async () => {
+ const pool = new BotWorkspacePool();
+ const create = vi
+ .fn<() => Promise<Workspace>>()
+ .mockRejectedValueOnce(new Error("unavailable"))
+ .mockResolvedValueOnce(localWorkspace());
+ await expect(pool.acquire("retry", create)).rejects.toThrow("unavailable");
+ const lease = await pool.acquire("retry", create);
+ await lease.release({ destroy: true });
+ expect(create).toHaveBeenCalledTimes(2);
+ });
+
+ it("pauses and reuses a remote workspace after initial wake failure", async () => {
+ const pool = new BotWorkspacePool();
+ const failed = remoteWorkspace({
+ wake: vi.fn().mockRejectedValueOnce(new Error("wake failed")).mockResolvedValue(undefined),
+ });
+ const reattached = remoteWorkspace();
+ const create = vi.fn().mockResolvedValueOnce(failed).mockResolvedValueOnce(reattached);
+
+ await expect(pool.acquire("remote-initial", create)).rejects.toThrow("wake failed");
+ expect(failed.destroy).not.toHaveBeenCalled();
+ await pool.retryFailedSleeps();
+ expect(failed.sleep).toHaveBeenCalledOnce();
+ const lease = await pool.acquire("remote-initial", create);
+ expect(create).toHaveBeenCalledOnce();
+ expect(lease.workspace).toBe(failed);
+ await lease.release({ destroy: true });
+ expect(failed.destroy).toHaveBeenCalledOnce();
+ });
+
+ it("does not pause a retained workspace while acquisition is starting", async () => {
+ const pool = new BotWorkspacePool();
+ const sleep = vi
+ .fn()
+ .mockRejectedValueOnce(new Error("pause failed"))
+ .mockResolvedValue(undefined);
+ const workspace = remoteWorkspace({ sleep });
+ const create = vi.fn().mockResolvedValue(workspace);
+ const initial = await pool.acquire("acquiring", create);
+ await expect(initial.release()).rejects.toThrow("pause failed");
+
+ const acquisition = pool.acquire("acquiring", create);
+ await pool.retryFailedSleeps();
+ const lease = await acquisition;
+ expect(sleep).toHaveBeenCalledOnce();
+ expect(lease.workspace).toBe(workspace);
+ await lease.release({ destroy: true });
+ });
+
+ it("preserves a remote workspace after cached wake failure and retries cleanup", async () => {
+ const pool = new BotWorkspacePool();
+ const failed = remoteWorkspace({
+ wake: vi
+ .fn()
+ .mockResolvedValueOnce(undefined)
+ .mockRejectedValueOnce(new Error("wake failed"))
+ .mockResolvedValue(undefined),
+ });
+ const reattached = remoteWorkspace();
+ const create = vi.fn().mockResolvedValueOnce(failed).mockResolvedValueOnce(reattached);
+
+ const initial = await pool.acquire("remote-cached", create);
+ await initial.release();
+ await expect(pool.acquire("remote-cached", create)).rejects.toThrow("wake failed");
+ expect(failed.destroy).not.toHaveBeenCalled();
+ await pool.retryFailedSleeps();
+ expect(failed.sleep).toHaveBeenCalledTimes(2);
+ const lease = await pool.acquire("remote-cached", create);
+ expect(lease.workspace).toBe(failed);
+ await lease.release({ destroy: true });
+ });
+
+ it("preserves and reuses a remote workspace after sleep failure", async () => {
+ const pool = new BotWorkspacePool();
+ const failed = remoteWorkspace({
+ sleep: vi.fn().mockRejectedValueOnce(new Error("sleep failed")),
+ });
+ const reattached = remoteWorkspace();
+ const create = vi.fn().mockResolvedValueOnce(failed).mockResolvedValueOnce(reattached);
+
+ const initial = await pool.acquire("remote-sleep", create);
+ await expect(initial.release()).rejects.toThrow("sleep failed");
+ expect(failed.destroy).not.toHaveBeenCalled();
+ const lease = await pool.acquire("remote-sleep", create);
+ expect(lease.workspace).toBe(failed);
+ expect(create).toHaveBeenCalledOnce();
+ await lease.release({ destroy: true });
+ expect(failed.destroy).toHaveBeenCalledOnce();
+ });
+
+ it("retries failed remote pauses without another acquisition and retains repeated failures", async () => {
+ const pool = new BotWorkspacePool();
+ const sleep = vi
+ .fn()
+ .mockRejectedValueOnce(new Error("pause failed"))
+ .mockRejectedValueOnce(new Error("pause still unavailable"))
+ .mockResolvedValue(undefined);
+ const workspace = remoteWorkspace({ sleep });
+ const lease = await pool.acquire("idle-retry", async () => workspace);
+ await expect(lease.release()).rejects.toThrow("pause failed");
+ await expect(pool.retryFailedSleeps()).rejects.toThrow("pause still unavailable");
+ await pool.retryFailedSleeps();
+ expect(sleep).toHaveBeenCalledTimes(3);
+ expect(workspace.destroy).not.toHaveBeenCalled();
+ await pool.retryFailedSleeps();
+ expect(sleep).toHaveBeenCalledTimes(3);
+ await pool.destroyAll();
+ expect(workspace.destroy).toHaveBeenCalledOnce();
+ });
+
+ it("does not retry pause while a recovered workspace is leased", async () => {
+ const pool = new BotWorkspacePool();
+ const sleep = vi
+ .fn()
+ .mockRejectedValueOnce(new Error("pause failed"))
+ .mockResolvedValue(undefined);
+ const workspace = remoteWorkspace({ sleep });
+ const create = vi.fn(async () => workspace);
+ const lease = await pool.acquire("active-retry", create);
+ await expect(lease.release()).rejects.toThrow("pause failed");
+ const active = await pool.acquire("active-retry", create);
+ await pool.retryFailedSleeps();
+ expect(sleep).toHaveBeenCalledTimes(1);
+ await active.release();
+ expect(sleep).toHaveBeenCalledTimes(2);
+ });
+
+ it("waits for an in-flight idle retry before waking a new lease", async () => {
+ const pool = new BotWorkspacePool();
+ let finishPause!: () => void;
+ let markStarted!: () => void;
+ const started = new Promise<void>((resolve) => {
+ markStarted = resolve;
+ });
+ const sleep = vi
+ .fn()
+ .mockRejectedValueOnce(new Error("pause failed"))
+ .mockImplementationOnce(
+ () =>
+ new Promise<void>((resolve) => {
+ finishPause = resolve;
+ markStarted();
+ }),
+ );
+ const workspace = remoteWorkspace({ sleep });
+ const create = vi.fn(async () => workspace);
+ const lease = await pool.acquire("concurrent-retry", create);
+ await expect(lease.release()).rejects.toThrow("pause failed");
+ const retry = pool.retryFailedSleeps();
+ await started;
+ const acquire = pool.acquire("concurrent-retry", create);
+ expect(workspace.wake).toHaveBeenCalledOnce();
+ finishPause();
+ await retry;
+ const active = await acquire;
+ expect(workspace.wake).toHaveBeenCalledTimes(2);
+ await active.release({ destroy: true });
+ });
effectIt.effect("sleeps after final release and wakes once on reuse", () =>
Effect.gen(function* () {
const clock = yield* Clock.Clock;
diff --git a/apps/server/src/provider/botWorkspacePool.ts b/apps/server/src/provider/botWorkspacePool.ts
index 9d6f37b9e..71b722210 100644
--- a/apps/server/src/provider/botWorkspacePool.ts
+++ b/apps/server/src/provider/botWorkspacePool.ts
@@ -81,11 +81,13 @@ export class BotWorkspacePool {
private readonly state: Promise<PoolState>;
private readonly clock: Clock.Clock | undefined;
private readonly references = new Map<string, number>();
+ private readonly acquisitions = new Map<string, number>();
private readonly creators = new Map<string, () => Promise<AkeruBotWorkspace | Workspace>>();
private readonly destroyRequested = new Set<string>();
private readonly sleepers = new Map<string, AkeruBotWorkspace>();
private readonly waking = new Set<string>();
private readonly failed = new Set<string>();
+ private readonly retrying = new Set<string>();
private readonly closing = new Map<string, Promise<void>>();
private destroyingAll = false;
private readonly destroyAllFailures: unknown[] = [];
@@ -127,7 +129,13 @@ export class BotWorkspacePool {
),
Effect.tap((workspace) =>
Effect.tryPromise({ try: () => workspace.wake(), catch: toPoolError }).pipe(
- Effect.tapCause(() => Effect.promise(() => workspace.destroy().catch(() => undefined))),
+ Effect.tapCause(() =>
+ workspace.provider === "local"
+ ? Effect.promise(() => workspace.destroy().catch(() => undefined))
+ : Effect.sync(() => {
+ this.sleepers.set(key, workspace);
+ }),
+ ),
),
),
Effect.map((workspace) => ({ workspace, wokeFromSleep })),
@@ -169,9 +177,15 @@ export class BotWorkspacePool {
}
return Effect.tryPromise(() => workspace.sleep()).pipe(
Effect.tap(() => Effect.sync(() => this.sleepers.set(key, workspace))),
- // A workspace that cannot sleep is unusable. Destroy it so the next acquire starts fresh,
- // then fail the release so callers drop resources, such as a browser, bound to it.
- Effect.tapError(() => Effect.promise(() => workspace.destroy().catch(() => undefined))),
+ // Remote workspaces can remain usable after a pause failure; retain them for retry.
+ Effect.tapError(() =>
+ workspace.provider === "local"
+ ? Effect.promise(() => workspace.destroy().catch(() => undefined))
+ : Effect.sync(() => {
+ this.sleepers.set(key, workspace);
+ this.failed.add(key);
+ }),
+ ),
Effect.catch((error) => Effect.die(error.cause)),
);
}
@@ -179,6 +193,20 @@ export class BotWorkspacePool {
async acquire(
key: string,
create: () => Promise<AkeruBotWorkspace | Workspace>,
+ ): Promise<BotWorkspaceLease> {
+ this.acquisitions.set(key, (this.acquisitions.get(key) ?? 0) + 1);
+ try {
+ return await this.acquireOnce(key, create);
+ } finally {
+ const remaining = (this.acquisitions.get(key) ?? 1) - 1;
+ if (remaining === 0) this.acquisitions.delete(key);
+ else this.acquisitions.set(key, remaining);
+ }
+ }
+
+ private async acquireOnce(
+ key: string,
+ create: () => Promise<AkeruBotWorkspace | Workspace>,
): Promise<BotWorkspaceLease> {
// Callers that join a wake in flight also reconnect, matching the caller that started it.
const joinedWake = this.waking.has(key);
@@ -193,9 +221,12 @@ export class BotWorkspacePool {
const leaseScope = await this.run(Scope.make());
const pooled = await this.run(RcMap.get(map, key).pipe(Scope.provide(leaseScope))).catch(
async (cause: unknown) => {
- // Drop the failed entry so the next acquire retries instead of reusing the failure while it idles.
- if (this.failed.delete(key)) await this.run(RcMap.invalidate(map, key));
await this.run(Scope.close(leaseScope, Exit.void));
+ if (this.failed.delete(key)) {
+ const retained = this.sleepers.has(key);
+ await this.run(RcMap.invalidate(map, key));
+ if (retained) this.failed.add(key);
+ }
throw cause;
},
);
@@ -231,13 +262,45 @@ export class BotWorkspacePool {
};
}
+ /** Retries failed pauses for retained remote workspaces. */
+ async retryFailedSleeps(): Promise<void> {
+ if (this.destroyingAll) return;
+ const results = await Promise.allSettled(
+ [...this.failed].map(async (key) => {
+ const workspace = this.sleepers.get(key);
+ if (
+ !workspace ||
+ this.references.has(key) ||
+ this.acquisitions.has(key) ||
+ this.retrying.has(key)
+ )
+ return;
+ this.retrying.add(key);
+ const finish = Promise.withResolvers<void>();
+ this.closing.set(key, finish.promise);
+ try {
+ await workspace.sleep();
+ this.failed.delete(key);
+ } finally {
+ this.retrying.delete(key);
+ if (this.closing.get(key) === finish.promise) this.closing.delete(key);
+ finish.resolve();
+ }
+ }),
+ );
+ const failure = results.find((result) => result.status === "rejected");
+ if (failure?.status === "rejected") throw failure.reason;
+ }
+
/** Destroys every pooled workspace, including idle ones that are still awake. */
async destroyAll(): Promise<void> {
const { scope } = await this.state;
this.destroyingAll = true;
+ await Promise.all(this.closing.values());
await this.run(Scope.close(scope, Exit.void));
const sleepers = [...this.sleepers.values()];
this.sleepers.clear();
+ this.failed.clear();
const results = await Promise.allSettled(sleepers.map((workspace) => workspace.destroy()));
for (const result of results) {
if (result.status === "rejected") this.destroyAllFailures.push(result.reason);
diff --git a/apps/server/src/serverSettings.test.ts b/apps/server/src/serverSettings.test.ts
index f998fdc73..3f2435027 100644
--- a/apps/server/src/serverSettings.test.ts
+++ b/apps/server/src/serverSettings.test.ts
@@ -1457,24 +1457,34 @@ it.layer(NodeServices.layer)("server settings", (it) => {
e2b: {
environment: [{ name: "E2B_API_KEY", value: "e2b-secret", sensitive: true }],
},
+ tenki: {
+ environment: [{ name: "TENKI_API_KEY", value: "tenki-secret", sensitive: true }],
+ },
},
},
});
assert.equal(next.sandbox.providers.e2b.environment[0]?.value, "e2b-secret");
+ assert.equal(next.sandbox.providers.tenki.environment[0]?.value, "tenki-secret");
const raw = yield* fileSystem.readFileString(serverConfig.settingsPath);
assert.notInclude(raw, "e2b-secret");
+ assert.notInclude(raw, "tenki-secret");
const clientSettings = ServerSettingsModule.redactServerSettingsForClient(next);
assert.deepInclude(clientSettings.sandbox.providers.e2b.environment[0], {
value: "",
valueRedacted: true,
});
+ assert.deepInclude(clientSettings.sandbox.providers.tenki.environment[0], {
+ value: "",
+ valueRedacted: true,
+ });
const roundTripped = yield* serverSettings.updateSettings({
sandbox: clientSettings.sandbox,
});
assert.equal(roundTripped.sandbox.providers.e2b.environment[0]?.value, "e2b-secret");
+ assert.equal(roundTripped.sandbox.providers.tenki.environment[0]?.value, "tenki-secret");
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
diff --git a/apps/server/src/serverSettings.ts b/apps/server/src/serverSettings.ts
index e108a9891..01dca82ad 100644
--- a/apps/server/src/serverSettings.ts
+++ b/apps/server/src/serverSettings.ts
@@ -190,6 +190,7 @@ export function redactServerSettingsForClient(settings: ServerSettings): ServerS
daytona: redactSandboxProviderConnection(settings.sandbox.providers.daytona),
vercel: redactSandboxProviderConnection(settings.sandbox.providers.vercel),
upstash: redactSandboxProviderConnection(settings.sandbox.providers.upstash),
+ tenki: redactSandboxProviderConnection(settings.sandbox.providers.tenki),
},
},
browserProvider: {
diff --git a/apps/server/src/telemetry/AnalyticsService.test.ts b/apps/server/src/telemetry/AnalyticsService.test.ts
index bef762e1f..bb029d32b 100644
--- a/apps/server/src/telemetry/AnalyticsService.test.ts
+++ b/apps/server/src/telemetry/AnalyticsService.test.ts
@@ -323,7 +323,14 @@ it.layer(NodeServices.layer)("anonymous analytics", (it) => {
config.analyticsStatePath,
encodeJson({
...deliveredState,
- pending: Array.from({ length: 9 }, () => pendingEvent),
+ pending: Array.from({ length: 9 }, () => ({
+ ...pendingEvent,
+ properties: Object.fromEntries(
+ Object.entries(pendingEvent.properties).filter(
+ ([key]) => key !== "sandbox_turns_tenki",
+ ),
+ ),
+ })),
}),
);
yield* analytics.flush;
@@ -333,6 +340,18 @@ it.layer(NodeServices.layer)("anonymous analytics", (it) => {
assert.equal((captured[2] as { readonly batch: ReadonlyArray<unknown> }).batch.length, 6);
assert.equal(quotaState.pending.length, 3);
assert.equal(quotaState.deliveredToday, 8);
+ const upgradedBatch = (
+ captured[2] as {
+ readonly batch: ReadonlyArray<{
+ readonly properties: {
+ readonly sandbox_turns_tenki: number;
+ readonly $insert_id: string;
+ };
+ }>;
+ }
+ ).batch;
+ assert.equal(upgradedBatch[0]?.properties.sandbox_turns_tenki, 0);
+ assert.equal(upgradedBatch[0]?.properties.$insert_id, pendingEvent.properties.$insert_id);
yield* settings.updateSettings({ analyticsEnabled: false });
yield* analytics.flush;
diff --git a/apps/server/src/telemetry/AnalyticsService.ts b/apps/server/src/telemetry/AnalyticsService.ts
index 622d3247e..6f6624c16 100644
--- a/apps/server/src/telemetry/AnalyticsService.ts
+++ b/apps/server/src/telemetry/AnalyticsService.ts
@@ -179,7 +179,7 @@ export function normalizeProvider(value: string): UsageAnalyticsProvider {
return providerValues.has(value) ? (value as UsageAnalyticsProvider) : "other";
}
-const sandboxValues = new Set(["none", "local", "e2b", "daytona", "vercel", "upstash"]);
+const sandboxValues = new Set(["none", "local", "e2b", "daytona", "vercel", "upstash", "tenki"]);
function normalizeSandbox(value: string): UsageSandboxProvider {
if (value === "other") return "other";
return sandboxValues.has(value) ? (value as UsageSandboxProvider) : "other";
diff --git a/apps/web/src/components/roster/botSandbox.test.ts b/apps/web/src/components/roster/botSandbox.test.ts
index 9b3676861..ad4cf8762 100644
--- a/apps/web/src/components/roster/botSandbox.test.ts
+++ b/apps/web/src/components/roster/botSandbox.test.ts
@@ -34,6 +34,7 @@ describe("botSandbox", () => {
"daytona",
"vercel",
"upstash",
+ "tenki",
]);
expect(botSandboxLabel("vercel")).toBe("Vercel Sandbox");
});
diff --git a/apps/web/src/components/roster/botSandbox.ts b/apps/web/src/components/roster/botSandbox.ts
index 8a804afc7..e59a074ea 100644
--- a/apps/web/src/components/roster/botSandbox.ts
+++ b/apps/web/src/components/roster/botSandbox.ts
@@ -20,6 +20,7 @@ export const BOT_SANDBOX_OPTIONS = [
{ value: "daytona", label: "Daytona" },
{ value: "vercel", label: "Vercel Sandbox" },
{ value: "upstash", label: "Upstash Box" },
+ { value: "tenki", label: "Tenki" },
] as const;
export type BotSandboxChoice = (typeof BOT_SANDBOX_OPTIONS)[number]["value"];
diff --git a/apps/web/src/components/roster/types.ts b/apps/web/src/components/roster/types.ts
index 45c530251..cae0a602e 100644
--- a/apps/web/src/components/roster/types.ts
+++ b/apps/web/src/components/roster/types.ts
@@ -37,7 +37,7 @@ export interface Bot {
disabledMcpServerIds: readonly McpServerId[];
avatar: BotAvatar;
engine: BotEngine | null;
- sandbox: "local" | "e2b" | "daytona" | "vercel" | "upstash" | null;
+ sandbox: "local" | "e2b" | "daytona" | "vercel" | "upstash" | "tenki" | null;
runtimeMode: "approval-required" | "auto-accept-edits" | "auto" | "full-access";
usageCap: { unit: "tokens"; limit: number } | null;
/** Personality baseline, 0 (chill) to 100 (professional). Absent on bots saved before the field existed. */
diff --git a/apps/web/src/components/settings/SandboxSettingsPanel.logic.ts b/apps/web/src/components/settings/SandboxSettingsPanel.logic.ts
index e565ecf7d..bcf55f1f4 100644
--- a/apps/web/src/components/settings/SandboxSettingsPanel.logic.ts
+++ b/apps/web/src/components/settings/SandboxSettingsPanel.logic.ts
@@ -51,6 +51,12 @@ const SANDBOX_PROVIDER_DEFINITION_BY_ID: Readonly<
description: "Cloud workspaces managed by Upstash Box. Requires an API key.",
fields: [{ name: "UPSTASH_BOX_API_KEY", label: "API key", secret: true }],
},
+ tenki: {
+ id: "tenki",
+ label: "Tenki",
+ description: "Cloud workspaces managed by Tenki. Requires an API key.",
+ fields: [{ name: "TENKI_API_KEY", label: "API key", secret: true }],
+ },
};
export const SANDBOX_PROVIDER_DEFINITIONS = Object.values(SANDBOX_PROVIDER_DEFINITION_BY_ID);
diff --git a/apps/web/src/components/settings/SandboxSettingsPanel.tsx b/apps/web/src/components/settings/SandboxSettingsPanel.tsx
index f5bc981d8..6c2f1eeed 100644
--- a/apps/web/src/components/settings/SandboxSettingsPanel.tsx
+++ b/apps/web/src/components/settings/SandboxSettingsPanel.tsx
@@ -40,6 +40,7 @@ const SANDBOX_PROVIDER_LABELS: Readonly<Record<SandboxProvider, string>> = {
daytona: "Daytona",
vercel: "Vercel Sandbox",
upstash: "Upstash Box",
+ tenki: "Tenki",
};
function errorMessage(
@@ -228,9 +229,10 @@ function EnvironmentSandboxSettingsPanel({
autoComplete="off"
value={draft[field.name] ?? ""}
placeholder={field.secret ? t("Leave blank to keep the saved value") : undefined}
- onChange={(event) =>
- setDraft((current) => ({ ...current, [field.name]: event.currentTarget.value }))
- }
+ onChange={(event) => {
+ const value = event.currentTarget.value;
+ setDraft((current) => ({ ...current, [field.name]: value }));
+ }}
/>
</label>
))}
diff --git a/docs/internals/computer-control.md b/docs/internals/computer-control.md
index 4cc143406..85d263cfb 100644
--- a/docs/internals/computer-control.md
+++ b/docs/internals/computer-control.md
@@ -31,6 +31,7 @@ Provider credentials and raw CDP URLs stay server-side. Connection identity is p
| E2B | No | Generic sandboxes are not treated as desktops. |
| Vercel Sandbox | No | No private desktop API is wired. |
| Upstash Box | No | The pinned SDK path does not provision the newer managed browser. |
+| Tenki | No | No authenticated browser-control or graphical desktop endpoint is wired. |
Codex, Claude, Grok, Kimi For Coding, and OpenCode Go register this computer through Mastra session resources. Standard OpenCode stays unavailable until it uses the same gated browser tools. Shell processes can still send desktop input outside the gate; that residual risk is documented rather than silently claimed exclusive. Unbrokered MCP browser credentials are withheld from the graphical computer.
diff --git a/docs/user/sandboxes.md b/docs/user/sandboxes.md
index d62e0425c..a25b4b29c 100644
--- a/docs/user/sandboxes.md
+++ b/docs/user/sandboxes.md
@@ -1,8 +1,16 @@
# Configure sandboxes
-Open **Settings > Sandbox** to connect E2B, Daytona, Vercel Sandbox, or Upstash Box. Local workspaces
+Open **Settings > Sandbox** to connect E2B, Daytona, Vercel Sandbox, Upstash Box, or Tenki. Local workspaces
need no credential and are always available.
+Tenki runs coding agents in full Linux VMs and supports public previews, disk and memory snapshots,
+and persistence until you clean up the sandbox. Connect it with your `TENKI_API_KEY`.
+Tenki previews are public: anyone with a preview URL can access it. Pausing preserves VM memory
+and disk but clears `/tmp`; keep durable files under `/home/tenki`.
+The sandbox browser is not available on Tenki: Akeru does not expose browser control through a public
+preview URL. This does not prevent agents from running commands in the VM.
+Executor and Tinyfish connectors can still start, but receive no sandbox browser connection.
+
Select **Connect** and enter the provider credentials. The environment stores secret values outside
`settings.json`. Clients receive only a redacted marker after a secret is saved.
@@ -18,6 +26,7 @@ so connect that service before you start the bot.
Akeru pauses remote sandboxes while bots are idle and reconnects to the saved provider workspace when
bot work resumes.
+If a remote pause fails, Akeru keeps the workspace and retries the pause while it remains idle.
Changing a provider credential replaces active sessions that use the connection. A running session
cannot continue with the old credential.
diff --git a/packages/client-runtime/src/i18n/index.ts b/packages/client-runtime/src/i18n/index.ts
index 0c5f3674f..890c8dcf9 100644
--- a/packages/client-runtime/src/i18n/index.ts
+++ b/packages/client-runtime/src/i18n/index.ts
@@ -2390,6 +2390,8 @@ export const englishCatalog = {
"Cloud workspaces in your Vercel team and project.",
"Cloud workspaces managed by Upstash Box. Requires an API key.":
"Cloud workspaces managed by Upstash Box. Requires an API key.",
+ "Cloud workspaces managed by Tenki. Requires an API key.":
+ "Cloud workspaces managed by Tenki. Requires an API key.",
Token: "Token",
"Team ID": "Team ID",
"Project ID": "Project ID",
diff --git a/packages/client-runtime/src/i18n/zh-CN.ts b/packages/client-runtime/src/i18n/zh-CN.ts
index 85fc800db..0ddec9528 100644
--- a/packages/client-runtime/src/i18n/zh-CN.ts
+++ b/packages/client-runtime/src/i18n/zh-CN.ts
@@ -2296,6 +2296,8 @@ export const zhCNCatalog: TranslationCatalog = {
"Cloud workspaces in your Vercel team and project.": "位于你的 Vercel 团队和项目中的云端工作区。",
"Cloud workspaces managed by Upstash Box. Requires an API key.":
"由 Upstash Box 管理的云端工作区。需要 API 密钥。",
+ "Cloud workspaces managed by Tenki. Requires an API key.":
+ "由 Tenki 管理的云端工作区。需要 API 密钥。",
Token: "令牌",
"Team ID": "团队 ID",
"Project ID": "项目 ID",
diff --git a/packages/client-runtime/src/state/computerViewer.test.ts b/packages/client-runtime/src/state/computerViewer.test.ts
index 753a866f1..798a0a134 100644
--- a/packages/client-runtime/src/state/computerViewer.test.ts
+++ b/packages/client-runtime/src/state/computerViewer.test.ts
@@ -244,7 +244,7 @@ describe("computer capability", () => {
expect(explainComputerCapability({ sandbox: null, provider: "codex", state: none })).toBe(
"local",
);
- for (const sandbox of ["e2b", "vercel", "upstash"] as const) {
+ for (const sandbox of ["e2b", "vercel", "upstash", "tenki"] as const) {
expect(explainComputerCapability({ sandbox, provider: "codex", state: none })).toBe(
"sandbox",
);
diff --git a/packages/client-runtime/src/state/computerViewer.ts b/packages/client-runtime/src/state/computerViewer.ts
index a08d170f8..46d28318b 100644
--- a/packages/client-runtime/src/state/computerViewer.ts
+++ b/packages/client-runtime/src/state/computerViewer.ts
@@ -269,6 +269,7 @@ export const COMPUTER_SANDBOX_CAPABILITY: Readonly<
daytona: { graphical: true },
vercel: { graphical: false },
upstash: { graphical: false },
+ tenki: { graphical: false },
};
/** Provider drivers that route browser input through the shared computer gate. */
diff --git a/packages/contracts/src/analytics.test.ts b/packages/contracts/src/analytics.test.ts
index e27635bf3..7a3a6b567 100644
--- a/packages/contracts/src/analytics.test.ts
+++ b/packages/contracts/src/analytics.test.ts
@@ -52,11 +52,11 @@ const rejects = (input: unknown) => expect(() => decodeUsage3hEvent(input)).toTh
describe("Usage3hEvent", () => {
it("accepts the fixed anonymous aggregate payload", () => {
expect(decodeUsage3hEvent(event)).toEqual(event);
- expect(USAGE_3H_COUNTER_KEYS).toHaveLength(94);
+ expect(USAGE_3H_COUNTER_KEYS).toHaveLength(95);
});
it("accepts current remote sandboxes and rejects the retired hosted sandbox", () => {
- for (const sandbox_provider of ["e2b", "daytona", "vercel", "upstash"] as const) {
+ for (const sandbox_provider of ["e2b", "daytona", "vercel", "upstash", "tenki"] as const) {
expect(
decodeUsage3hEvent({
...event,
@@ -80,6 +80,20 @@ describe("Usage3hEvent", () => {
).toBe(0);
});
+ it("defaults pre-Tenki queued counters without changing event identity", () => {
+ const properties = Object.fromEntries(
+ Object.entries(event.properties).filter(([key]) => key !== "sandbox_turns_tenki"),
+ );
+ expect(decodeUsage3hEvent({ ...event, properties })).toEqual(event);
+ });
+
+ it.each([-1, 1.5, USAGE_3H_COUNTER_MAX + 1, "1", null])(
+ "rejects invalid Tenki counter %s",
+ (sandbox_turns_tenki) => {
+ rejects({ ...event, properties: { ...event.properties, sandbox_turns_tenki } });
+ },
+ );
+
it("rejects unknown events and properties", () => {
rejects({ ...event, event: "turn_completed" });
rejects({ ...event, prompt: "private" });
diff --git a/packages/contracts/src/analytics.ts b/packages/contracts/src/analytics.ts
index d60423532..09c26073e 100644
--- a/packages/contracts/src/analytics.ts
+++ b/packages/contracts/src/analytics.ts
@@ -33,6 +33,7 @@ export const USAGE_SANDBOX_IDS = [
"vercel",
"akeru_cloud",
"upstash",
+ "tenki",
"other",
] as const;
@@ -168,6 +169,7 @@ export const UsageSandboxProvider = Schema.Literals([
"daytona",
"vercel",
"upstash",
+ "tenki",
"mixed",
"other",
]);
@@ -175,6 +177,7 @@ export type UsageSandboxProvider = typeof UsageSandboxProvider.Type;
const UsageCounters = Schema.Struct({
...Object.fromEntries(USAGE_3H_COUNTER_KEYS.map((key) => [key, UsageCounter])),
+ sandbox_turns_tenki: UsageCounter.pipe(Schema.withDecodingDefault(Effect.succeed(0))),
new_installations: Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 1 })).pipe(
Schema.withDecodingDefault(Effect.succeed(0)),
),
diff --git a/packages/contracts/src/botConfig.test.ts b/packages/contracts/src/botConfig.test.ts
index 217ee5ad3..9b7568b8c 100644
--- a/packages/contracts/src/botConfig.test.ts
+++ b/packages/contracts/src/botConfig.test.ts
@@ -41,7 +41,7 @@ describe("BotUsageCap", () => {
});
it("accepts cloud sandbox providers on bot events", () => {
- for (const sandbox of ["local", "e2b", "daytona", "vercel", "upstash"] as const) {
+ for (const sandbox of ["local", "e2b", "daytona", "vercel", "upstash", "tenki"] as const) {
expect(
decodeCreated({
botId: "bot-sandbox",
diff --git a/packages/contracts/src/orchestration.ts b/packages/contracts/src/orchestration.ts
index 6c9348c18..4a9f591c2 100644
--- a/packages/contracts/src/orchestration.ts
+++ b/packages/contracts/src/orchestration.ts
@@ -375,7 +375,14 @@ export const BotEngine = Schema.Struct({
});
export type BotEngine = typeof BotEngine.Type;
-export const BotSandbox = Schema.Literals(["local", "e2b", "daytona", "vercel", "upstash"]);
+export const BotSandbox = Schema.Literals([
+ "local",
+ "e2b",
+ "daytona",
+ "vercel",
+ "upstash",
+ "tenki",
+]);
export type BotSandbox = typeof BotSandbox.Type;
export const PersistedBotSandbox = Schema.Union([
diff --git a/packages/contracts/src/settings.test.ts b/packages/contracts/src/settings.test.ts
index dc458aa50..e2d11d06b 100644
--- a/packages/contracts/src/settings.test.ts
+++ b/packages/contracts/src/settings.test.ts
@@ -305,6 +305,7 @@ describe("ServerSettings sandbox providers", () => {
daytona: { environment: [] },
vercel: { environment: [] },
upstash: { environment: [] },
+ tenki: { environment: [] },
},
});
});
@@ -331,6 +332,20 @@ describe("ServerSettings sandbox providers", () => {
});
});
+ it("accepts Tenki's secret API key", () => {
+ expect(
+ decodeServerSettingsRpcPatch({
+ sandbox: {
+ providers: {
+ tenki: {
+ environment: [{ name: "TENKI_API_KEY", value: "secret", sensitive: true }],
+ },
+ },
+ },
+ }).sandbox?.providers?.tenki?.environment,
+ ).toEqual([{ name: "TENKI_API_KEY", value: "secret", sensitive: true }]);
+ });
+
it("keeps automatic idle cleanup enabled", () => {
expect(() => decodeServerSettingsPatch({ sandbox: { autoIdle: false } })).toThrow();
});
diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.ts
index 3dc2d44a6..864a5f436 100644
--- a/packages/contracts/src/settings.ts
+++ b/packages/contracts/src/settings.ts
@@ -664,7 +664,7 @@ export const SandboxProvider = BotSandbox;
export type SandboxProvider = BotSandbox;
export type CloudSandboxProvider = Exclude<SandboxProvider, "local">;
-export const CLOUD_SANDBOX_PROVIDERS = ["e2b", "daytona", "vercel", "upstash"] as const;
+export const CLOUD_SANDBOX_PROVIDERS = ["e2b", "daytona", "vercel", "upstash", "tenki"] as const;
export const SANDBOX_PROVIDER_CREDENTIALS = {
e2b: [{ name: "E2B_API_KEY", sensitive: true }],
daytona: [{ name: "DAYTONA_API_KEY", sensitive: true }],
@@ -674,6 +674,7 @@ export const SANDBOX_PROVIDER_CREDENTIALS = {
{ name: "VERCEL_PROJECT_ID", sensitive: false },
],
upstash: [{ name: "UPSTASH_BOX_API_KEY", sensitive: true }],
+ tenki: [{ name: "TENKI_API_KEY", sensitive: true }],
} as const satisfies Readonly<
Record<
CloudSandboxProvider,
@@ -698,6 +699,7 @@ export const SandboxSettings = Schema.Struct({
daytona: SandboxProviderConnection,
vercel: SandboxProviderConnection,
upstash: SandboxProviderConnection,
+ tenki: SandboxProviderConnection,
}).pipe(Schema.withDecodingDefault(Effect.succeed({}))),
}).pipe(Schema.withDecodingDefault(Effect.succeed({})));
export type SandboxSettings = typeof SandboxSettings.Type;
@@ -1010,6 +1012,7 @@ const SandboxSettingsPatch = Schema.Struct({
daytona: Schema.optionalKey(SandboxProviderConnectionPatch),
vercel: Schema.optionalKey(SandboxProviderConnectionPatch),
upstash: Schema.optionalKey(SandboxProviderConnectionPatch),
+ tenki: Schema.optionalKey(SandboxProviderConnectionPatch),
}),
),
});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index fe11e3855..e150609d0 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -517,6 +517,9 @@ importers:
'@photon-ai/chat-adapter-imessage':
specifier: 3.2.0
+ '@tenkicloud/sandbox':
+ specifier: 1.3.0
'@upstash/box':
specifier: 0.5.3
version: 0.5.3([email protected])
@@ -2173,6 +2176,9 @@ packages:
cpu: [x64]
os: [win32]
+ '@bufbuild/[email protected]':
+ resolution: {integrity: sha512-BvAMfS6LrgZiryOAZ4pBYucu4wG/Ei/9o9DZ9akbREnMLbPJiom2i8b9C8IsKErQoiKqVhrerzt3kOT/RrzLHg==}
+
'@bufbuild/[email protected]':
resolution: {integrity: sha512-C3UGsiCwSprE2NKIIFA3hCDlpXTMCAXRZuEVp88L1GY36Y41+rYL5fryE+nOFhp4p4JPQvdV8PQ4DWgHgeTE+w==}
@@ -2348,6 +2354,13 @@ packages:
peerDependencies:
zod: '>=3.25.76 <5'
+ '@connectrpc/[email protected]':
+ resolution: {integrity: sha512-+i/aAOpsI8sIx1mbYp6d99zvxaUSF6t/jP9Ux9maAmjsZPgmIQ3JuIeYi0zJIP9zlCnBlJjkpPosshCgdRuThQ==}
+ engines: {node: '>=20'}
+ peerDependencies:
+ '@bufbuild/protobuf': ^2.7.0
+ '@connectrpc/connect': 2.1.2
+
'@connectrpc/[email protected]':
resolution: {integrity: sha512-1tfaK85MU+gJjwwmL31d2rzdf0XCYX99chZf63uG89SGBUd4XuZ4ZzhGo2u79TPXOE6nLIZQ2okrpyey42PYdg==}
peerDependencies:
@@ -2411,6 +2424,7 @@ packages:
'@distilled.cloud/[email protected]':
resolution: {integrity: sha512-UO9wjepZWYupWMf/KYKY7LUueHNawdp0qBGc9z3XYxjodrQaMwFQWtIGG1yWOHjTWl1BUx86A69hyB8kHYRAeA==}
+ deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
peerDependencies:
rolldown: ^1.1.5
vite: ^7.0.0 || ^8.0.0
@@ -2435,6 +2449,7 @@ packages:
'@distilled.cloud/[email protected]':
resolution: {integrity: sha512-O8lvG48OQcRkjwkCPUGdEGTtDuaKBlZWIMy+yTCAUnte/8rvixIxUj/PMX6lx4Prj2tx/ciqjRHl9qjtHL8KWA==}
+ deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
peerDependencies:
'@distilled.cloud/cloudflare': ^0.29.0
'@distilled.cloud/cloudflare-runtime': 0.13.10
@@ -6105,6 +6120,10 @@ packages:
'@tavily/[email protected]':
resolution: {integrity: sha512-XV3SB2AxpD52SMyTjLHxoZED8K+zWLBxsQ778iCXwmYmp1zTQXwNPV7gUmJX6qLKFHwq7Tum9XVqxFqqbCwagA==}
+ '@tenkicloud/[email protected]':
+ resolution: {integrity: sha512-wJ5dFLs7cZJl87ATP0MAZ0r8FIeYw1EorKu+JpQFxwwq6OYplewlGvpddBaOn1hLw601QL/jHXJzAKy8e85zvA==}
+ engines: {node: '>=18'}
+
'@testing-library/[email protected]':
resolution: {integrity: sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==}
engines: {node: '>=18'}
@@ -15333,6 +15352,8 @@ snapshots:
'@bruits/[email protected]':
optional: true
+ '@bufbuild/[email protected]': {}
+
'@bufbuild/[email protected]': {}
@@ -15647,11 +15668,20 @@ snapshots:
dependencies:
zod: 4.4.3
+ '@connectrpc/[email protected](@bufbuild/[email protected])(@connectrpc/[email protected](@bufbuild/[email protected]))':
+ dependencies:
+ '@bufbuild/protobuf': 2.12.1
+ '@connectrpc/connect': 2.1.2(@bufbuild/[email protected])
+
'@connectrpc/[email protected](@bufbuild/[email protected])(@connectrpc/[email protected](@bufbuild/[email protected]))':
dependencies:
'@bufbuild/protobuf': 2.14.0
'@connectrpc/connect': 2.1.2(@bufbuild/[email protected])
+ '@connectrpc/[email protected](@bufbuild/[email protected])':
+ dependencies:
+ '@bufbuild/protobuf': 2.12.1
+
'@connectrpc/[email protected](@bufbuild/[email protected])':
dependencies:
'@bufbuild/protobuf': 2.14.0
@@ -20045,6 +20075,16 @@ snapshots:
- debug
- supports-color
+ dependencies:
+ '@bufbuild/protobuf': 2.12.1
+ '@connectrpc/connect': 2.1.2(@bufbuild/[email protected])
+ '@connectrpc/connect-node': 2.1.2(@bufbuild/[email protected])(@connectrpc/[email protected](@bufbuild/[email protected]))
+ transitivePeerDependencies:
+ - bufferutil
+ - utf-8-validate
+
'@testing-library/[email protected]':
dependencies:
'@babel/code-frame': 7.29.7