@ekairos/sandbox 1.22.10-beta.development.0 → 1.22.11-beta.development.0

package/dist/service.js

@@ -1,8 +1,10 @@
 import { Sandbox as VercelSandbox } from "@vercel/sandbox";
 import { Daytona, Image } from "@daytonaio/sdk";
-import { id } from "@instantdb/admin";
+import { id, init } from "@instantdb/admin";
 import { resolveRuntime } from "@ekairos/domain/runtime";
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from "@workflow/serde";
 import { runCommandInSandbox } from "./commands.js";
+import { sandboxDomain } from "./schema.js";
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { existsSync, promises as fs } from "node:fs";
@@ -10,6 +12,14 @@ import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
+function isVercelSandbox(sandbox) {
+    return Boolean(sandbox &&
+        typeof sandbox === "object" &&
+        typeof sandbox.runCommand === "function" &&
+        typeof sandbox.currentSession === "function" &&
+        typeof sandbox.name === "string" &&
+        sandbox.__provider !== "sprites");
+}
 const EKAIROS_ROOT_DIR = "/vercel/sandbox/.ekairos";
 const EKAIROS_RUNTIME_MANIFEST_PATH = `${EKAIROS_ROOT_DIR}/runtime.json`;
 const EKAIROS_HTTP_HELPER_PATH = `${EKAIROS_ROOT_DIR}/instant-http.mjs`;
@@ -17,6 +27,8 @@ const EKAIROS_QUERY_SCRIPT_PATH = `${EKAIROS_ROOT_DIR}/query.mjs`;
 const CODEX_HOME_DIR = "/vercel/sandbox/.codex";
 const CODEX_SKILLS_DIR = `${CODEX_HOME_DIR}/skills`;
 const INSTANT_API_BASE_URL = "https://api.instantdb.com";
+const SANDBOX_PROCESS_STREAM_VERSION = 1;
+const SANDBOX_PROCESS_TERMINAL_STATUSES = new Set(["exited", "failed", "killed", "lost"]);
 function formatInstantSchemaError(err) {
     const base = err instanceof Error ? err.message : String(err);
     const body = err?.body;
@@ -49,9 +61,200 @@ function formatSandboxError(err) {
         return base;
     return `${base}: ${detail}`;
 }
+function nowIso() {
+    return new Date().toISOString();
+}
+function asOptionalString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function sanitizeInstantString(value) {
+    return value.includes("\0") ? value.replace(/\0/g, "") : value;
+}
+function sanitizeInstantValue(value) {
+    if (typeof value === "string") {
+        return sanitizeInstantString(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => sanitizeInstantValue(item));
+    }
+    if (value && typeof value === "object" && !(value instanceof Date)) {
+        const sanitized = {};
+        for (const [key, entry] of Object.entries(value)) {
+            sanitized[key] = sanitizeInstantValue(entry);
+        }
+        return sanitized;
+    }
+    return value;
+}
+function createSandboxProcessStreamClientId(processId) {
+    const normalized = String(processId ?? "").trim();
+    if (!normalized)
+        throw new Error("sandbox_process_id_required");
+    return `sandbox-process:${normalized}`;
+}
+function encodeSandboxProcessStreamChunk(chunk) {
+    return `${JSON.stringify(chunk)}\n`;
+}
+function parseSandboxProcessStreamChunk(value) {
+    const parsed = typeof value === "string" ? JSON.parse(value) : value;
+    if (!parsed || typeof parsed !== "object") {
+        throw new Error("invalid_sandbox_process_stream_chunk");
+    }
+    const record = parsed;
+    if (record.version !== SANDBOX_PROCESS_STREAM_VERSION) {
+        throw new Error(`invalid_sandbox_process_stream_version:${String(record.version)}`);
+    }
+    return record;
+}
+function resolveDbConfig(db) {
+    const config = db?.config ?? {};
+    const appId = String(config.appId ?? "").trim();
+    const adminToken = String(config.adminToken ?? "").trim();
+    if (!appId || !adminToken) {
+        throw new Error("sandbox_service_db_config_required");
+    }
+    return { appId, adminToken };
+}
+function createAdminDbFromConfig(config) {
+    return init({
+        appId: config.appId,
+        adminToken: config.adminToken,
+        schema: sandboxDomain.toInstantSchema(),
+        useDateObjects: true,
+    });
+}
+function sandboxProcessFinishedHookToken(processId) {
+    return `sandbox-process:${processId}:finished`;
+}
+async function resumeSandboxProcessHook(processId, payload) {
+    try {
+        const { resumeHook } = await import("workflow/api");
+        await resumeHook(sandboxProcessFinishedHookToken(processId), payload);
+    }
+    catch {
+        // No workflow may be listening; process metadata and streams remain the source of truth.
+    }
+}
+function commandResultFromProcessStream(params) {
+    const stdout = params.chunks
+        .filter((chunk) => chunk.type === "stdout")
+        .map((chunk) => String(chunk.data?.text ?? ""))
+        .join("");
+    const stderr = params.chunks
+        .filter((chunk) => chunk.type === "stderr" || chunk.type === "error")
+        .map((chunk) => String(chunk.data?.text ?? chunk.data?.message ?? ""))
+        .join("");
+    const exitChunk = [...params.chunks].reverse().find((chunk) => chunk.type === "exit");
+    const exitCode = Number(exitChunk?.data?.exitCode ?? params.processRow?.exitCode ?? 1);
+    const command = [
+        String(params.processRow?.command ?? ""),
+        ...(Array.isArray(params.processRow?.args) ? params.processRow.args : []),
+    ]
+        .filter(Boolean)
+        .join(" ");
+    return {
+        success: exitCode === 0,
+        exitCode,
+        output: stdout,
+        error: stderr,
+        command,
+    };
+}
+export class SandboxCommandRun {
+    constructor(data, service) {
+        this.service = null;
+        this.data = data;
+        this.service = service ?? null;
+    }
+    static [WORKFLOW_SERIALIZE](instance) {
+        return instance.data;
+    }
+    static [WORKFLOW_DESERIALIZE](data) {
+        return new SandboxCommandRun(data);
+    }
+    get sandboxId() {
+        return this.data.sandboxId;
+    }
+    get processId() {
+        return this.data.processId;
+    }
+    get streamId() {
+        return this.data.streamId;
+    }
+    get streamClientId() {
+        return this.data.streamClientId;
+    }
+    getService() {
+        if (!this.service) {
+            this.service = new SandboxService(createAdminDbFromConfig(this.data.db));
+        }
+        return this.service;
+    }
+    async readStream() {
+        "use step";
+        const stream = await this.getService().readProcessStream(this.processId);
+        if (!stream.ok)
+            throw new Error(stream.error);
+        return stream.data;
+    }
+    async snapshot() {
+        "use step";
+        const snapshot = await this.getService().getProcessSnapshot(this.processId);
+        if (!snapshot.ok)
+            throw new Error(snapshot.error);
+        return snapshot.data;
+    }
+    async wait(params) {
+        if (this.data.result)
+            return this.data.result;
+        const initial = await this.snapshot();
+        if (SANDBOX_PROCESS_TERMINAL_STATUSES.has(String(initial.status ?? ""))) {
+            const stream = await this.readStream();
+            const result = commandResultFromProcessStream({ processRow: initial, chunks: stream.chunks });
+            this.data.result = result;
+            return result;
+        }
+        try {
+            const { createHook } = await import("workflow");
+            const hook = createHook({
+                token: sandboxProcessFinishedHookToken(this.processId),
+            });
+            const result = await hook;
+            this.data.result = result;
+            return result;
+        }
+        catch {
+            // Outside workflow context, or if hooks are unavailable, poll the durable row.
+        }
+        const timeoutMs = Math.max(0, Number(params?.timeoutMs ?? 5 * 60 * 1000));
+        const pollMs = Math.max(50, Number(params?.pollMs ?? 500));
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() <= deadline) {
+            const row = await this.snapshot();
+            if (SANDBOX_PROCESS_TERMINAL_STATUSES.has(String(row.status ?? ""))) {
+                const stream = await this.readStream();
+                const result = commandResultFromProcessStream({ processRow: row, chunks: stream.chunks });
+                this.data.result = result;
+                return result;
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollMs));
+        }
+        throw new Error(`sandbox_process_wait_timeout:${this.processId}`);
+    }
+    then(onfulfilled, onrejected) {
+        return this.wait().then(onfulfilled, onrejected);
+    }
+}
 export class SandboxService {
     constructor(db) {
         this.adminDb = db;
+        this.dbConfig = resolveDbConfig(db);
+    }
+    static [WORKFLOW_SERIALIZE](instance) {
+        return { db: instance.dbConfig };
+    }
+    static [WORKFLOW_DESERIALIZE](data) {
+        return new SandboxService(createAdminDbFromConfig(data.db));
     }
     static getVercelCredentials() {
         const teamId = String(process.env.SANDBOX_VERCEL_TEAM_ID ?? "").trim();
@@ -639,8 +842,8 @@ export class SandboxService {
                         : "";
         return {
             exitCode: Number.isFinite(exitCode) ? exitCode : 0,
-            stdout,
-            stderr,
+            stdout: sanitizeInstantString(stdout),
+            stderr: sanitizeInstantString(stderr),
         };
     }
     static async spritesExec(params) {
@@ -829,6 +1032,7 @@ export class SandboxService {
         return image;
     }
     async createSandbox(config) {
+        "use step";
         const sandboxId = id();
         const now = Date.now();
         const provider = SandboxService.resolveProvider(config);
@@ -977,7 +1181,7 @@ export class SandboxService {
                 ? sandbox.id
                 : provider === "sprites"
                     ? String(sandbox.name)
-                    : sandbox.sandboxId;
+                    : sandbox.name;
             const sandboxUrl = provider === "sprites" ? sandbox.url : undefined;
             const activateMutations = [
                 this.adminDb.tx.sandbox_sandboxes[sandboxId].update({
@@ -1144,7 +1348,7 @@ export class SandboxService {
                 const delayMs = 500;
                 for (let attempt = 0; attempt < maxAttempts; attempt++) {
                     const sandbox = await VercelSandbox.get({
-                        sandboxId: String(record.externalSandboxId),
+                        name: String(record.externalSandboxId),
                         teamId: creds.teamId,
                         projectId: creds.projectId,
                         token: creds.token,
@@ -1180,7 +1384,82 @@ export class SandboxService {
         });
         return recordResult?.sandbox_sandboxes?.[0] ?? null;
     }
+    async getProcessSnapshot(processId) {
+        "use step";
+        try {
+            const processResult = await this.adminDb.query({
+                sandbox_processes: {
+                    $: { where: { id: processId }, limit: 1 },
+                    sandbox: {},
+                },
+            });
+            const processRow = processResult?.sandbox_processes?.[0];
+            if (!processRow)
+                return { ok: false, error: "sandbox_process_not_found" };
+            return { ok: true, data: processRow };
+        }
+        catch (e) {
+            return { ok: false, error: formatInstantSchemaError(e) };
+        }
+    }
+    async markOpenProcessesLost(sandboxId, reason) {
+        try {
+            const processResult = await this.adminDb.query({
+                sandbox_processes: {
+                    $: {
+                        where: { "sandbox.id": sandboxId },
+                        limit: 500,
+                    },
+                },
+            });
+            const rows = Array.isArray(processResult?.sandbox_processes)
+                ? processResult.sandbox_processes
+                : [];
+            const now = Date.now();
+            const txs = rows
+                .filter((row) => !SANDBOX_PROCESS_TERMINAL_STATUSES.has(String(row?.status ?? "")))
+                .map((row) => this.adminDb.tx.sandbox_processes[String(row.id)].update({
+                status: "lost",
+                streamFinishedAt: row.streamFinishedAt ?? now,
+                streamAbortReason: reason,
+                exitedAt: now,
+                updatedAt: now,
+                metadata: {
+                    ...(row.metadata ?? {}),
+                    lostReason: reason,
+                },
+            }));
+            if (txs.length > 0) {
+                await this.adminDb.transact(txs);
+            }
+        }
+        catch {
+            // Best-effort cleanup; stopping the sandbox should not fail because process metadata could not be marked.
+        }
+    }
+    async createProcessStream(params) {
+        const streams = this.adminDb?.streams;
+        if (!streams?.createWriteStream) {
+            throw new Error("sandbox_process_streams_unavailable");
+        }
+        const streamClientId = params.streamClientId || createSandboxProcessStreamClientId(params.processId);
+        const stream = streams.createWriteStream({ clientId: streamClientId });
+        const streamId = typeof stream.streamId === "function" ? await stream.streamId() : streamClientId;
+        return { stream, streamId, streamClientId };
+    }
+    async writeProcessChunk(params) {
+        await params.writer.write(encodeSandboxProcessStreamChunk({
+            version: SANDBOX_PROCESS_STREAM_VERSION,
+            at: nowIso(),
+            seq: params.seq,
+            type: params.type,
+            sandboxId: params.sandboxId,
+            processId: params.processId,
+            ...(params.data ? { data: sanitizeInstantValue(params.data) } : {}),
+        }));
+    }
     async stopSandbox(sandboxId) {
+        "use step";
         try {
             const result = await this.reconnectToSandbox(sandboxId);
             const recordResult = await this.adminDb.query({
@@ -1195,7 +1474,7 @@ export class SandboxService {
             if (result.ok) {
                 try {
                     const sandbox = result.data.sandbox;
-                    if (sandbox?.sandboxId) {
+                    if (isVercelSandbox(sandbox)) {
                         await sandbox.stop();
                     }
                     else if (sandbox?.__provider === "sprites") {
@@ -1231,6 +1510,7 @@ export class SandboxService {
                 shutdownAt: Date.now(),
                 updatedAt: Date.now(),
             }));
+            await this.markOpenProcessesLost(sandboxId, "sandbox_stopped");
             return { ok: true, data: undefined };
         }
         catch (e) {
@@ -1273,12 +1553,13 @@ export class SandboxService {
         }
     }
     async runCommand(sandboxId, command, args = []) {
+        "use step";
         try {
             const sandboxResult = await this.reconnectToSandbox(sandboxId);
             if (!sandboxResult.ok)
                 return { ok: false, error: sandboxResult.error };
             const sandbox = sandboxResult.data.sandbox;
-            if (sandbox.sandboxId) {
+            if (isVercelSandbox(sandbox)) {
                 const result = await runCommandInSandbox(sandbox, command, args);
                 return { ok: true, data: result };
             }
@@ -1319,13 +1600,283 @@ export class SandboxService {
             return { ok: false, error: formatInstantSchemaError(e) };
         }
     }
+    async runCommandProcess(sandboxId, command, args = [], opts) {
+        "use step";
+        const processId = id();
+        const now = Date.now();
+        let writer = null;
+        let stream = null;
+        let seq = 0;
+        try {
+            const record = await this.getSandboxRecord(sandboxId);
+            if (!record)
+                return { ok: false, error: "Valid sandbox record not found" };
+            if (record.status !== "active")
+                return { ok: false, error: `sandbox_not_active:${record.status}` };
+            const streamSession = await this.createProcessStream({ sandboxId, processId });
+            stream = streamSession.stream;
+            writer = stream.getWriter();
+            await this.adminDb.transact([
+                this.adminDb.tx.sandbox_processes[processId]
+                    .update({
+                    kind: opts?.kind ?? "command",
+                    mode: opts?.mode ?? "foreground",
+                    status: "running",
+                    provider: String(record.provider ?? "unknown"),
+                    command: sanitizeInstantString(command),
+                    args: sanitizeInstantValue(Array.isArray(args) ? args : []),
+                    cwd: asOptionalString(opts?.cwd),
+                    env: sanitizeInstantValue(opts?.env),
+                    streamId: streamSession.streamId,
+                    streamClientId: streamSession.streamClientId,
+                    streamStartedAt: now,
+                    startedAt: now,
+                    updatedAt: now,
+                    metadata: sanitizeInstantValue(opts?.metadata),
+                })
+                    .link({ sandbox: sandboxId, stream: streamSession.streamId }),
+            ]);
+            seq += 1;
+            await this.writeProcessChunk({
+                writer,
+                sandboxId,
+                processId,
+                seq,
+                type: "status",
+                data: {
+                    status: "running",
+                    command,
+                    args: Array.isArray(args) ? args : [],
+                    cwd: opts?.cwd ?? null,
+                },
+            });
+            const result = await this.runCommand(sandboxId, command, args);
+            const finishedAt = Date.now();
+            let finalResult;
+            let status;
+            let exitCode;
+            let errorText;
+            if (result.ok) {
+                finalResult = result.data;
+                exitCode = Number(result.data.exitCode ?? (result.data.success === false ? 1 : 0));
+                status = exitCode === 0 ? "exited" : "failed";
+                const stdout = String(result.data.stdout ?? result.data.output ?? "");
+                const stderr = String(result.data.stderr ?? result.data.error ?? "");
+                if (stdout) {
+                    seq += 1;
+                    await this.writeProcessChunk({
+                        writer,
+                        sandboxId,
+                        processId,
+                        seq,
+                        type: "stdout",
+                        data: { text: stdout },
+                    });
+                }
+                if (stderr) {
+                    seq += 1;
+                    await this.writeProcessChunk({
+                        writer,
+                        sandboxId,
+                        processId,
+                        seq,
+                        type: "stderr",
+                        data: { text: stderr },
+                    });
+                }
+            }
+            else {
+                exitCode = 1;
+                status = "failed";
+                errorText = result.error;
+                finalResult = {
+                    success: false,
+                    exitCode,
+                    output: "",
+                    error: result.error,
+                    command: [command, ...(Array.isArray(args) ? args : [])].join(" "),
+                };
+                seq += 1;
+                await this.writeProcessChunk({
+                    writer,
+                    sandboxId,
+                    processId,
+                    seq,
+                    type: "error",
+                    data: { message: result.error },
+                });
+            }
+            seq += 1;
+            await this.writeProcessChunk({
+                writer,
+                sandboxId,
+                processId,
+                seq,
+                type: "exit",
+                data: { exitCode, status },
+            });
+            await writer.close();
+            writer = null;
+            await this.adminDb.transact([
+                this.adminDb.tx.sandbox_processes[processId].update({
+                    status,
+                    exitCode,
+                    streamFinishedAt: finishedAt,
+                    streamAbortReason: null,
+                    exitedAt: finishedAt,
+                    updatedAt: finishedAt,
+                    metadata: sanitizeInstantValue({
+                        ...(opts?.metadata ?? {}),
+                        ...(errorText ? { error: errorText } : {}),
+                        chunkCount: seq,
+                        result: finalResult,
+                    }),
+                }),
+            ]);
+            await resumeSandboxProcessHook(processId, finalResult);
+            return {
+                ok: true,
+                data: new SandboxCommandRun({
+                    db: this.dbConfig,
+                    sandboxId,
+                    processId,
+                    streamId: streamSession.streamId,
+                    streamClientId: streamSession.streamClientId,
+                    result: finalResult,
+                }, this),
+            };
+        }
+        catch (e) {
+            const message = formatInstantSchemaError(e);
+            const failedAt = Date.now();
+            try {
+                if (writer) {
+                    seq += 1;
+                    await this.writeProcessChunk({
+                        writer,
+                        sandboxId,
+                        processId,
+                        seq,
+                        type: "error",
+                        data: { message },
+                    });
+                    await writer.abort(message);
+                    writer = null;
+                }
+                else if (stream) {
+                    await stream.abort(message);
+                }
+            }
+            catch {
+                // ignore stream cleanup errors
+            }
+            try {
+                const finalResult = {
+                    success: false,
+                    exitCode: 1,
+                    output: "",
+                    error: message,
+                    command: [command, ...(Array.isArray(args) ? args : [])].join(" "),
+                };
+                await this.adminDb.transact([
+                    this.adminDb.tx.sandbox_processes[processId].update({
+                        status: "failed",
+                        streamFinishedAt: failedAt,
+                        streamAbortReason: message,
+                        exitedAt: failedAt,
+                        updatedAt: failedAt,
+                        metadata: sanitizeInstantValue({
+                            ...(opts?.metadata ?? {}),
+                            error: message,
+                            result: finalResult,
+                        }),
+                    }),
+                ]);
+                await resumeSandboxProcessHook(processId, finalResult);
+            }
+            catch {
+                // ignore partial metadata failures
+            }
+            return { ok: false, error: message };
+        }
+        finally {
+            try {
+                writer?.releaseLock();
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    async runCommandWithProcessStream(sandboxId, command, args = [], opts) {
+        const run = await this.runCommandProcess(sandboxId, command, args, opts);
+        if (!run.ok)
+            return run;
+        const result = await run.data;
+        return {
+            ok: true,
+            data: {
+                processId: run.data.processId,
+                streamId: run.data.streamId,
+                streamClientId: run.data.streamClientId,
+                result,
+            },
+        };
+    }
+    async readProcessStream(processId) {
+        "use step";
+        try {
+            const processResult = await this.adminDb.query({
+                sandbox_processes: {
+                    $: { where: { id: processId }, limit: 1 },
+                },
+            });
+            const processRow = processResult?.sandbox_processes?.[0];
+            if (!processRow)
+                return { ok: false, error: "sandbox_process_not_found" };
+            const streams = this.adminDb?.streams;
+            if (!streams?.createReadStream)
+                return { ok: false, error: "sandbox_process_streams_unavailable" };
+            const clientId = String(processRow.streamClientId ?? "").trim() || undefined;
+            const streamId = String(processRow.streamId ?? "").trim() || undefined;
+            if (!clientId && !streamId)
+                return { ok: false, error: "sandbox_process_stream_missing" };
+            const stream = streams.createReadStream({ clientId, streamId });
+            const chunks = [];
+            let byteOffset = 0;
+            let buffer = "";
+            for await (const raw of stream) {
+                const encoded = typeof raw === "string" ? raw : String(raw ?? "");
+                if (!encoded)
+                    continue;
+                byteOffset += new TextEncoder().encode(encoded).length;
+                buffer += encoded;
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    chunks.push(parseSandboxProcessStreamChunk(trimmed));
+                }
+            }
+            const trailing = buffer.trim();
+            if (trailing)
+                chunks.push(parseSandboxProcessStreamChunk(trailing));
+            return { ok: true, data: { chunks, byteOffset } };
+        }
+        catch (e) {
+            return { ok: false, error: formatInstantSchemaError(e) };
+        }
+    }
     async writeFiles(sandboxId, files) {
+        "use step";
         try {
             const sandboxResult = await this.reconnectToSandbox(sandboxId);
             if (!sandboxResult.ok)
                 return { ok: false, error: sandboxResult.error };
             const sandbox = sandboxResult.data.sandbox;
-            if (sandbox.sandboxId) {
+            if (isVercelSandbox(sandbox)) {
                 await sandbox.writeFiles(files.map((f) => ({
                     path: f.path,
                     content: Buffer.from(f.contentBase64, "base64"),
@@ -1362,12 +1913,13 @@ export class SandboxService {
         }
     }
     async readFile(sandboxId, path) {
+        "use step";
         try {
             const sandboxResult = await this.reconnectToSandbox(sandboxId);
             if (!sandboxResult.ok)
                 return { ok: false, error: sandboxResult.error };
             const sandbox = sandboxResult.data.sandbox;
-            if (sandbox.sandboxId) {
+            if (isVercelSandbox(sandbox)) {
                 const stream = await sandbox.readFile({ path });
                 if (!stream) {
                     return { ok: true, data: { contentBase64: "" } };