fetchsandbox 0.1.0 → 0.2.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/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/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.2.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.2.0";

package/dist/index.js

@@ -6,42 +6,113 @@ 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";
 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));
+// ── 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("reset <sandbox-id>")
     .description("Reset sandbox to its original seed data")
     .action(reset);
+// ── Go Live ───────────────────────────────────────────────────────────
 program
-    .command("list")
-    .description("List all sandboxes")
-    .action(list);
+    .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("Test:")}`);
+    console.log(`  ${pc.white("status <id>")}        Show sandbox state and activity`);
+    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("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,64 @@ 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 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 +102,22 @@ 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 sandboxRequest(sandboxId: string, method: string, path: string, body?: string, apiKey?: string): Promise<SandboxProxyResponse>;

package/dist/lib/api.js

@@ -71,3 +71,51 @@ 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 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.2.0",
   "description": "Turn any OpenAPI spec into a live developer portal with a stateful sandbox",
   "type": "module",
   "bin": {