fetchsandbox 0.1.0 → 0.3.0

package/dist/commands/check.d.ts

@@ -0,0 +1 @@
+export declare function check(sandboxId: string): Promise<void>;

package/dist/commands/check.js

@@ -0,0 +1,102 @@
+import pc from "picocolors";
+import ora from "ora";
+import { getSandbox, getSandboxLogs, getWorkflows, getWebhooks, validateSandbox, } from "../lib/api.js";
+import { fail, blank, heading, friendlyError } from "../lib/output.js";
+export async function check(sandboxId) {
+    blank();
+    const spinner = ora({ text: "Running integration readiness check...", indent: 2 }).start();
+    try {
+        const sb = await getSandbox(sandboxId);
+        // Fetch all data in parallel
+        const [validation, logs, workflowData, webhooks] = await Promise.all([
+            validateSandbox(sandboxId).catch(() => null),
+            getSandboxLogs(sandboxId, 200).catch(() => []),
+            getWorkflows(sb.spec_id).catch(() => ({ workflows: [] })),
+            getWebhooks(sandboxId).catch(() => []),
+        ]);
+        spinner.stop();
+        heading(`Integration Readiness: ${sb.spec_name || sb.name}`);
+        blank();
+        // ── 1. Endpoint Health (30%) ──────────────────────────────────
+        const healthScore = validation ? validation.pass_rate / 100 : 0;
+        const healthPct = Math.round(healthScore * 100);
+        const healthIcon = healthPct >= 90 ? pc.green("✓") : healthPct >= 60 ? pc.yellow("⚠") : pc.red("✗");
+        console.log(`  ${healthIcon} Endpoint health: ${healthPct >= 90 ? pc.green(healthPct + "%") : healthPct >= 60 ? pc.yellow(healthPct + "%") : pc.red(healthPct + "%")}${validation ? pc.dim(` (${validation.passed}/${validation.total} passed)`) : pc.dim(" (unable to validate)")}`);
+        // ── 2. Endpoint Coverage (30%) ────────────────────────────────
+        const uniqueEndpointsCalled = new Set(logs.map((l) => `${l.method} ${l.matched_path_template || l.path}`));
+        const totalEndpoints = sb.endpoints_count || 1;
+        const coverageRatio = Math.min(uniqueEndpointsCalled.size / totalEndpoints, 1);
+        const coveragePct = Math.round(coverageRatio * 100);
+        const coverageIcon = coveragePct >= 25 ? pc.green("✓") : coveragePct >= 10 ? pc.yellow("⚠") : pc.red("✗");
+        console.log(`  ${coverageIcon} Endpoints exercised: ${coveragePct >= 25 ? pc.green(coveragePct + "%") : coveragePct >= 10 ? pc.yellow(coveragePct + "%") : pc.red(coveragePct + "%")}${pc.dim(` (${uniqueEndpointsCalled.size}/${totalEndpoints} unique endpoints called)`)}`);
+        // ── 3. Workflow Completion (25%) ──────────────────────────────
+        const wfs = workflowData.workflows || [];
+        let workflowScore = 0;
+        let completedWorkflows = 0;
+        const incompleteWorkflows = [];
+        if (wfs.length > 0) {
+            for (const wf of wfs) {
+                let stepsMatched = 0;
+                for (const step of wf.steps) {
+                    const found = logs.some((l) => l.method === step.method && (l.matched_path_template === step.path || l.path.includes(step.path.replace(/\{[^}]+\}/g, ""))));
+                    if (found)
+                        stepsMatched++;
+                }
+                if (stepsMatched === wf.steps.length)
+                    completedWorkflows++;
+                else if (stepsMatched > 0)
+                    incompleteWorkflows.push({ name: wf.name, completed: stepsMatched, total: wf.steps.length });
+            }
+            workflowScore = completedWorkflows / wfs.length;
+        }
+        const wfPct = Math.round(workflowScore * 100);
+        const wfIcon = completedWorkflows > 0 ? pc.green("✓") : wfs.length > 0 ? pc.red("✗") : pc.dim("—");
+        console.log(`  ${wfIcon} Workflows completed: ${completedWorkflows > 0 ? pc.green(`${completedWorkflows}/${wfs.length}`) : wfs.length > 0 ? pc.red(`${completedWorkflows}/${wfs.length}`) : pc.dim("none discovered")}`);
+        for (const inc of incompleteWorkflows.slice(0, 3)) {
+            console.log(`    ${pc.dim("⤷")} ${inc.name}: ${pc.yellow(`${inc.completed}/${inc.total} steps`)}`);
+        }
+        // ── 4. Webhook Readiness (15%) ────────────────────────────────
+        const webhookScore = webhooks.length > 0 ? 1 : 0;
+        const whIcon = webhookScore > 0 ? pc.green("✓") : pc.yellow("⚠");
+        console.log(`  ${whIcon} Webhook handler: ${webhookScore > 0 ? pc.green(`${webhooks.length} registered`) : pc.yellow("not registered")}`);
+        // ── Overall Score ─────────────────────────────────────────────
+        const overall = Math.round(healthScore * 30 +
+            coverageRatio * 30 +
+            workflowScore * 25 +
+            webhookScore * 15);
+        blank();
+        const overallColor = overall >= 80 ? pc.green : overall >= 50 ? pc.yellow : pc.red;
+        console.log(`  ${pc.bold("Overall:")} ${overallColor(pc.bold(`${overall}%`))}`);
+        // ── Next Steps ────────────────────────────────────────────────
+        const nextSteps = [];
+        if (coveragePct < 10) {
+            nextSteps.push(`Try an API call: ${pc.cyan(`fetchsandbox request ${sandboxId} GET /v1`)}`);
+        }
+        if (wfs.length > 0 && completedWorkflows === 0) {
+            nextSteps.push(`Run a workflow: ${pc.cyan(`fetchsandbox workflows ${sandboxId}`)}`);
+        }
+        if (webhookScore === 0) {
+            nextSteps.push(`Register a webhook in the sandbox dashboard`);
+        }
+        if (healthPct < 90 && healthPct > 0) {
+            nextSteps.push(`Check failing endpoints: ${pc.cyan(`fetchsandbox endpoints ${sandboxId}`)}`);
+        }
+        if (sb.active_scenario === "default") {
+            nextSteps.push(`Test error scenarios: ${pc.cyan(`fetchsandbox scenario ${sandboxId} auth-failure`)}`);
+        }
+        if (nextSteps.length > 0) {
+            blank();
+            heading("Next steps:");
+            for (let i = 0; i < nextSteps.length; i++) {
+                console.log(`  ${pc.dim(`${i + 1}.`)} ${nextSteps[i]}`);
+            }
+        }
+        blank();
+    }
+    catch (error) {
+        spinner.stop();
+        fail(friendlyError(error));
+        blank();
+        process.exit(1);
+    }
+}

package/dist/commands/delete.d.ts

@@ -0,0 +1,3 @@
+export declare function deleteCmd(sandboxId: string, options: {
+    force?: boolean;
+}): Promise<void>;

package/dist/commands/delete.js

@@ -0,0 +1,30 @@
+import pc from "picocolors";
+import { getSandbox, deleteSandbox } from "../lib/api.js";
+import { ok, fail, blank, friendlyError } from "../lib/output.js";
+import { createInterface } from "node:readline";
+export async function deleteCmd(sandboxId, options) {
+    blank();
+    try {
+        const sb = await getSandbox(sandboxId);
+        if (!options.force) {
+            const rl = createInterface({ input: process.stdin, output: process.stdout });
+            const answer = await new Promise((resolve) => {
+                rl.question(`  ${pc.yellow("?")} Delete "${sb.spec_name || sb.name}" (${sb.id})? [y/N] `, resolve);
+            });
+            rl.close();
+            if (answer.toLowerCase() !== "y") {
+                console.log(`  ${pc.dim("Cancelled.")}`);
+                blank();
+                return;
+            }
+        }
+        await deleteSandbox(sandboxId);
+        ok(`Deleted sandbox "${sb.spec_name || sb.name}" (${sb.id})`);
+        blank();
+    }
+    catch (error) {
+        fail(friendlyError(error));
+        blank();
+        process.exit(1);
+    }
+}

package/dist/commands/docs.d.ts

@@ -0,0 +1 @@
+export declare function docs(sandboxId: string): Promise<void>;

package/dist/commands/docs.js

@@ -0,0 +1,22 @@
+import { getSandbox } from "../lib/api.js";
+import { ok, fail, blank, friendlyError } from "../lib/output.js";
+import { API_BASE } from "../constants.js";
+import { exec } from "node:child_process";
+export async function docs(sandboxId) {
+    blank();
+    try {
+        const sb = await getSandbox(sandboxId);
+        const slug = sb.slug || sb.spec_id;
+        const url = `${API_BASE}/docs/${slug}`;
+        // Open in default browser
+        const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        exec(`${cmd} ${url}`);
+        ok(`Opening ${url}`);
+        blank();
+    }
+    catch (error) {
+        fail(friendlyError(error));
+        blank();
+        process.exit(1);
+    }
+}

package/dist/commands/endpoints.d.ts

@@ -0,0 +1,3 @@
+export declare function endpoints(sandboxId: string, options: {
+    search?: string;
+}): Promise<void>;

package/dist/commands/endpoints.js

@@ -0,0 +1,38 @@
+import pc from "picocolors";
+import { getEndpoints } from "../lib/api.js";
+import { fail, blank, heading, method as methodColor, tableHeader, row, friendlyError } from "../lib/output.js";
+export async function endpoints(sandboxId, options) {
+    blank();
+    try {
+        let eps = await getEndpoints(sandboxId);
+        if (options.search) {
+            const term = options.search.toLowerCase();
+            eps = eps.filter((e) => e.path.toLowerCase().includes(term) ||
+                e.summary?.toLowerCase().includes(term) ||
+                e.operation_id?.toLowerCase().includes(term) ||
+                e.tags?.some((t) => t.toLowerCase().includes(term)));
+        }
+        if (eps.length === 0) {
+            console.log(`  ${pc.dim(options.search ? `No endpoints matching "${options.search}".` : "No endpoints found.")}`);
+            blank();
+            return;
+        }
+        heading(`${eps.length} endpoints${options.search ? ` matching "${options.search}"` : ""}:`);
+        blank();
+        const widths = [8, 42, 40];
+        tableHeader(["Method", "Path", "Summary"], widths);
+        for (const ep of eps) {
+            const m = methodColor(ep.method);
+            const summary = (ep.summary || "").slice(0, 38);
+            row([m, ep.path.slice(0, 40), pc.dim(summary)], widths);
+        }
+        blank();
+        console.log(`  ${pc.dim("Try one:")} ${pc.cyan(`fetchsandbox request ${sandboxId} GET ${eps[0]?.path || "/v1"}`)}`);
+        blank();
+    }
+    catch (error) {
+        fail(friendlyError(error));
+        blank();
+        process.exit(1);
+    }
+}

package/dist/commands/logs.d.ts

@@ -0,0 +1,5 @@
+export declare function logs(sandboxId: string, options: {
+    follow?: boolean;
+    status?: string;
+    limit?: string;
+}): Promise<void>;

package/dist/commands/logs.js

@@ -0,0 +1,66 @@
+import pc from "picocolors";
+import { getSandboxLogs } from "../lib/api.js";
+import { fail, blank, heading, method as methodColor, status as statusColor, timeAgo, friendlyError } from "../lib/output.js";
+export async function logs(sandboxId, options) {
+    blank();
+    try {
+        const limit = options.limit ? parseInt(options.limit, 10) : 30;
+        const statusFilter = options.status ? parseInt(options.status, 10) : 0;
+        const printLogs = (entries) => {
+            for (const log of entries) {
+                if (statusFilter) {
+                    // Support range filters: 4xx matches 400-499, 5xx matches 500-599
+                    if (String(statusFilter).includes("x")) {
+                        const base = parseInt(String(statusFilter).replace(/x/gi, "0"), 10);
+                        if (log.response_status < base || log.response_status >= base + 100)
+                            continue;
+                    }
+                    else if (log.response_status !== statusFilter) {
+                        continue;
+                    }
+                }
+                const time = timeAgo(log.timestamp).padEnd(8);
+                const m = methodColor(log.method);
+                const path = log.path.length > 40 ? log.path.slice(0, 37) + "..." : log.path;
+                console.log(`  ${pc.dim(time)}${m} ${path.padEnd(41)} ${statusColor(log.response_status)}  ${pc.dim(log.duration_ms + "ms")}`);
+            }
+        };
+        if (options.follow) {
+            heading("Tailing logs (Ctrl+C to stop):");
+            blank();
+            let lastSeen = "";
+            const poll = async () => {
+                const entries = await getSandboxLogs(sandboxId, 20);
+                const newEntries = lastSeen
+                    ? entries.filter((e) => e.timestamp > lastSeen)
+                    : entries;
+                if (newEntries.length > 0) {
+                    printLogs(newEntries);
+                    lastSeen = newEntries[0].timestamp; // logs are newest-first
+                }
+            };
+            await poll();
+            const interval = setInterval(poll, 2000);
+            process.on("SIGINT", () => { clearInterval(interval); blank(); process.exit(0); });
+            // Keep alive
+            await new Promise(() => { });
+        }
+        else {
+            const entries = await getSandboxLogs(sandboxId, limit);
+            if (entries.length === 0) {
+                console.log(`  ${pc.dim("No request logs yet. Make an API call to see logs.")}`);
+                blank();
+                return;
+            }
+            heading(`Last ${entries.length} requests:`);
+            blank();
+            printLogs(entries);
+            blank();
+        }
+    }
+    catch (error) {
+        fail(friendlyError(error));
+        blank();
+        process.exit(1);
+    }
+}

package/dist/commands/request.d.ts

@@ -0,0 +1,3 @@
+export declare function sendRequest(sandboxId: string, httpMethod: string, path: string, options: {
+    data?: string;
+}): Promise<void>;

package/dist/commands/request.js

@@ -0,0 +1,44 @@
+import pc from "picocolors";
+import { getSandbox, sandboxRequest } from "../lib/api.js";
+import { fail, blank, friendlyError, method as methodColor, status as statusColor } from "../lib/output.js";
+export async function sendRequest(sandboxId, httpMethod, path, options) {
+    blank();
+    try {
+        const sb = await getSandbox(sandboxId);
+        const apiKey = sb.credentials?.[0]?.api_key;
+        const m = httpMethod.toUpperCase();
+        console.log(`  ${methodColor(m)} ${pc.cyan(path)}`);
+        if (options.data) {
+            console.log(`  ${pc.dim("Body:")} ${options.data.length > 80 ? options.data.slice(0, 77) + "..." : options.data}`);
+        }
+        blank();
+        const res = await sandboxRequest(sandboxId, m, path, options.data, apiKey);
+        // Status line
+        const statusStr = statusColor(res.status);
+        const statusText = res.status < 300 ? "OK" : res.status < 500 ? "Client Error" : "Server Error";
+        console.log(`  ${pc.dim("←")} ${statusStr} ${statusText}`);
+        blank();
+        // Response body
+        if (res.body !== undefined && res.body !== null && res.body !== "") {
+            const formatted = typeof res.body === "string"
+                ? res.body
+                : JSON.stringify(res.body, null, 2);
+            // Truncate very large responses for terminal readability
+            const lines = formatted.split("\n");
+            const maxLines = 60;
+            for (const line of lines.slice(0, maxLines)) {
+                console.log(`  ${pc.dim(line)}`);
+            }
+            if (lines.length > maxLines) {
+                blank();
+                console.log(`  ${pc.dim(`... ${lines.length - maxLines} more lines (${formatted.length} bytes total)`)}`);
+            }
+        }
+        blank();
+    }
+    catch (error) {
+        fail(friendlyError(error));
+        blank();
+        process.exit(1);
+    }
+}

package/dist/commands/run.d.ts

@@ -0,0 +1,4 @@
+export declare function run(sandboxId: string, workflowName: string, options?: {
+    scenario?: string;
+    verbose?: boolean;
+}): Promise<void>;

package/dist/commands/run.js

@@ -0,0 +1,167 @@
+import pc from "picocolors";
+import ora from "ora";
+import { runWorkflow, getWorkflows, getSandbox, setScenario } from "../lib/api.js";
+import { fail, blank, heading, info, method as methodColor, friendlyError } from "../lib/output.js";
+export async function run(sandboxId, workflowName, options = {}) {
+    blank();
+    try {
+        // If a scenario was requested, switch to it first
+        if (options.scenario) {
+            const spinner = ora({ text: `  Switching to scenario: ${options.scenario}`, indent: 0 }).start();
+            try {
+                await setScenario(sandboxId, options.scenario);
+                spinner.succeed(`  Scenario: ${options.scenario}`);
+            }
+            catch (err) {
+                spinner.fail(`  Failed to set scenario: ${friendlyError(err)}`);
+                blank();
+                process.exit(1);
+            }
+        }
+        // Run the workflow
+        const spinner = ora({ text: `  Running workflow...`, indent: 0 }).start();
+        let result;
+        try {
+            result = await runWorkflow(sandboxId, workflowName);
+            spinner.stop();
+        }
+        catch (err) {
+            spinner.fail(`  Failed to run workflow`);
+            blank();
+            // If 404, try to list available workflows and show helpful error
+            const errMsg = friendlyError(err);
+            if (errMsg.includes("404") || errMsg.includes("not found") || errMsg.includes("Not found")) {
+                await showAvailableWorkflows(sandboxId, workflowName);
+            }
+            else {
+                fail(errMsg);
+            }
+            blank();
+            process.exit(1);
+        }
+        // Display results
+        const totalSteps = result.steps.length;
+        const passedSteps = result.steps.filter((s) => s.status === "passed").length;
+        const workflowLabel = result.flow_description || result.flow_name;
+        heading(`${workflowLabel} (${totalSteps} step${totalSteps === 1 ? "" : "s"})`);
+        blank();
+        for (let i = 0; i < result.steps.length; i++) {
+            const step = result.steps[i];
+            const stepNum = `Step ${i + 1}/${totalSteps}`;
+            const icon = step.status === "passed" ? pc.green("✓") : pc.red("✗");
+            const duration = pc.dim(`${step.duration_ms}ms`);
+            // Parse method and path from detail or step name
+            const { method: httpMethod, path } = parseMethodPath(step.detail);
+            // Step header
+            if (httpMethod && path) {
+                console.log(`  ${icon} ${pc.dim(stepNum)}  ${methodColor(httpMethod)} ${path}  ${duration}`);
+            }
+            else {
+                console.log(`  ${icon} ${pc.dim(stepNum)}  ${step.name}  ${duration}`);
+            }
+            // Step detail
+            const detail = formatDetail(step);
+            if (detail) {
+                console.log(`    ${detail}`);
+            }
+            // Verbose: show full data
+            if (options.verbose && Object.keys(step.data).length > 0) {
+                const json = JSON.stringify(step.data, null, 2);
+                for (const line of json.split("\n")) {
+                    console.log(`    ${pc.dim(line)}`);
+                }
+            }
+            // Show webhook events in step
+            if (step.name === "webhook_verification") {
+                const matched = (step.data.matched || []);
+                for (const evt of matched) {
+                    console.log(`    ${pc.yellow("⚡")} ${evt}`);
+                }
+            }
+        }
+        blank();
+        // Summary
+        const totalTime = `${result.total_duration_ms}ms`;
+        if (result.passed) {
+            console.log(`  ${pc.green("✓")} Workflow complete — ${passedSteps}/${totalSteps} steps passed ${pc.dim(`(${totalTime})`)}`);
+        }
+        else {
+            console.log(`  ${pc.red("✗")} Workflow failed at step ${passedSteps + 1}/${totalSteps} ${pc.dim(`(${totalTime})`)}`);
+        }
+        // If using a scenario and it failed as expected, that's actually a good thing
+        if (options.scenario && !result.passed) {
+            blank();
+            info(`Scenario "${options.scenario}" correctly caused failure at step ${passedSteps + 1}.`);
+            info("This confirms your error handling works.");
+        }
+        blank();
+        // Reset scenario back to default if we changed it
+        if (options.scenario) {
+            try {
+                await setScenario(sandboxId, "default");
+                info("Scenario reset to default.");
+                blank();
+            }
+            catch {
+                // Silent — best effort reset
+            }
+        }
+        // Exit with appropriate code
+        if (!result.passed && !options.scenario) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        fail(friendlyError(error));
+        blank();
+        process.exit(1);
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────────────
+/** Parse HTTP method and path from step detail string. */
+function parseMethodPath(detail) {
+    const match = detail.match(/^(GET|POST|PUT|PATCH|DELETE|HEAD)\s+(\S+)/);
+    if (match) {
+        return { method: match[1], path: match[2] };
+    }
+    return { method: "", path: "" };
+}
+/** Format a human-readable detail line from step data. */
+function formatDetail(step) {
+    if (step.status === "failed") {
+        return pc.red(step.detail);
+    }
+    // Extract meaningful info from data
+    const id = step.data.id || step.data.resource_id || "";
+    const status = step.data.status || "";
+    const responseStatus = step.data.response_status;
+    const parts = [];
+    if (responseStatus)
+        parts.push(`→ ${pc.green(String(responseStatus))}`);
+    if (id)
+        parts.push(pc.white(String(id)));
+    if (status)
+        parts.push(pc.dim(`status: ${status}`));
+    return parts.length > 0 ? parts.join("  ") : "";
+}
+/** Show available workflows when one isn't found. */
+async function showAvailableWorkflows(sandboxId, attempted) {
+    fail(`Workflow "${attempted}" not found.`);
+    try {
+        const sb = await getSandbox(sandboxId);
+        const { workflows } = await getWorkflows(sb.spec_id);
+        if (workflows.length > 0) {
+            blank();
+            info("Available workflows:");
+            for (const wf of workflows) {
+                const id = wf.id || wf.name;
+                console.log(`  ${pc.dim("•")} ${id}`);
+            }
+            blank();
+            info(`Try: fetchsandbox run ${sandboxId} "${workflows[0].id || workflows[0].name}"`);
+        }
+    }
+    catch {
+        // Silent — best effort
+    }
+}

package/dist/commands/scenario.d.ts

@@ -0,0 +1,3 @@
+export declare function scenario(sandboxId: string, options: {
+    name?: string;
+}): Promise<void>;

package/dist/commands/scenario.js

@@ -0,0 +1,40 @@
+import pc from "picocolors";
+import { getSandbox, getScenarios, setScenario } from "../lib/api.js";
+import { ok, fail, blank, heading, friendlyError } from "../lib/output.js";
+export async function scenario(sandboxId, options) {
+    blank();
+    try {
+        const sb = await getSandbox(sandboxId);
+        if (options.name) {
+            // Set scenario
+            const result = await setScenario(sandboxId, options.name);
+            ok(`Scenario set to "${result.active_scenario}"`);
+            blank();
+            return;
+        }
+        // List scenarios
+        const scenarios = await getScenarios();
+        heading(`Scenarios for ${sb.spec_name || sb.name}:`);
+        console.log(`  ${pc.dim("Active:")} ${pc.bold(sb.active_scenario)}`);
+        blank();
+        if (scenarios.length === 0) {
+            console.log(`  ${pc.dim("No custom scenarios available.")}`);
+            blank();
+            return;
+        }
+        for (const s of scenarios) {
+            const active = s.name === sb.active_scenario ? pc.green(" ● active") : "";
+            console.log(`  ${pc.bold(s.name)}${active}`);
+            console.log(`  ${pc.dim(s.description)}`);
+            console.log(`  ${pc.dim(`${s.overrides_count} overrides, auth ${s.auth_enabled ? "enabled" : "disabled"}`)}`);
+            blank();
+        }
+        console.log(`  ${pc.dim("Switch:")} ${pc.cyan(`fetchsandbox scenario ${sandboxId} --name <scenario>`)}`);
+        blank();
+    }
+    catch (error) {
+        fail(friendlyError(error));
+        blank();
+        process.exit(1);
+    }
+}

package/dist/commands/state.d.ts

@@ -0,0 +1,3 @@
+export declare function state(sandboxId: string, resource?: string, options?: {
+    id?: string;
+}): Promise<void>;

package/dist/commands/state.js

@@ -0,0 +1,135 @@
+import pc from "picocolors";
+import { getSandboxState } from "../lib/api.js";
+import { fail, blank, heading, info, row, tableHeader, friendlyError } from "../lib/output.js";
+export async function state(sandboxId, resource, options = {}) {
+    blank();
+    try {
+        const snapshot = await getSandboxState(sandboxId);
+        const types = Object.entries(snapshot).filter(([, records]) => Array.isArray(records) && records.length > 0);
+        if (types.length === 0) {
+            info("No resources in this sandbox. Run some requests first.");
+            blank();
+            return;
+        }
+        // ── Single resource type ──────────────────────────────────────────
+        if (resource) {
+            const records = snapshot[resource];
+            if (!records || !Array.isArray(records) || records.length === 0) {
+                const available = types.map(([t]) => t).join(", ");
+                fail(`No resource type "${resource}" found.`);
+                info(`Available: ${available}`);
+                blank();
+                return;
+            }
+            // Single record by --id
+            if (options.id) {
+                const typedRecords = records;
+                const record = typedRecords.find((r) => r.id === options.id || r.ID === options.id);
+                if (!record) {
+                    fail(`No record with id "${options.id}" in ${resource}.`);
+                    info(`${records.length} records available. Try without --id to list all.`);
+                    blank();
+                    return;
+                }
+                heading(`${resource} / ${options.id}`);
+                blank();
+                console.log(formatJson(record));
+                blank();
+                return;
+            }
+            // Table view for all records of this type
+            heading(`${resource} — ${records.length} record${records.length === 1 ? "" : "s"}`);
+            blank();
+            const cols = pickColumns(records);
+            const widths = cols.map((c) => Math.max(c.length + 2, Math.min(30, maxWidth(records, c) + 2)));
+            tableHeader(cols, widths);
+            for (const record of records) {
+                const values = cols.map((c) => truncate(String(record[c] ?? ""), widths[cols.indexOf(c)] - 2));
+                row(values, widths);
+            }
+            blank();
+            return;
+        }
+        // ── Summary of all resource types ─────────────────────────────────
+        heading(`State snapshot — ${types.length} resource type${types.length === 1 ? "" : "s"}, ${types.reduce((sum, [, r]) => sum + r.length, 0)} records`);
+        blank();
+        for (const [type, records] of types) {
+            const items = records;
+            const dist = stateDistribution(items);
+            const countStr = pc.bold(String(items.length));
+            const distStr = dist ? pc.dim(`  (${dist})`) : "";
+            console.log(`  ${type.padEnd(25)} ${countStr}${distStr}`);
+        }
+        blank();
+        info("Tip: fetchsandbox state <sandbox> <resource> to see records");
+        blank();
+    }
+    catch (error) {
+        fail(friendlyError(error));
+        blank();
+        process.exit(1);
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────────────
+/** Pick the most useful columns to display in a table. */
+function pickColumns(records) {
+    if (records.length === 0)
+        return [];
+    const allKeys = Object.keys(records[0]);
+    // Priority: id first, then status, then name/email/type, then rest
+    const priority = ["id", "ID", "status", "state", "name", "email", "type", "amount", "currency", "description"];
+    const picked = [];
+    for (const key of priority) {
+        if (allKeys.includes(key) && !picked.includes(key)) {
+            picked.push(key);
+        }
+    }
+    // Fill up to 5 columns with remaining keys (skip large objects/arrays)
+    for (const key of allKeys) {
+        if (picked.length >= 5)
+            break;
+        if (picked.includes(key))
+            continue;
+        const sample = records[0][key];
+        if (typeof sample === "object" && sample !== null)
+            continue; // skip nested
+        picked.push(key);
+    }
+    return picked;
+}
+/** Get the max display width of a column across all records. */
+function maxWidth(records, key) {
+    let max = key.length;
+    for (const r of records) {
+        const len = String(r[key] ?? "").length;
+        if (len > max)
+            max = len;
+    }
+    return Math.min(max, 28);
+}
+/** Truncate a string to fit a column width. */
+function truncate(s, max) {
+    return s.length > max ? s.slice(0, max - 1) + "…" : s;
+}
+/** Compute state/status distribution string, e.g. "2 active, 1 suspended". */
+function stateDistribution(records) {
+    const field = records[0]?.status !== undefined ? "status" : records[0]?.state !== undefined ? "state" : null;
+    if (!field)
+        return "";
+    const counts = {};
+    for (const r of records) {
+        const val = String(r[field] ?? "unknown");
+        counts[val] = (counts[val] || 0) + 1;
+    }
+    return Object.entries(counts)
+        .sort(([, a], [, b]) => b - a)
+        .map(([val, count]) => `${count} ${val}`)
+        .join(", ");
+}
+/** Pretty-print a JSON object with 2-space indent, indented for CLI output. */
+function formatJson(obj) {
+    return JSON.stringify(obj, null, 2)
+        .split("\n")
+        .map((line) => `  ${pc.white(line)}`)
+        .join("\n");
+}

package/dist/commands/webhook.d.ts

@@ -0,0 +1,4 @@
+export declare function webhookListen(sandboxId: string, options?: {
+    verbose?: boolean;
+    eventType?: string;
+}): Promise<void>;

package/dist/commands/webhook.js

@@ -0,0 +1,111 @@
+import pc from "picocolors";
+import { getWebhookEvents } from "../lib/api.js";
+import { fail, blank, heading, info, friendlyError } from "../lib/output.js";
+export async function webhookListen(sandboxId, options = {}) {
+    blank();
+    try {
+        heading("Listening for webhook events... (Ctrl+C to stop)");
+        blank();
+        let lastSeen = "";
+        let totalShown = 0;
+        const poll = async () => {
+            const events = await getWebhookEvents(sandboxId, 30);
+            // Filter to only new events (same dedup pattern as logs --follow)
+            const newEvents = lastSeen
+                ? events.filter((e) => e.timestamp > lastSeen)
+                : events;
+            if (newEvents.length === 0)
+                return;
+            // Update watermark — events are newest-first from API
+            lastSeen = newEvents[0].timestamp;
+            // Display oldest-first for natural reading order
+            const ordered = [...newEvents].reverse();
+            for (const event of ordered) {
+                // Optional event type filter
+                if (options.eventType && !event.event_type.includes(options.eventType)) {
+                    continue;
+                }
+                const time = formatTime(event.timestamp);
+                const type = colorEventType(event.event_type);
+                const resourceId = extractResourceId(event.payload);
+                const statusField = extractStatus(event.payload);
+                console.log(`  ${pc.dim(time)}  ${type}  ${pc.white(resourceId)}${statusField}`);
+                if (options.verbose && event.payload) {
+                    const json = JSON.stringify(event.payload, null, 2);
+                    for (const line of json.split("\n")) {
+                        console.log(`  ${pc.dim("          ")}${pc.dim(line)}`);
+                    }
+                }
+                totalShown++;
+            }
+        };
+        // Initial poll
+        await poll();
+        if (totalShown === 0) {
+            info("No events yet. Make API calls in another terminal to see webhooks fire.");
+        }
+        // Poll every 2 seconds
+        const interval = setInterval(async () => {
+            try {
+                await poll();
+            }
+            catch {
+                // Silently retry on transient errors during polling
+            }
+        }, 2000);
+        process.on("SIGINT", () => {
+            clearInterval(interval);
+            blank();
+            if (totalShown > 0) {
+                console.log(`  ${pc.dim(`${totalShown} event${totalShown === 1 ? "" : "s"} received.`)}`);
+            }
+            blank();
+            process.exit(0);
+        });
+        // Keep alive
+        await new Promise(() => { });
+    }
+    catch (error) {
+        fail(friendlyError(error));
+        blank();
+        process.exit(1);
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────────────
+/** Format ISO timestamp to HH:MM:SS. */
+function formatTime(ts) {
+    try {
+        const d = new Date(ts);
+        return d.toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+    }
+    catch {
+        return ts.slice(11, 19);
+    }
+}
+/** Color event type based on action. */
+function colorEventType(eventType) {
+    const padded = eventType.padEnd(30);
+    if (eventType.includes("created"))
+        return pc.green(padded);
+    if (eventType.includes("succeeded") || eventType.includes("completed"))
+        return pc.green(padded);
+    if (eventType.includes("failed") || eventType.includes("declined"))
+        return pc.red(padded);
+    if (eventType.includes("deleted") || eventType.includes("canceled"))
+        return pc.red(padded);
+    if (eventType.includes("updated") || eventType.includes("captured"))
+        return pc.yellow(padded);
+    return pc.white(padded);
+}
+/** Extract the resource ID from a webhook payload. */
+function extractResourceId(payload) {
+    const id = payload?.id ?? payload?.ID ?? "";
+    return id ? String(id) : "";
+}
+/** Extract a status-like field from payload for compact display. */
+function extractStatus(payload) {
+    const status = payload?.status ?? payload?.state ?? null;
+    if (!status)
+        return "";
+    return pc.dim(` → ${status}`);
+}

package/dist/commands/workflows.d.ts

@@ -0,0 +1,3 @@
+export declare function workflows(sandboxId: string, options: {
+    name?: string;
+}): Promise<void>;

package/dist/commands/workflows.js

@@ -0,0 +1,68 @@
+import pc from "picocolors";
+import { getSandbox, getWorkflows } from "../lib/api.js";
+import { fail, blank, heading, method as methodColor, friendlyError } from "../lib/output.js";
+export async function workflows(sandboxId, options) {
+    blank();
+    try {
+        const sb = await getSandbox(sandboxId);
+        const data = await getWorkflows(sb.spec_id);
+        const wfs = data.workflows || [];
+        if (wfs.length === 0) {
+            console.log(`  ${pc.dim("No workflows discovered for this sandbox.")}`);
+            blank();
+            return;
+        }
+        // If a specific workflow name is given, show detail view
+        if (options.name) {
+            const match = wfs.find((w) => w.id === options.name ||
+                w.name.toLowerCase().includes(options.name.toLowerCase()));
+            if (!match) {
+                fail(`No workflow matching "${options.name}". Run ${pc.cyan("fetchsandbox workflows " + sandboxId)} to see all.`);
+                blank();
+                return;
+            }
+            heading(`${match.name}`);
+            console.log(`  ${pc.dim(match.description)}`);
+            if (match.category)
+                console.log(`  ${pc.dim("Category:")} ${match.category}`);
+            blank();
+            for (const step of match.steps) {
+                const m = methodColor(step.method);
+                console.log(`  ${pc.bold(String(step.step) + ".")} ${step.name}`);
+                console.log(`     ${m} ${pc.cyan(step.path)}`);
+                if (step.description)
+                    console.log(`     ${pc.dim(step.description)}`);
+                blank();
+            }
+            if (match.webhook_events && match.webhook_events.length > 0) {
+                heading("Webhook events:");
+                for (const evt of match.webhook_events) {
+                    console.log(`  ${pc.dim("→")} ${evt}`);
+                }
+                blank();
+            }
+            // Show helpful next step
+            console.log(`  ${pc.dim("Try it:")} ${pc.cyan(`fetchsandbox request ${sandboxId} ${match.steps[0].method} ${match.steps[0].path}`)}`);
+            blank();
+            return;
+        }
+        // List all workflows
+        heading(`${wfs.length} workflows for ${sb.spec_name || sb.name}:`);
+        blank();
+        for (const wf of wfs) {
+            const stepCount = `${wf.steps.length} steps`;
+            console.log(`  ${pc.bold(wf.name)}  ${pc.dim(stepCount)}`);
+            console.log(`  ${pc.dim(wf.description)}`);
+            const methods = wf.steps.map((s) => `${s.method} ${s.path}`).join(" → ");
+            console.log(`  ${pc.dim(methods.length > 80 ? methods.slice(0, 77) + "..." : methods)}`);
+            blank();
+        }
+        console.log(`  ${pc.dim("Show detail:")} ${pc.cyan(`fetchsandbox workflows ${sandboxId} --name "<workflow name>"`)}`);
+        blank();
+    }
+    catch (error) {
+        fail(friendlyError(error));
+        blank();
+        process.exit(1);
+    }
+}

package/dist/constants.d.ts

@@ -1,2 +1,2 @@
 export declare const API_BASE: string;
-export declare const VERSION = "0.1.0";
+export declare const VERSION = "0.3.0";

package/dist/constants.js

@@ -1,2 +1,2 @@
 export const API_BASE = process.env.FETCHSANDBOX_API_URL ?? "https://fetchsandbox.com";
-export const VERSION = "0.1.0";
+export const VERSION = "0.3.0";

package/dist/index.js

@@ -6,42 +6,142 @@ import { generate } from "./commands/generate.js";
 import { showStatus } from "./commands/status.js";
 import { reset } from "./commands/reset.js";
 import { list } from "./commands/list.js";
+import { workflows } from "./commands/workflows.js";
+import { sendRequest } from "./commands/request.js";
+import { check } from "./commands/check.js";
+import { endpoints } from "./commands/endpoints.js";
+import { logs } from "./commands/logs.js";
+import { scenario } from "./commands/scenario.js";
+import { deleteCmd } from "./commands/delete.js";
+import { docs } from "./commands/docs.js";
+import { state } from "./commands/state.js";
+import { webhookListen } from "./commands/webhook.js";
+import { run } from "./commands/run.js";
 const program = new Command();
 program
     .name("fetchsandbox")
-    .description(pc.dim("Turn any OpenAPI spec into a live developer portal"))
+    .description(pc.dim("Ship your API integration in minutes, not months"))
     .version(VERSION, "-v, --version");
+// ── Setup ─────────────────────────────────────────────────────────────
 program
     .command("generate <spec>")
-    .description("Create a portal from an OpenAPI spec file or URL")
+    .description("Create a sandbox from an OpenAPI spec file or URL")
     .action(generate);
+program
+    .command("list")
+    .description("List all sandboxes")
+    .action(list);
+program
+    .command("delete <sandbox-id>")
+    .description("Delete a sandbox")
+    .option("-f, --force", "Skip confirmation prompt")
+    .action((id, opts) => deleteCmd(id, opts));
+// ── Understand ────────────────────────────────────────────────────────
+program
+    .command("endpoints <sandbox-id>")
+    .description("List all endpoints (use --search to filter)")
+    .option("-s, --search <term>", "Filter by path, summary, or tag")
+    .action((id, opts) => endpoints(id, opts));
+program
+    .command("docs <sandbox-id>")
+    .description("Open the docs portal in your browser")
+    .action(docs);
+// ── Plan ──────────────────────────────────────────────────────────────
+program
+    .command("workflows <sandbox-id>")
+    .description("List integration workflows (use --name for detail)")
+    .option("-n, --name <name>", "Show detail for a specific workflow")
+    .action((id, opts) => workflows(id, opts));
+// ── Implement ─────────────────────────────────────────────────────────
+program
+    .command("request <sandbox-id> <method> <path>")
+    .description("Make an API call to the sandbox")
+    .option("-d, --data <json>", "Request body (JSON string)")
+    .action((id, method, path, opts) => sendRequest(id, method, path, opts));
+// ── Prove ─────────────────────────────────────────────────────────────
+program
+    .command("run <sandbox-id> <workflow>")
+    .description("Execute a workflow end-to-end and verify each step")
+    .option("--scenario <name>", "Run under an error scenario (resets after)")
+    .option("--verbose", "Show full response data for each step")
+    .action((id, workflow, opts) => run(id, workflow, opts));
+// ── Test ──────────────────────────────────────────────────────────────
 program
     .command("status <sandbox-id>")
     .description("Show sandbox state, resources, and recent activity")
     .action(showStatus);
+program
+    .command("logs <sandbox-id>")
+    .description("Show request logs (use --follow for live tail)")
+    .option("-f, --follow", "Tail logs in real-time")
+    .option("--status <code>", "Filter by status code (e.g. 200, 4xx, 5xx)")
+    .option("-l, --limit <n>", "Number of log entries (default: 30)")
+    .action((id, opts) => logs(id, opts));
+program
+    .command("scenario <sandbox-id>")
+    .description("List or switch test scenarios")
+    .option("-n, --name <name>", "Set active scenario")
+    .action((id, opts) => scenario(id, opts));
+program
+    .command("state <sandbox-id> [resource]")
+    .description("Inspect resource state (use --id for single record)")
+    .option("--id <resource-id>", "Show a single record by ID")
+    .action((id, resource, opts) => state(id, resource, opts));
 program
     .command("reset <sandbox-id>")
     .description("Reset sandbox to its original seed data")
     .action(reset);
+// ── Observe ──────────────────────────────────────────────────────────
 program
-    .command("list")
-    .description("List all sandboxes")
-    .action(list);
+    .command("webhook-listen <sandbox-id>")
+    .description("Live-tail webhook events (Ctrl+C to stop)")
+    .option("--verbose", "Show full event payload")
+    .option("--event-type <type>", "Filter by event type (e.g. charge.created)")
+    .action((id, opts) => webhookListen(id, opts));
+// ── Go Live ───────────────────────────────────────────────────────────
+program
+    .command("check <sandbox-id>")
+    .description("Run integration readiness check")
+    .action(check);
 // If no command given, show help with a friendly message
 if (process.argv.length <= 2) {
     console.log();
     console.log(`  ${pc.bold("fetchsandbox")} ${pc.dim(`v${VERSION}`)}`);
-    console.log(`  ${pc.dim("Turn any OpenAPI spec into a live developer portal")}`);
+    console.log(`  ${pc.dim("Ship your API integration in minutes, not months")}`);
     console.log();
     console.log(`  ${pc.dim("Quick start:")}`);
     console.log(`  ${pc.cyan("fetchsandbox generate ./openapi.yaml")}`);
-    console.log(`  ${pc.cyan("fetchsandbox generate https://api.example.com/openapi.yaml")}`);
     console.log();
-    console.log(`  ${pc.dim("Commands:")}`);
-    console.log(`  ${pc.white("generate <spec>")}    Create a portal from a spec file or URL`);
-    console.log(`  ${pc.white("status <id>")}        Show sandbox state and recent activity`);
+    console.log(`  ${pc.dim("Understand:")}`);
+    console.log(`  ${pc.white("endpoints <id>")}     List all endpoints (--search to filter)`);
+    console.log(`  ${pc.white("docs <id>")}          Open docs portal in browser`);
+    console.log();
+    console.log(`  ${pc.dim("Plan:")}`);
+    console.log(`  ${pc.white("workflows <id>")}     List integration workflows`);
+    console.log();
+    console.log(`  ${pc.dim("Implement:")}`);
+    console.log(`  ${pc.white("request <id> <method> <path>")}  Make an API call`);
+    console.log();
+    console.log(`  ${pc.dim("Prove:")}`);
+    console.log(`  ${pc.white("run <id> <workflow>")}  Run a workflow end-to-end`);
+    console.log();
+    console.log(`  ${pc.dim("Test:")}`);
+    console.log(`  ${pc.white("status <id>")}        Show sandbox state and activity`);
+    console.log(`  ${pc.white("state <id> [type]")}   Inspect resource data (--id for single)`);
+    console.log(`  ${pc.white("logs <id>")}          Show request logs (--follow for live)`);
+    console.log(`  ${pc.white("scenario <id>")}      List or switch test scenarios`);
     console.log(`  ${pc.white("reset <id>")}         Reset sandbox to seed data`);
+    console.log();
+    console.log(`  ${pc.dim("Observe:")}`);
+    console.log(`  ${pc.white("webhook-listen <id>")} Live-tail webhook events`);
+    console.log();
+    console.log(`  ${pc.dim("Go Live:")}`);
+    console.log(`  ${pc.white("check <id>")}         Integration readiness score`);
+    console.log();
+    console.log(`  ${pc.dim("Manage:")}`);
+    console.log(`  ${pc.white("generate <spec>")}    Create sandbox from spec file or URL`);
     console.log(`  ${pc.white("list")}               List all sandboxes`);
+    console.log(`  ${pc.white("delete <id>")}        Delete a sandbox`);
     console.log();
     console.log(`  ${pc.dim("Learn more:")} ${pc.cyan("https://fetchsandbox.com")}`);
     console.log();

package/dist/lib/api.d.ts

@@ -28,6 +28,87 @@ export interface LogEntry {
     response_status: number;
     duration_ms: number;
     timestamp: string;
+    matched_operation?: string;
+    matched_path_template?: string;
+    request_body?: unknown;
+    response_body?: unknown;
+}
+export interface EndpointInfo {
+    method: string;
+    path: string;
+    operation_id: string;
+    summary: string;
+    tags: string[];
+    sandbox_url: string;
+    parameters: Array<{
+        name: string;
+        in: string;
+        required: boolean;
+        schema?: unknown;
+    }>;
+    has_request_body: boolean;
+    request_body_schema?: unknown;
+    sample_values?: Record<string, string>;
+    sample_body?: unknown;
+}
+export interface Workflow {
+    id: string;
+    name: string;
+    description: string;
+    category: string;
+    steps: Array<{
+        step: number;
+        name: string;
+        method: string;
+        path: string;
+        operation_id: string;
+        description: string;
+        request_body?: Record<string, unknown>;
+        expected_status?: number;
+    }>;
+    webhook_events?: string[];
+}
+export interface ScenarioInfo {
+    name: string;
+    description: string;
+    overrides_count: number;
+    auth_enabled: boolean;
+}
+export interface WebhookRegistration {
+    id: string;
+    sandbox_id: string;
+    url: string;
+    events: string[];
+    enabled: boolean;
+    created_at: string;
+}
+export interface WebhookEvent {
+    id: string;
+    event_type: string;
+    timestamp: string;
+    payload: Record<string, unknown>;
+    delivered: boolean;
+    delivery_status: number;
+}
+export interface WorkflowRunStep {
+    name: string;
+    description: string;
+    status: "pending" | "passed" | "failed";
+    detail: string;
+    duration_ms: number;
+    data: Record<string, unknown>;
+}
+export interface WorkflowRunResult {
+    flow_name: string;
+    flow_description: string;
+    passed: boolean;
+    total_duration_ms: number;
+    steps: WorkflowRunStep[];
+}
+export interface SandboxProxyResponse {
+    status: number;
+    headers: Record<string, string>;
+    body: unknown;
 }
 export declare function uploadSpec(input: string): Promise<SpecResult>;
 export declare function createSandbox(specId: string, name?: string): Promise<SandboxResult>;
@@ -44,4 +125,24 @@ export declare function validateSandbox(id: string): Promise<{
     passed: number;
     failed: number;
     pass_rate: number;
+    results?: Array<{
+        method: string;
+        path: string;
+        status: number;
+        ok: boolean;
+    }>;
+}>;
+export declare function getEndpoints(id: string): Promise<EndpointInfo[]>;
+export declare function getWorkflows(specId: string): Promise<{
+    workflows: Workflow[];
+}>;
+export declare function getScenarios(): Promise<ScenarioInfo[]>;
+export declare function setScenario(sandboxId: string, scenario: string): Promise<{
+    status: string;
+    active_scenario: string;
 }>;
+export declare function deleteSandbox(id: string): Promise<void>;
+export declare function getWebhooks(sandboxId: string): Promise<WebhookRegistration[]>;
+export declare function getWebhookEvents(sandboxId: string, limit?: number): Promise<WebhookEvent[]>;
+export declare function runWorkflow(sandboxId: string, workflowName: string): Promise<WorkflowRunResult>;
+export declare function sandboxRequest(sandboxId: string, method: string, path: string, body?: string, apiKey?: string): Promise<SandboxProxyResponse>;

package/dist/lib/api.js

@@ -71,3 +71,59 @@ export async function resetSandbox(id) {
 export async function validateSandbox(id) {
     return request(`/api/sandboxes/${id}/validate`);
 }
+export async function getEndpoints(id) {
+    return request(`/api/sandboxes/${id}/endpoints`);
+}
+export async function getWorkflows(specId) {
+    return request(`/api/specs/${specId}/workflows`);
+}
+export async function getScenarios() {
+    return request("/api/scenarios");
+}
+export async function setScenario(sandboxId, scenario) {
+    return request(`/api/sandboxes/${sandboxId}/scenario`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ scenario }),
+    });
+}
+export async function deleteSandbox(id) {
+    return request(`/api/sandboxes/${id}`, { method: "DELETE" });
+}
+export async function getWebhooks(sandboxId) {
+    return request(`/api/sandboxes/${sandboxId}/webhooks`);
+}
+export async function getWebhookEvents(sandboxId, limit = 50) {
+    return request(`/api/sandboxes/${sandboxId}/webhooks/events?limit=${limit}`);
+}
+export async function runWorkflow(sandboxId, workflowName) {
+    return request(`/api/sandboxes/${sandboxId}/workflows/${encodeURIComponent(workflowName)}/run`, {
+        method: "POST",
+    });
+}
+export async function sandboxRequest(sandboxId, method, path, body, apiKey) {
+    // Use the path-based proxy: /sandbox/{id}/{path}
+    const sandboxPath = path.startsWith("/") ? path : `/${path}`;
+    const url = `${API_BASE}/sandbox/${sandboxId}${sandboxPath}`;
+    const headers = {};
+    if (apiKey)
+        headers["api-key"] = apiKey;
+    if (body)
+        headers["Content-Type"] = "application/json";
+    const res = await fetch(url, {
+        method: method.toUpperCase(),
+        headers,
+        body: body || undefined,
+    });
+    const resBody = await res.text();
+    let parsed;
+    try {
+        parsed = JSON.parse(resBody);
+    }
+    catch {
+        parsed = resBody;
+    }
+    const resHeaders = {};
+    res.headers.forEach((v, k) => { resHeaders[k] = v; });
+    return { status: res.status, headers: resHeaders, body: parsed };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fetchsandbox",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Turn any OpenAPI spec into a live developer portal with a stateful sandbox",
   "type": "module",
   "bin": {