@sanlabs/sanbox-cli 0.0.3 → 0.0.5

package/dist/config.js

@@ -11,7 +11,6 @@ export const readLocalConfig = (cwd = process.cwd()) => {
         const record = parsed;
         return {
             api_url: typeof record.api_url === "string" ? record.api_url : undefined,
-            org: typeof record.org === "string" ? record.org : undefined,
             default_template: typeof record.default_template === "string" ? record.default_template : undefined
         };
     }
@@ -24,19 +23,13 @@ export const readLocalConfig = (cwd = process.cwd()) => {
 export const readConfig = (flags = {}) => {
     const localConfig = readLocalConfig();
     const apiUrl = String(flags["api-url"] || process.env.SANBOX_API_URL || localConfig.api_url || defaultApiUrl).replace(/\/+$/, "");
-    const org = String(flags.org || process.env.SANBOX_ORG || localConfig.org || "").trim();
     const apiKey = process.env.SANBOX_API_KEY || "";
-    if (!org) {
-        throw new CliError("org_required", "Organization context is required.", {
-            nextActions: [commandAction(["sanbox", "context", "--json"], "Select an organization and retry with SANBOX_ORG set.", { SANBOX_ORG: "<org-slug>" })]
-        });
-    }
     if (!apiKey) {
         throw new CliError("api_key_required", "SANBOX_API_KEY is required.", {
             nextActions: [commandAction(["sanbox", "auth", "check", "--json"], "Set a Sanbox control-plane API key and check access.", { SANBOX_API_KEY: "<sanbox-api-key>" })]
         });
     }
-    return { apiUrl, org, apiKey };
+    return { apiUrl, apiKey };
 };
 export function readTemplateSelection(flags = {}, options = {}) {
     const flagValue = flags.template;
@@ -52,7 +45,7 @@ export function readTemplateSelection(flags = {}, options = {}) {
         return null;
     throw new CliError("template_required", "A template must be selected explicitly.", {
         nextActions: [
-            commandAction(["sanbox", "templates", "list", "--json"], "List templates available to the selected organization."),
+            commandAction(["sanbox", "templates", "list", "--json"], "List templates available to the API key's organization."),
             commandAction(["sanbox", "run", "<task>", "--template", "<template-id>"], "Run with an explicit template."),
             commandAction(["sanbox", "context", "--json"], "Select a template for this shell and inspect the resolved context.", { SANBOX_TEMPLATE: "<template-id>" })
         ]

package/dist/inputs.js

@@ -0,0 +1,150 @@
+import crypto from "node:crypto";
+import { constants as fsConstants } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import fg from "fast-glob";
+import ignore from "ignore";
+import yazl from "yazl";
+const maximumInputBytes = 64 * 1024 * 1024;
+const maximumInputFiles = 10_000;
+const defaultIgnorePatterns = [
+    ".git/**",
+    "**/.git/**",
+    "node_modules/**",
+    "**/node_modules/**",
+    "dist/**",
+    "**/dist/**",
+    "build/**",
+    "**/build/**",
+    "coverage/**",
+    "**/coverage/**",
+    ".next/**",
+    "**/.next/**",
+    ".turbo/**",
+    "**/.turbo/**",
+    ".env",
+    ".env.*",
+    "**/.env",
+    "**/.env.*",
+    "**/*secret*",
+    "**/*Secret*",
+    "**/*token*",
+    "**/*Token*",
+    "**/*credential*",
+    "**/*Credential*",
+    "**/*.pem",
+    "**/*.key",
+    "**/id_rsa",
+    "**/id_ed25519"
+];
+const normalizePattern = async (cwd, pattern) => {
+    const slashPattern = pattern.replaceAll(path.sep, "/");
+    const normalizedPath = path.posix.normalize(slashPattern);
+    if (path.isAbsolute(pattern) || normalizedPath === ".." || normalizedPath.startsWith("../")) {
+        throw new Error(`Input path must be relative to the current directory: ${pattern}`);
+    }
+    if (pattern === ".")
+        return "**/*";
+    const normalized = normalizedPath.replace(/\/+$/, "");
+    if (normalized.includes("*"))
+        return normalized;
+    try {
+        const stat = await fs.stat(path.resolve(cwd, normalized));
+        if (stat.isDirectory())
+            return `${normalized}/**`;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    return normalized;
+};
+const readSanboxIgnore = async (cwd) => {
+    try {
+        const raw = await fs.readFile(path.join(cwd, ".sanboxignore"), "utf8");
+        return raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+};
+const selectedInputs = async (cwd, inputs) => {
+    const patterns = await Promise.all(inputs.map((input) => normalizePattern(cwd, input)));
+    const ignored = ignore().add([...defaultIgnorePatterns, ...(await readSanboxIgnore(cwd))]);
+    const candidates = await fg(patterns, {
+        cwd,
+        dot: true,
+        onlyFiles: true,
+        followSymbolicLinks: false,
+        unique: true
+    });
+    const normalizedCandidates = candidates
+        .map((item) => item.replaceAll(path.sep, "/"))
+        .filter((item) => !item.startsWith("../") && !path.isAbsolute(item))
+        .filter((item) => !ignored.ignores(item))
+        .sort();
+    const files = [];
+    for (const item of normalizedCandidates) {
+        const stat = await fs.lstat(path.join(cwd, item));
+        if (stat.isFile())
+            files.push(item);
+    }
+    return { patterns, files };
+};
+const zipToBuffer = async (zip) => new Promise((resolve, reject) => {
+    const chunks = [];
+    zip.outputStream.on("data", (chunk) => chunks.push(chunk));
+    zip.outputStream.on("error", reject);
+    zip.outputStream.on("end", () => resolve(Buffer.concat(chunks)));
+    zip.end();
+});
+export const sha256 = (buffer) => crypto.createHash("sha256").update(buffer).digest("hex");
+export const previewInputs = async (input) => {
+    const { patterns, files } = await selectedInputs(input.cwd, input.inputs);
+    const previewFiles = [];
+    let totalBytes = 0;
+    for (const relative of files) {
+        const stat = await fs.stat(path.join(input.cwd, relative));
+        if (!stat.isFile())
+            continue;
+        totalBytes += stat.size;
+        previewFiles.push({ path: relative, size: stat.size });
+    }
+    return { patterns, files: previewFiles, totalBytes };
+};
+export const buildInputBundle = async (input) => {
+    const { files } = await selectedInputs(input.cwd, input.inputs);
+    if (files.length === 0)
+        throw new Error("No files matched the supplied --input values.");
+    if (files.length > maximumInputFiles)
+        throw new Error(`Inputs exceed the ${maximumInputFiles}-file limit.`);
+    const zip = new yazl.ZipFile();
+    const metadata = [];
+    let totalBytes = 0;
+    for (const relative of files) {
+        const absolute = path.join(input.cwd, relative);
+        const file = await fs.open(absolute, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+        try {
+            const stat = await file.stat();
+            if (!stat.isFile())
+                continue;
+            if (totalBytes + stat.size > maximumInputBytes)
+                throw new Error("Inputs exceed the 64 MiB uncompressed limit.");
+            const content = await file.readFile();
+            totalBytes += content.byteLength;
+            if (totalBytes > maximumInputBytes)
+                throw new Error("Inputs exceed the 64 MiB uncompressed limit.");
+            metadata.push({ path: relative, size: content.byteLength, sha256: sha256(content) });
+            zip.addBuffer(content, `input/${relative}`, { mode: stat.mode });
+        }
+        finally {
+            await file.close();
+        }
+    }
+    const buffer = await zipToBuffer(zip);
+    if (buffer.byteLength > maximumInputBytes)
+        throw new Error("Inputs exceed the 64 MiB upload limit.");
+    return { buffer, sha256: sha256(buffer), files: metadata };
+};

package/dist/output.js

@@ -77,7 +77,9 @@ export const summarizeRun = (payload) => {
     const selection = [
         templateId ? `template=${templateId}` : "",
         run.provider_id ? `provider=${run.provider_id}` : "",
-        run.model_id ? `model=${run.model_id}` : ""
+        run.model_id ? `model=${run.model_id}` : "",
+        run.sandbox_state ? `sandbox=${run.sandbox_state}` : "",
+        run.snapshot_generation ? `snapshot=${run.snapshot_generation}` : ""
     ].filter(Boolean).join(" ");
     return `${run.id} ${run.status}${selection ? ` ${selection}` : ""}${run.exit_code === null ? "" : ` exit=${run.exit_code}`}${run.error ? ` error=${run.error}` : ""}`;
 };

package/dist/runs.js

@@ -1,9 +1,8 @@
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { buildTaskDossier, readDossierFile } from "./dossier.js";
-const terminalStatuses = new Set(["completed", "failed", "canceled", "expired"]);
-const inlineLimitBytes = 8 * 1024 * 1024;
+import { buildInputBundle } from "./inputs.js";
+const terminalStatuses = new Set(["completed", "failed", "canceled"]);
 export const isTerminalRun = (run) => terminalStatuses.has(run.status);
 export const waitForRun = async (client, runId, options = {}) => {
     const pollIntervalMs = options.pollIntervalMs ?? 2000;
@@ -18,32 +17,21 @@ export const waitForRun = async (client, runId, options = {}) => {
     return payload;
 };
 export const createRun = async (client, options) => {
-    const dossier = options.dossierPath
-        ? await readDossierFile(path.resolve(options.cwd, options.dossierPath))
-        : await buildTaskDossier({
-            cwd: options.cwd,
-            task: options.task || "",
-            include: options.include,
-            cliVersion: options.cliVersion
+    let inputCollectionId;
+    if (options.inputs.length > 0) {
+        const bundle = await buildInputBundle({ cwd: options.cwd, inputs: options.inputs });
+        const uploaded = await client.uploadInputCollection({
+            buffer: bundle.buffer,
+            sha256: bundle.sha256,
+            fileCount: bundle.files.length
         });
-    if (dossier.buffer.byteLength > inlineLimitBytes) {
-        throw new Error(`Dossier is ${dossier.buffer.byteLength} bytes; inline dossier limit is ${inlineLimitBytes} bytes.`);
+        inputCollectionId = uploaded.input_collection.id;
     }
-    const manifest = {
-        dossier: {
-            inline_base64: dossier.buffer.toString("base64"),
-            sha256: dossier.sha256
-        },
-        sanbox_cli: {
-            files: dossier.files,
-            source: options.dossierPath ? "dossier_file" : "generated_task"
-        }
-    };
     return client.createRun({
         external_run_id: options.externalRunId,
         workload_id: options.templateId,
-        manifest,
-        retention_ttl_seconds: options.retentionTtlSeconds
+        instruction: options.instruction,
+        ...(inputCollectionId ? { input_collection_id: inputCollectionId } : {})
     });
 };
 export const readTasks = async (tasksPath) => {
@@ -64,7 +52,7 @@ export const readTasks = async (tasksPath) => {
         return {
             task,
             external_run_id: record.external_run_id ? String(record.external_run_id) : undefined,
-            include: Array.isArray(record.include) ? record.include.map(String) : undefined
+            input: Array.isArray(record.input) ? record.input.map(String) : undefined
         };
     });
 };

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.0.3";
+export const version = "0.0.5";

package/dist/watch.js

@@ -1,6 +1,6 @@
 import { SanboxApiError } from "./api.js";
-const terminalStatuses = new Set(["completed", "failed", "canceled", "expired"]);
-const terminalEventKinds = new Set(["run.completed", "run.failed", "run.canceled", "run.expired"]);
+const terminalStatuses = new Set(["completed", "failed", "canceled"]);
+const terminalEventKinds = new Set(["run.completed", "run.failed", "run.canceled"]);
 const retryableNetworkCodes = new Set(["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT", "EAI_AGAIN", "ENETUNREACH"]);
 export class WatchInterruptedError extends Error {
     constructor() {
@@ -38,6 +38,65 @@ const assertActive = (signal, deadline, now, runId) => {
         throw new Error(`Timed out watching run ${runId}.`);
 };
 export const isTerminalStatus = (status) => terminalStatuses.has(status);
+export const watchEventsUntil = async (client, runId, options) => {
+    const pageSize = Math.max(1, Math.min(500, Math.floor(options.pageSize ?? 200)));
+    const pollIntervalMs = Math.max(1, Math.floor(options.pollIntervalMs ?? 2000));
+    const timeoutSeconds = Math.max(1, options.timeoutSeconds ?? 1800);
+    const maxReconnectDelayMs = Math.max(250, options.maxReconnectDelayMs ?? 10_000);
+    const sleep = options.sleep ?? defaultSleep;
+    const now = options.now ?? Date.now;
+    const random = options.random ?? Math.random;
+    const deadline = now() + timeoutSeconds * 1000;
+    let cursor = Math.max(0, Math.floor(options.afterEventId ?? 0));
+    const request = async (operation) => {
+        let attempt = 0;
+        for (;;) {
+            assertActive(options.signal, deadline, now, runId);
+            try {
+                return await operation();
+            }
+            catch (error) {
+                if (options.signal?.aborted)
+                    throw new WatchInterruptedError();
+                if (error instanceof WatchInterruptedError || !isRetryable(error))
+                    throw error;
+                attempt += 1;
+                const exponential = Math.min(maxReconnectDelayMs, 250 * (2 ** Math.min(attempt - 1, 8)));
+                const remainingMs = deadline - now();
+                if (remainingMs <= 0)
+                    throw new Error(`Timed out watching run ${runId}.`);
+                const delayMs = Math.min(remainingMs, Math.max(1, Math.floor(exponential * (0.8 + random() * 0.4))));
+                options.onRetry?.({ error, attempt, delayMs });
+                await sleep(delayMs, options.signal);
+            }
+        }
+    };
+    for (;;) {
+        assertActive(options.signal, deadline, now, runId);
+        let delivered = 0;
+        let fetchAnotherPage = true;
+        while (fetchAnotherPage) {
+            const page = await request(() => client.listEvents(runId, cursor, pageSize, options.signal));
+            const previousCursor = cursor;
+            const ordered = [...page.events].sort((left, right) => left.id - right.id);
+            const seen = new Set();
+            for (const event of ordered) {
+                if (!Number.isSafeInteger(event.id) || event.id <= cursor || seen.has(event.id))
+                    continue;
+                seen.add(event.id);
+                await options.onEvent?.(event);
+                cursor = event.id;
+                delivered += 1;
+                if (options.stopWhen(event))
+                    return event;
+            }
+            const reportedMore = page.has_more ?? page.events.length >= pageSize;
+            fetchAnotherPage = reportedMore && cursor > previousCursor;
+        }
+        if (delivered === 0)
+            await sleep(pollIntervalMs, options.signal);
+    }
+};
 export const watchRun = async (client, runId, options) => {
     const pageSize = Math.max(1, Math.min(500, Math.floor(options.pageSize ?? 200)));
     const pollIntervalMs = Math.max(1, Math.floor(options.pollIntervalMs ?? 2000));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanlabs/sanbox-cli",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "private": false,
   "repository": {
     "type": "git",

package/dist/dossier.js

@@ -1,187 +0,0 @@
-import crypto from "node:crypto";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { inflateRawSync } from "node:zlib";
-import fg from "fast-glob";
-import ignore from "ignore";
-import yazl from "yazl";
-const defaultIgnorePatterns = [
-    ".git/**",
-    "**/.git/**",
-    "node_modules/**",
-    "**/node_modules/**",
-    "dist/**",
-    "**/dist/**",
-    "build/**",
-    "**/build/**",
-    "coverage/**",
-    "**/coverage/**",
-    ".next/**",
-    "**/.next/**",
-    ".turbo/**",
-    "**/.turbo/**",
-    ".env",
-    ".env.*",
-    "**/.env",
-    "**/.env.*",
-    "**/*secret*",
-    "**/*Secret*",
-    "**/*token*",
-    "**/*Token*",
-    "**/*credential*",
-    "**/*Credential*",
-    "**/*.pem",
-    "**/*.key",
-    "**/id_rsa",
-    "**/id_ed25519"
-];
-const normalizePattern = async (cwd, pattern) => {
-    if (pattern === ".")
-        return "**/*";
-    const normalized = pattern.replaceAll(path.sep, "/").replace(/\/+$/, "");
-    if (normalized.includes("*"))
-        return normalized;
-    try {
-        const stat = await fs.stat(path.resolve(cwd, normalized));
-        if (stat.isDirectory())
-            return `${normalized}/**`;
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-    }
-    return normalized;
-};
-const normalizeInclude = async (cwd, patterns) => {
-    if (patterns.length === 0)
-        return ["**/*"];
-    return Promise.all(patterns.map((pattern) => normalizePattern(cwd, pattern)));
-};
-const readSanboxIgnore = async (cwd) => {
-    try {
-        const raw = await fs.readFile(path.join(cwd, ".sanboxignore"), "utf8");
-        return raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-};
-const zipToBuffer = async (zip) => new Promise((resolve, reject) => {
-    const chunks = [];
-    zip.outputStream.on("data", (chunk) => chunks.push(chunk));
-    zip.outputStream.on("error", reject);
-    zip.outputStream.on("end", () => resolve(Buffer.concat(chunks)));
-    zip.end();
-});
-export const sha256 = (buffer) => crypto.createHash("sha256").update(buffer).digest("hex");
-const selectedFiles = async (cwd, include) => {
-    const patterns = await normalizeInclude(cwd, include);
-    const ig = ignore().add([...defaultIgnorePatterns, ...(await readSanboxIgnore(cwd))]);
-    const candidates = await fg(patterns, {
-        cwd,
-        dot: true,
-        onlyFiles: true,
-        followSymbolicLinks: false,
-        unique: true
-    });
-    const files = candidates
-        .map((item) => item.replaceAll(path.sep, "/"))
-        .filter((item) => !item.startsWith("../") && !path.isAbsolute(item))
-        .filter((item) => !ig.ignores(item))
-        .sort();
-    return { patterns, files };
-};
-export const previewTaskDossier = async (input) => {
-    const { patterns, files } = await selectedFiles(input.cwd, input.include);
-    const previewFiles = [];
-    let totalBytes = 0;
-    for (const rel of files) {
-        const stat = await fs.stat(path.join(input.cwd, rel));
-        if (!stat.isFile())
-            continue;
-        totalBytes += stat.size;
-        previewFiles.push({ path: rel, size: stat.size });
-    }
-    return { patterns, files: previewFiles, totalBytes };
-};
-export const buildTaskDossier = async (input) => {
-    const { files } = await selectedFiles(input.cwd, input.include);
-    const zip = new yazl.ZipFile();
-    const fileMetadata = [];
-    const runbook = [
-        "# Sanbox Task",
-        "",
-        "Follow these instructions exactly.",
-        "",
-        input.task.trim(),
-        "",
-        "Write durable results under `/workspace/output`.",
-        "Use files under `/workspace/dossier/input/repo` as the provided source context."
-    ].join("\n");
-    zip.addBuffer(Buffer.from(runbook, "utf8"), "RUNBOOK.md");
-    for (const rel of files) {
-        const abs = path.join(input.cwd, rel);
-        const stat = await fs.stat(abs);
-        if (!stat.isFile())
-            continue;
-        const content = await fs.readFile(abs);
-        fileMetadata.push({ path: rel, size: stat.size, sha256: sha256(content) });
-        zip.addBuffer(content, `input/repo/${rel}`);
-    }
-    const manifest = {
-        source: "sanbox-cli",
-        cli_version: input.cliVersion,
-        created_at: new Date().toISOString(),
-        task: input.task,
-        files: fileMetadata
-    };
-    zip.addBuffer(Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`, "utf8"), "manifest.json");
-    const buffer = await zipToBuffer(zip);
-    return { buffer, sha256: sha256(buffer), files: fileMetadata };
-};
-export const readDossierFile = async (dossierPath) => {
-    const buffer = await fs.readFile(dossierPath);
-    return { buffer, sha256: sha256(buffer), files: [] };
-};
-export const writeTaskDossier = async (input) => {
-    const dossier = await buildTaskDossier(input);
-    await fs.mkdir(path.dirname(input.outPath), { recursive: true });
-    await fs.writeFile(input.outPath, dossier.buffer);
-    return dossier;
-};
-const readUInt16 = (buffer, offset) => buffer.readUInt16LE(offset);
-const readUInt32 = (buffer, offset) => buffer.readUInt32LE(offset);
-export const inspectDossierFile = async (dossierPath) => {
-    const buffer = await fs.readFile(dossierPath);
-    const entries = [];
-    let runbook;
-    let manifest;
-    let offset = 0;
-    while (offset + 30 <= buffer.length && readUInt32(buffer, offset) === 0x04034b50) {
-        const compressionMethod = readUInt16(buffer, offset + 8);
-        const compressedSize = readUInt32(buffer, offset + 18);
-        const uncompressedSize = readUInt32(buffer, offset + 22);
-        const nameLength = readUInt16(buffer, offset + 26);
-        const extraLength = readUInt16(buffer, offset + 28);
-        const nameStart = offset + 30;
-        const dataStart = nameStart + nameLength + extraLength;
-        const dataEnd = dataStart + compressedSize;
-        if (dataEnd > buffer.length)
-            break;
-        const entryPath = buffer.subarray(nameStart, nameStart + nameLength).toString("utf8");
-        entries.push({ path: entryPath, compressedSize, uncompressedSize });
-        if (entryPath === "RUNBOOK.md" || entryPath === "manifest.json") {
-            const compressed = buffer.subarray(dataStart, dataEnd);
-            const content = compressionMethod === 0 ? compressed : inflateRawSync(compressed);
-            const text = content.toString("utf8");
-            if (entryPath === "RUNBOOK.md")
-                runbook = text;
-            if (entryPath === "manifest.json")
-                manifest = JSON.parse(text);
-        }
-        offset = dataEnd;
-    }
-    return { entries, runbook, manifest };
-};