@sanlabs/sanbox-cli 0.0.1 → 0.0.4

package/dist/dossier.js

@@ -1,108 +0,0 @@
-import crypto from "node:crypto";
-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 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 normalizeInclude = (patterns) => patterns.length === 0 ? ["**/*"] : patterns.map((pattern) => (pattern === "." ? "**/*" : 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");
-export const buildTaskDossier = async (input) => {
-    const patterns = normalizeInclude(input.include);
-    const ig = ignore().add([...defaultIgnorePatterns, ...(await readSanboxIgnore(input.cwd))]);
-    const candidates = await fg(patterns, {
-        cwd: input.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();
-    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: [] };
-};

package/dist/mcp.js

@@ -1,131 +0,0 @@
-#!/usr/bin/env node
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import * as z from "zod/v4";
-import { SanboxClient } from "./api.js";
-import { defaultWorkloadId, readConfig } from "./config.js";
-import { createRun, readTasks, runPool, stableBatchId, waitForRun } from "./runs.js";
-import { version } from "./version.js";
-const textAndJson = (summary, structuredContent) => ({
-    content: [{ type: "text", text: `${summary}\n\n${JSON.stringify(structuredContent, null, 2)}` }],
-    structuredContent
-});
-const client = () => new SanboxClient(readConfig());
-const server = new McpServer({
-    name: "sanbox",
-    version
-});
-server.registerTool("create_sandbox_run", {
-    title: "Create Sanbox Run",
-    description: "Create one Sanbox run from a task or existing dossier ZIP.",
-    inputSchema: {
-        task: z.string().optional().describe("Task instructions. Required unless dossier_path is provided."),
-        dossier_path: z.string().optional().describe("Path to an existing dossier ZIP."),
-        include: z.array(z.string()).optional().describe("Repo file globs to include when task is provided."),
-        external_run_id: z.string().optional().describe("Optional idempotency key."),
-        workload_id: z.string().optional().default(defaultWorkloadId),
-        wait: z.boolean().optional().default(false)
-    }
-}, async (args) => {
-    if (!args.task && !args.dossier_path)
-        throw new Error("task or dossier_path is required.");
-    const api = client();
-    let payload = await createRun(api, {
-        cwd: process.cwd(),
-        cliVersion: version,
-        task: args.task,
-        dossierPath: args.dossier_path,
-        include: args.include || [],
-        externalRunId: args.external_run_id,
-        workloadId: args.workload_id || defaultWorkloadId
-    });
-    if (args.wait)
-        payload = await waitForRun(api, payload.run.id);
-    return textAndJson(`Run ${payload.run.id} is ${payload.run.status}.`, payload);
-});
-server.registerTool("create_sandbox_runs", {
-    title: "Create Multiple Sanbox Runs",
-    description: "Create independent Sanbox runs for parallel task delegation.",
-    inputSchema: {
-        tasks: z.array(z.object({
-            task: z.string(),
-            external_run_id: z.string().optional(),
-            include: z.array(z.string()).optional()
-        })).optional().describe("Inline tasks to run."),
-        tasks_path: z.string().optional().describe("Path to a JSON task array."),
-        include: z.array(z.string()).optional().describe("Default repo file globs for generated dossiers."),
-        batch_id: z.string().optional().describe("Optional stable batch id for idempotency."),
-        max_parallel: z.number().int().min(1).max(20).optional().default(5),
-        wait: z.boolean().optional().default(false)
-    }
-}, async (args) => {
-    const tasks = args.tasks_path ? await readTasks(args.tasks_path) : args.tasks;
-    if (!tasks || tasks.length === 0)
-        throw new Error("tasks or tasks_path is required.");
-    const batchId = args.batch_id || (args.tasks_path ? await stableBatchId(args.tasks_path) : `mcp-${Date.now().toString(36)}`);
-    const api = client();
-    const results = await runPool(tasks, args.max_parallel || 5, async (task, index) => {
-        let payload = await createRun(api, {
-            cwd: process.cwd(),
-            cliVersion: version,
-            task: task.task,
-            include: task.include || args.include || [],
-            externalRunId: task.external_run_id || `sanbox-batch-${batchId}-${index + 1}`,
-            workloadId: defaultWorkloadId
-        });
-        if (args.wait)
-            payload = await waitForRun(api, payload.run.id);
-        return payload;
-    });
-    const structured = { batch_id: batchId, runs: results.map((result) => result.run), results };
-    return textAndJson(`Created ${results.length} Sanbox runs.`, structured);
-});
-server.registerTool("get_sandbox_run", {
-    title: "Get Sanbox Run",
-    description: "Fetch a Sanbox run and recent events.",
-    inputSchema: {
-        run_id: z.string()
-    }
-}, async ({ run_id }) => {
-    const payload = await client().getRun(run_id);
-    return textAndJson(`Run ${payload.run.id} is ${payload.run.status}.`, payload);
-});
-server.registerTool("list_sandbox_events", {
-    title: "List Sanbox Events",
-    description: "List events for a Sanbox run.",
-    inputSchema: {
-        run_id: z.string(),
-        after_event_id: z.number().int().min(0).optional().default(0)
-    }
-}, async ({ run_id, after_event_id }) => {
-    const payload = await client().listEvents(run_id, after_event_id || 0);
-    return textAndJson(`Found ${payload.events.length} events.`, payload);
-});
-server.registerTool("cancel_sandbox_run", {
-    title: "Cancel Sanbox Run",
-    description: "Request cancellation for a queued or running Sanbox run.",
-    inputSchema: {
-        run_id: z.string()
-    }
-}, async ({ run_id }) => {
-    const payload = await client().cancelRun(run_id);
-    return textAndJson(`Cancel requested for ${payload.run.id}.`, payload);
-});
-server.registerTool("send_sandbox_message", {
-    title: "Send Sanbox Message",
-    description: "Ask a follow-up question against a retained Sanbox run workspace.",
-    inputSchema: {
-        run_id: z.string(),
-        message: z.string()
-    }
-}, async ({ run_id, message }) => {
-    const payload = await client().sendMessage(run_id, message);
-    return textAndJson(`Message sent to ${payload.run.id}.`, payload);
-});
-const main = async () => {
-    await server.connect(new StdioServerTransport());
-};
-main().catch((error) => {
-    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-    process.exit(1);
-});