@useswarm/cli 0.1.0

package/dist/commands/list-swarms.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const listSwarmsCommand: Command;

package/dist/commands/list-swarms.js

@@ -0,0 +1,37 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { ApiClient } from "../lib/api-client.js";
+import { requireAuth } from "../lib/config.js";
+export const listSwarmsCommand = new Command("list-swarms")
+    .description("List your saved persona swarms")
+    .action(async () => {
+    const config = requireAuth();
+    const client = new ApiClient(config.apiUrl, config.apiKey);
+    const spinner = ora("Fetching swarms...").start();
+    let res;
+    try {
+        res = await client.listSwarms();
+    }
+    catch (err) {
+        spinner.fail("Failed to fetch swarms");
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+    spinner.stop();
+    if (res.swarms.length === 0) {
+        console.log(chalk.yellow("No swarms found. Create one on the dashboard first."));
+        return;
+    }
+    console.log(chalk.bold(`\n  ${res.swarms.length} swarm(s) found:\n`));
+    for (const swarm of res.swarms) {
+        const personaCount = Array.isArray(swarm.personas) ? swarm.personas.length : 0;
+        console.log(`  ${chalk.cyan(swarm.id)}  ${chalk.bold(swarm.name)}  (${personaCount} personas)`);
+        if (swarm.description) {
+            console.log(`    ${chalk.dim(swarm.description)}`);
+        }
+    }
+    console.log();
+    console.log(chalk.dim("  Use a swarm ID with: swarm test --swarm <id>"));
+    console.log();
+});

package/dist/commands/login.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare const loginCommand: Command;
+export declare const logoutCommand: Command;

package/dist/commands/login.js

@@ -0,0 +1,91 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import open from "open";
+import { ApiClient } from "../lib/api-client.js";
+import { saveConfig, getApiUrl, getConfig, clearConfig } from "../lib/config.js";
+export const loginCommand = new Command("login")
+    .description("Authenticate with Swarm via browser")
+    .option("--api-url <url>", "Override API URL")
+    .action(async (opts) => {
+    const apiUrl = opts.apiUrl ?? getApiUrl();
+    const client = new ApiClient(apiUrl);
+    const existing = getConfig();
+    if (existing) {
+        console.log(chalk.yellow(`Already logged in as ${existing.user.name} (${existing.organization.name}).`));
+        console.log(chalk.dim("Run `swarm logout` to switch accounts.\n"));
+    }
+    const spinner = ora("Starting authentication...").start();
+    let initRes;
+    try {
+        initRes = await client.initiateAuth();
+    }
+    catch (err) {
+        spinner.fail("Failed to start authentication");
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+    spinner.stop();
+    console.log();
+    console.log(chalk.bold("  Enter this code in your browser:"));
+    console.log();
+    console.log(chalk.cyan.bold(`    ${initRes.userCode}`));
+    console.log();
+    console.log(chalk.dim(`  Opening ${initRes.verificationUrl} ...`));
+    console.log();
+    await open(initRes.verificationUrl).catch(() => {
+        console.log(chalk.yellow(`  Could not open browser. Visit: ${initRes.verificationUrl}`));
+    });
+    const pollSpinner = ora("Waiting for browser authorization...").start();
+    const deadline = Date.now() + initRes.expiresIn * 1000;
+    while (Date.now() < deadline) {
+        await sleep(2500);
+        try {
+            const poll = await client.pollAuth(initRes.deviceCode);
+            if (poll.status === "complete" && poll.apiKey && poll.user && poll.organization) {
+                pollSpinner.stop();
+                const authedClient = new ApiClient(apiUrl, poll.apiKey);
+                let ngrokToken;
+                try {
+                    const tokenRes = await authedClient.getTunnelToken();
+                    ngrokToken = tokenRes.ngrokAuthToken;
+                }
+                catch {
+                    // Non-fatal
+                }
+                saveConfig({
+                    apiKey: poll.apiKey,
+                    apiUrl,
+                    ngrokToken,
+                    user: poll.user,
+                    organization: poll.organization,
+                });
+                console.log(chalk.green("✓ Authenticated successfully!"));
+                console.log();
+                console.log(`  ${chalk.bold("User:")}  ${poll.user.name} (${poll.user.email})`);
+                console.log(`  ${chalk.bold("Org:")}   ${poll.organization.name} (${poll.organization.planType} plan)`);
+                console.log();
+                console.log(chalk.dim("  Run `swarm test` to start a UX simulation."));
+                return;
+            }
+            if (poll.status === "expired") {
+                pollSpinner.fail("Authentication expired. Run `swarm login` again.");
+                process.exit(1);
+            }
+        }
+        catch {
+            // Network error — keep polling
+        }
+    }
+    pollSpinner.fail("Authentication timed out. Run `swarm login` again.");
+    process.exit(1);
+});
+export const logoutCommand = new Command("logout")
+    .description("Remove stored credentials")
+    .action(() => {
+    clearConfig();
+    console.log(chalk.green("✓ Logged out successfully."));
+});
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/commands/test.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const testCommand: Command;

package/dist/commands/test.js

@@ -0,0 +1,167 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { ApiClient } from "../lib/api-client.js";
+import { requireAuth } from "../lib/config.js";
+import { openTunnel } from "../lib/tunnel.js";
+import { renderStep, renderRunComplete, renderSynthesis, renderJudge, renderDone } from "../lib/renderer.js";
+import { EventSourceParserStream } from "eventsource-parser/stream";
+export const testCommand = new Command("test")
+    .description("Run a UX simulation against a URL")
+    .requiredOption("--url <url>", "Target URL (use localhost:PORT for local dev)")
+    .requiredOption("--goal <goal>", "What the user should try to do")
+    .option("--description <desc>", "Describe your target audience", "general web users")
+    .option("--swarm <id>", "Use an existing swarm's personas")
+    .option("--agents <count>", "Number of AI agents to generate", "3")
+    .option("--audience <desc>", "Audience description for persona generation")
+    .option("--no-tunnel", "Skip ngrok tunnel (URL must be publicly accessible)")
+    .action(async (opts) => {
+    const config = requireAuth();
+    const client = new ApiClient(config.apiUrl, config.apiKey);
+    let targetUrl = opts.url;
+    let tunnel;
+    const isLocalhost = targetUrl.includes("localhost") ||
+        targetUrl.includes("127.0.0.1") ||
+        targetUrl.match(/:\d+/) !== null;
+    if (isLocalhost && opts.tunnel !== false) {
+        const portMatch = targetUrl.match(/:(\d+)/);
+        const port = portMatch ? parseInt(portMatch[1], 10) : 3000;
+        if (!config.ngrokToken) {
+            console.error(chalk.red("No tunnel token available. Run `swarm login` again or use --no-tunnel."));
+            process.exit(1);
+        }
+        const tunnelSpinner = ora(`Opening tunnel to localhost:${port}...`).start();
+        try {
+            tunnel = await openTunnel(port, config.ngrokToken);
+            targetUrl = tunnel.url;
+            tunnelSpinner.succeed(`Tunnel open: ${chalk.underline(tunnel.url)}`);
+        }
+        catch (err) {
+            tunnelSpinner.fail("Failed to open tunnel");
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    }
+    const body = {
+        targetUrl,
+        goal: opts.goal,
+        userDescription: opts.description,
+    };
+    if (opts.swarm) {
+        body.swarmId = opts.swarm;
+    }
+    else {
+        body.generatePersonas = {
+            agentCount: parseInt(opts.agents, 10),
+            audienceDescription: opts.audience ?? opts.description,
+        };
+    }
+    const createSpinner = ora("Creating test run...").start();
+    let createRes;
+    try {
+        createRes = await client.createTest(body);
+    }
+    catch (err) {
+        createSpinner.fail("Failed to create test");
+        console.error(chalk.red(err.message));
+        await tunnel?.close();
+        process.exit(1);
+    }
+    createSpinner.succeed(`Test started with ${createRes.totalRuns} agent(s) — ${chalk.dim(createRes.batchId)}`);
+    console.log();
+    for (const p of createRes.personas) {
+        console.log(`  ${chalk.cyan("•")} ${p.name}`);
+    }
+    console.log();
+    try {
+        await streamResults(client, createRes.batchId, config.apiKey, createRes.dashboardUrl);
+    }
+    catch (err) {
+        console.error(chalk.red(`\nStream error: ${err.message}`));
+        console.log(chalk.dim(`\nPoll results: swarm status ${createRes.batchId}`));
+    }
+    if (tunnel) {
+        await tunnel.close().catch(() => { });
+    }
+});
+async function streamResults(client, batchId, apiKey, dashboardUrl) {
+    const url = client.streamUrl(batchId);
+    const response = await fetch(url, {
+        headers: {
+            "X-API-Key": apiKey,
+            Accept: "text/event-stream",
+        },
+    });
+    if (!response.ok || !response.body) {
+        console.log(chalk.dim("SSE not available, falling back to polling..."));
+        await pollResults(client, batchId, dashboardUrl);
+        return;
+    }
+    const stream = response.body
+        .pipeThrough(new TextDecoderStream())
+        .pipeThrough(new EventSourceParserStream());
+    for await (const event of stream) {
+        const eventType = event.event;
+        if (!eventType || eventType === "keepalive" || !event.data)
+            continue;
+        try {
+            const data = JSON.parse(event.data);
+            switch (data.type) {
+                case "step":
+                    renderStep(data);
+                    break;
+                case "run_complete":
+                    renderRunComplete(data);
+                    break;
+                case "synthesis":
+                    renderSynthesis(data);
+                    break;
+                case "judge":
+                    renderJudge(data);
+                    break;
+                case "done":
+                    renderDone(dashboardUrl);
+                    return;
+            }
+        }
+        catch {
+            // Skip malformed events
+        }
+    }
+    renderDone(dashboardUrl);
+}
+async function pollResults(client, batchId, dashboardUrl) {
+    const spinner = ora("Waiting for results...").start();
+    while (true) {
+        await new Promise((r) => setTimeout(r, 5000));
+        try {
+            const status = await client.getBatchStatus(batchId);
+            spinner.text = `Running... ${status.completedRuns}/${status.totalRuns} agents complete`;
+            if (status.status === "completed" || status.status === "failed") {
+                spinner.stop();
+                if (status.synthesis) {
+                    renderSynthesis({
+                        type: "synthesis",
+                        executiveSummary: status.synthesis.executiveSummary,
+                        tickets: status.synthesis.tickets,
+                        positives: status.synthesis.positives,
+                    });
+                }
+                if (status.judge) {
+                    renderJudge({
+                        type: "judge",
+                        verdict: status.judge.verdict,
+                        confidence: status.judge.confidence,
+                        evidenceBlocks: status.judge.evidenceBlocks,
+                        recommendedActions: status.judge.recommendedActions,
+                    });
+                }
+                renderDone(dashboardUrl);
+                return;
+            }
+        }
+        catch {
+            // Keep polling on error
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { loginCommand, logoutCommand } from "./commands/login.js";
+import { testCommand } from "./commands/test.js";
+import { listSwarmsCommand } from "./commands/list-swarms.js";
+const program = new Command();
+program
+    .name("swarm")
+    .description("Swarm CLI — run AI-powered UX simulations from the terminal")
+    .version("0.0.1");
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(testCommand);
+program.addCommand(listSwarmsCommand);
+program.parse();

package/dist/lib/api-client.d.ts

@@ -0,0 +1,15 @@
+import type { InitiateResponse, PollResponse, TunnelTokenResponse, SwarmsResponse, CreateTestRequest, CreateTestResponse, BatchStatusResponse } from "../types.js";
+export declare class ApiClient {
+    private baseUrl;
+    private apiKey?;
+    constructor(baseUrl: string, apiKey?: string | undefined);
+    private headers;
+    private request;
+    initiateAuth(): Promise<InitiateResponse>;
+    pollAuth(deviceCode: string): Promise<PollResponse>;
+    getTunnelToken(): Promise<TunnelTokenResponse>;
+    listSwarms(): Promise<SwarmsResponse>;
+    createTest(req: CreateTestRequest): Promise<CreateTestResponse>;
+    getBatchStatus(batchId: string): Promise<BatchStatusResponse>;
+    streamUrl(batchId: string): string;
+}

package/dist/lib/api-client.js

@@ -0,0 +1,48 @@
+export class ApiClient {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    headers() {
+        const h = { "Content-Type": "application/json" };
+        if (this.apiKey)
+            h["X-API-Key"] = this.apiKey;
+        return h;
+    }
+    async request(method, path, body) {
+        const url = `${this.baseUrl}/api/cli${path}`;
+        const res = await fetch(url, {
+            method,
+            headers: this.headers(),
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(err.error ?? `HTTP ${res.status}`);
+        }
+        return res.json();
+    }
+    async initiateAuth() {
+        return this.request("POST", "/auth/initiate");
+    }
+    async pollAuth(deviceCode) {
+        return this.request("GET", `/auth/poll?device_code=${encodeURIComponent(deviceCode)}`);
+    }
+    async getTunnelToken() {
+        return this.request("GET", "/tunnel-token");
+    }
+    async listSwarms() {
+        return this.request("GET", "/swarms");
+    }
+    async createTest(req) {
+        return this.request("POST", "/tests", req);
+    }
+    async getBatchStatus(batchId) {
+        return this.request("GET", `/tests/${batchId}`);
+    }
+    streamUrl(batchId) {
+        return `${this.baseUrl}/api/cli/tests/${batchId}/stream`;
+    }
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,6 @@
+import type { SwarmConfig } from "../types.js";
+export declare function getConfig(): SwarmConfig | null;
+export declare function saveConfig(config: SwarmConfig): void;
+export declare function clearConfig(): void;
+export declare function getApiUrl(): string;
+export declare function requireAuth(): SwarmConfig;

package/dist/lib/config.js

@@ -0,0 +1,49 @@
+import Conf from "conf";
+const DEFAULT_API_URL = "https://staging-api.useswarm.co";
+const store = new Conf({
+    projectName: "swarm",
+    schema: {
+        auth: {
+            type: "object",
+            properties: {
+                apiKey: { type: "string" },
+                apiUrl: { type: "string" },
+                ngrokToken: { type: "string" },
+                user: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string" },
+                        email: { type: "string" },
+                    },
+                },
+                organization: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string" },
+                        planType: { type: "string" },
+                    },
+                },
+            },
+        },
+    },
+});
+export function getConfig() {
+    return store.get("auth") ?? null;
+}
+export function saveConfig(config) {
+    store.set("auth", config);
+}
+export function clearConfig() {
+    store.delete("auth");
+}
+export function getApiUrl() {
+    return getConfig()?.apiUrl ?? process.env.SWARM_API_URL ?? DEFAULT_API_URL;
+}
+export function requireAuth() {
+    const config = getConfig();
+    if (!config) {
+        console.error("Not logged in. Run `swarm login` first.");
+        process.exit(1);
+    }
+    return config;
+}

package/dist/lib/renderer.d.ts

@@ -0,0 +1,6 @@
+import type { StepEvent, RunCompleteEvent, SynthesisEvent, JudgeEvent } from "../types.js";
+export declare function renderStep(event: StepEvent): void;
+export declare function renderRunComplete(event: RunCompleteEvent): void;
+export declare function renderSynthesis(event: SynthesisEvent): void;
+export declare function renderJudge(event: JudgeEvent): void;
+export declare function renderDone(dashboardUrl: string): void;

package/dist/lib/renderer.js

@@ -0,0 +1,71 @@
+import chalk from "chalk";
+const SENTIMENT_COLORS = {
+    positive: chalk.green,
+    neutral: chalk.gray,
+    negative: chalk.yellow,
+    critical: chalk.red,
+};
+export function renderStep(event) {
+    const persona = chalk.cyan(event.personaName.padEnd(18));
+    const stepNum = chalk.dim(`[step ${String(event.step).padStart(2)}]`);
+    if (event.thought?.summary) {
+        const color = SENTIMENT_COLORS[event.thought.sentiment ?? "neutral"] ?? chalk.gray;
+        console.log(`  ${persona} ${stepNum} ${color(event.thought.summary)}`);
+    }
+    if (event.action) {
+        const action = chalk.dim(`→ ${event.action.toolName}`);
+        console.log(`  ${" ".repeat(18)} ${" ".repeat(10)} ${action}`);
+    }
+}
+export function renderRunComplete(event) {
+    const persona = chalk.cyan(event.personaName.padEnd(18));
+    const status = event.status === "completed"
+        ? chalk.green("✓ completed")
+        : event.status === "abandoned"
+            ? chalk.yellow("⚠ abandoned")
+            : event.status === "blocked"
+                ? chalk.red("✕ blocked")
+                : chalk.red(`✕ ${event.status}`);
+    const score = event.uxScore != null ? chalk.bold(` UX: ${event.uxScore}/100`) : "";
+    console.log(`\n  ${persona} ${status}${score}\n`);
+}
+export function renderSynthesis(event) {
+    console.log(chalk.bold("\n  ── Synthesis ──────────────────────────────────────\n"));
+    console.log(`  ${event.executiveSummary}\n`);
+    if (event.positives?.length > 0) {
+        console.log(chalk.green.bold("  Positives:"));
+        for (const p of event.positives) {
+            const text = typeof p === "string" ? p : p.title ?? JSON.stringify(p);
+            console.log(chalk.green(`    ✓ ${text}`));
+        }
+        console.log();
+    }
+    if (event.tickets?.length > 0) {
+        console.log(chalk.yellow.bold("  Issues Found:"));
+        for (const t of event.tickets) {
+            const title = typeof t === "string" ? t : t.title ?? JSON.stringify(t);
+            const severity = t.severity ? chalk.dim(` [${t.severity}]`) : "";
+            console.log(chalk.yellow(`    • ${title}${severity}`));
+        }
+        console.log();
+    }
+}
+export function renderJudge(event) {
+    console.log(chalk.bold("\n  ── Judge Verdict ─────────────────────────────────\n"));
+    const verdictColor = event.verdict === "pass" ? chalk.green : event.verdict === "fail" ? chalk.red : chalk.yellow;
+    console.log(`  Verdict:    ${verdictColor.bold(event.verdict.toUpperCase())}`);
+    console.log(`  Confidence: ${chalk.bold(event.confidence)}`);
+    if (event.recommendedActions?.length > 0) {
+        console.log(chalk.bold("\n  Recommended Actions:"));
+        for (const action of event.recommendedActions) {
+            const text = typeof action === "string" ? action : action.action ?? JSON.stringify(action);
+            console.log(`    → ${text}`);
+        }
+    }
+    console.log();
+}
+export function renderDone(dashboardUrl) {
+    console.log(chalk.bold("  ── Complete ──────────────────────────────────────\n"));
+    console.log(`  ${chalk.dim("Full results:")} ${chalk.underline(dashboardUrl)}`);
+    console.log();
+}

package/dist/lib/tunnel.d.ts

@@ -0,0 +1,5 @@
+export interface TunnelInfo {
+    url: string;
+    close: () => Promise<void>;
+}
+export declare function openTunnel(localPort: number, authToken: string): Promise<TunnelInfo>;

package/dist/lib/tunnel.js

@@ -0,0 +1,17 @@
+import ngrok from "@ngrok/ngrok";
+export async function openTunnel(localPort, authToken) {
+    const listener = await ngrok.forward({
+        addr: localPort,
+        authtoken: authToken,
+    });
+    const url = listener.url();
+    if (!url) {
+        throw new Error("ngrok tunnel created but no URL returned");
+    }
+    return {
+        url,
+        close: async () => {
+            await listener.close();
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,131 @@
+export interface InitiateResponse {
+    deviceCode: string;
+    userCode: string;
+    verificationUrl: string;
+    expiresIn: number;
+}
+export interface PollResponse {
+    status: "pending" | "expired" | "consumed" | "complete";
+    apiKey?: string;
+    user?: {
+        name: string;
+        email: string;
+    };
+    organization?: {
+        name: string;
+        planType: string;
+    };
+    error?: string;
+}
+export interface TunnelTokenResponse {
+    ngrokAuthToken: string;
+}
+export interface Swarm {
+    id: string;
+    name: string;
+    description: string | null;
+    personas: any[];
+    createdAt: string;
+}
+export interface SwarmsResponse {
+    swarms: Swarm[];
+}
+export interface CreateTestRequest {
+    targetUrl: string;
+    goal: string;
+    userDescription: string;
+    swarmId?: string;
+    generatePersonas?: {
+        agentCount: number;
+        audienceDescription: string;
+    };
+}
+export interface CreateTestResponse {
+    batchId: string;
+    personas: Array<{
+        index: number;
+        name: string;
+    }>;
+    totalRuns: number;
+    dashboardUrl: string;
+}
+export interface BatchStatusResponse {
+    batchId: string;
+    status: string;
+    overallUxScore: number | null;
+    totalRuns: number;
+    completedRuns: number;
+    failedRuns: number;
+    runs: Array<{
+        id: string;
+        personaIndex: number;
+        personaName: string | null;
+        status: string;
+        uxScore: number | null;
+        stepsTaken: number | null;
+    }>;
+    synthesis: {
+        executiveSummary: string;
+        tickets: any[];
+        positives: any[];
+    } | null;
+    judge: {
+        verdict: string;
+        confidence: string;
+        evidenceBlocks: any[];
+        recommendedActions: any[];
+    } | null;
+    dashboardUrl: string;
+}
+export interface StepEvent {
+    type: "step";
+    runId: string;
+    personaName: string;
+    step: number;
+    thought?: {
+        kind: string;
+        summary?: string;
+        sentiment?: string;
+    };
+    action?: {
+        toolName: string;
+        input: Record<string, unknown>;
+    };
+}
+export interface RunCompleteEvent {
+    type: "run_complete";
+    runId: string;
+    personaName: string;
+    status: string;
+    uxScore?: number;
+}
+export interface SynthesisEvent {
+    type: "synthesis";
+    executiveSummary: string;
+    tickets: any[];
+    positives: any[];
+}
+export interface JudgeEvent {
+    type: "judge";
+    verdict: string;
+    confidence: string;
+    evidenceBlocks: any[];
+    recommendedActions: any[];
+}
+export interface DoneEvent {
+    type: "done";
+}
+export type SSEEvent = StepEvent | RunCompleteEvent | SynthesisEvent | JudgeEvent | DoneEvent;
+export interface SwarmConfig {
+    apiKey: string;
+    apiUrl: string;
+    ngrokToken?: string;
+    user: {
+        name: string;
+        email: string;
+    };
+    organization: {
+        name: string;
+        planType: string;
+    };
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@useswarm/cli",
+  "version": "0.1.0",
+  "description": "Swarm CLI — AI-powered UX testing from your terminal",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "swarm": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["ux", "testing", "ai", "swarm", "cli"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aaladaruncc/my-stagehand-app",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://useswarm.co",
+  "dependencies": {
+    "commander": "^13.0.0",
+    "chalk": "^5.4.0",
+    "ora": "^8.2.0",
+    "open": "^10.1.0",
+    "conf": "^13.0.0",
+    "@ngrok/ngrok": "^1.4.1",
+    "eventsource-parser": "^3.0.0"
+  },
+  "devDependencies": {
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}