speqs 0.4.0 → 0.5.0

package/dist/commands/tester-profile.js

@@ -0,0 +1,95 @@
+/**
+ * speqs tester-profile — Manage tester profiles.
+ */
+import { withClient, readJsonFileOrStdin } from "../lib/command-helpers.js";
+import { formatTesterProfileList, output } from "../lib/output.js";
+export function registerTesterProfileCommands(program) {
+    const profile = program
+        .command("tester-profile")
+        .description("Manage tester profiles");
+    profile
+        .command("list")
+        .description("List tester profiles (defaults to simulatable AI profiles)")
+        .option("--workspace <id>", "Filter by workspace ID")
+        .option("--search <query>", "Search by name or bio")
+        .option("--type <type>", "Profile type: ai, human, all (default: ai)", "ai")
+        .option("--gender <gender>", "Filter by gender")
+        .option("--country <country>", "Filter by country code (e.g. US, GB, SE)")
+        .option("--min-age <n>", "Minimum age")
+        .option("--max-age <n>", "Maximum age")
+        .option("--limit <n>", "Max results (default 50)", "50")
+        .option("--offset <n>", "Offset for pagination", "0")
+        .addHelpText("after", `
+Examples:
+  $ speqs tester-profile list
+  $ speqs tester-profile list --search "engineer" --country US
+  $ speqs tester-profile list --gender female --min-age 25 --max-age 40
+  $ speqs tester-profile list --type all --json`)
+        .action(async (opts, cmd) => {
+        await withClient(cmd, async (client, globals) => {
+            const params = {
+                limit: opts.limit,
+                offset: opts.offset,
+            };
+            if (opts.workspace)
+                params.product_id = opts.workspace;
+            if (opts.search)
+                params.search = opts.search;
+            if (opts.type !== "all")
+                params.type = opts.type;
+            if (opts.gender)
+                params.gender = opts.gender;
+            if (opts.country)
+                params.country = opts.country;
+            if (opts.minAge)
+                params.min_age = opts.minAge;
+            if (opts.maxAge)
+                params.max_age = opts.maxAge;
+            const data = await client.get("/tester-profiles", params);
+            formatTesterProfileList(data, globals.json, parseInt(opts.limit, 10));
+        });
+    });
+    profile
+        .command("create")
+        .description("Create a tester profile")
+        .requiredOption("--file <path>", "JSON file with profile data")
+        .action(async (opts, cmd) => {
+        await withClient(cmd, async (client, globals) => {
+            const body = await readJsonFileOrStdin(opts.file);
+            const data = await client.post("/tester-profiles", body);
+            output(data, globals.json);
+        });
+    });
+    profile
+        .command("get")
+        .description("Get tester profile details")
+        .argument("<id>", "Tester profile ID")
+        .action(async (id, _opts, cmd) => {
+        await withClient(cmd, async (client, globals) => {
+            const data = await client.get(`/tester-profiles/${id}`);
+            output(data, globals.json);
+        });
+    });
+    profile
+        .command("update")
+        .description("Update a tester profile")
+        .argument("<id>", "Tester profile ID")
+        .requiredOption("--file <path>", "JSON file with update data")
+        .action(async (id, opts, cmd) => {
+        await withClient(cmd, async (client, globals) => {
+            const body = await readJsonFileOrStdin(opts.file);
+            const data = await client.put(`/tester-profiles/${id}`, body);
+            output(data, globals.json);
+        });
+    });
+    profile
+        .command("delete")
+        .description("Delete a tester profile")
+        .argument("<id>", "Tester profile ID")
+        .action(async (id, _opts, cmd) => {
+        await withClient(cmd, async (client, globals) => {
+            await client.del(`/tester-profiles/${id}`);
+            output({ message: "Tester profile deleted" }, globals.json);
+        });
+    });
+}

package/dist/commands/tester.d.ts

@@ -0,0 +1,5 @@
+/**
+ * speqs tester — Manage testers (usually created via `simulation run`).
+ */
+import type { Command } from "commander";
+export declare function registerTesterCommands(program: Command): void;

package/dist/commands/tester.js

@@ -0,0 +1,63 @@
+/**
+ * speqs tester — Manage testers (usually created via `simulation run`).
+ */
+import { withClient, readJsonFileOrStdin } from "../lib/command-helpers.js";
+import { formatTesterDetail, output } from "../lib/output.js";
+export function registerTesterCommands(program) {
+    const tester = program
+        .command("tester")
+        .description("Manage testers (usually created via `simulation run`)");
+    tester
+        .command("create")
+        .description("Create a tester (low-level)")
+        .requiredOption("--iteration <id>", "Iteration ID")
+        .requiredOption("--profile <id>", "Tester profile ID")
+        .option("--language <lang>", "Language code (e.g. en, sv)")
+        .option("--platform <platform>", "Platform (browser, android, figma, code)")
+        .option("--tester-type <type>", "Tester type (ai, human)", "ai")
+        .action(async (opts, cmd) => {
+        await withClient(cmd, async (client, globals) => {
+            const body = {
+                tester_profile_id: opts.profile,
+                tester_type: opts.testerType,
+                ...(opts.language && { language: opts.language }),
+                ...(opts.platform && { platform: opts.platform }),
+            };
+            const data = await client.post(`/iterations/${opts.iteration}/testers`, body);
+            output(data, globals.json);
+        });
+    });
+    tester
+        .command("batch-create")
+        .description("Create multiple testers from a JSON file (low-level)")
+        .requiredOption("--iteration <id>", "Iteration ID")
+        .requiredOption("--file <path>", "JSON file with testers array")
+        .action(async (opts, cmd) => {
+        await withClient(cmd, async (client, globals) => {
+            const body = await readJsonFileOrStdin(opts.file);
+            const data = await client.post(`/iterations/${opts.iteration}/testers/batch`, body);
+            output(data, globals.json);
+        });
+    });
+    tester
+        .command("get")
+        .description("Get tester details and results")
+        .argument("<id>", "Tester ID")
+        .addHelpText("after", "\nExamples:\n  $ speqs tester get <id>\n  $ speqs tester get <id> --json")
+        .action(async (id, _opts, cmd) => {
+        await withClient(cmd, async (client, globals) => {
+            const data = await client.get(`/testers/${id}`);
+            formatTesterDetail(data, globals.json);
+        });
+    });
+    tester
+        .command("delete")
+        .description("Delete a tester")
+        .argument("<id>", "Tester ID")
+        .action(async (id, _opts, cmd) => {
+        await withClient(cmd, async (client, globals) => {
+            await client.del(`/testers/${id}`);
+            output({ message: "Tester deleted" }, globals.json);
+        });
+    });
+}

package/dist/commands/workspace.d.ts

@@ -0,0 +1,5 @@
+/**
+ * speqs workspace — Manage workspaces (API: /products).
+ */
+import type { Command } from "commander";
+export declare function registerWorkspaceCommands(program: Command): void;

package/dist/commands/workspace.js

@@ -0,0 +1,86 @@
+/**
+ * speqs workspace — Manage workspaces (API: /products).
+ */
+import { withClient, getWebUrl, terminalLink } from "../lib/command-helpers.js";
+import { formatWorkspaceList, formatWorkspaceDetail, output } from "../lib/output.js";
+export function registerWorkspaceCommands(program) {
+    const workspace = program
+        .command("workspace")
+        .description("Manage workspaces");
+    workspace
+        .command("list")
+        .description("List all workspaces")
+        .addHelpText("after", "\nExamples:\n  $ speqs workspace list\n  $ speqs workspace list --json")
+        .action(async (_opts, cmd) => {
+        await withClient(cmd, async (client, globals) => {
+            const data = await client.get("/products");
+            formatWorkspaceList(data, globals.json);
+        });
+    });
+    workspace
+        .command("create")
+        .description("Create a new workspace")
+        .requiredOption("--name <name>", "Workspace name")
+        .option("--description <description>", "Workspace description")
+        .option("--base-url <url>", "Default base URL")
+        .addHelpText("after", "\nExamples:\n  $ speqs workspace create --name \"My App\" --base-url https://example.com\n  $ speqs workspace create --name \"My App\" --json")
+        .action(async (opts, cmd) => {
+        await withClient(cmd, async (client, globals) => {
+            const body = {
+                name: opts.name,
+                ...(opts.description && { description: opts.description }),
+                ...(opts.baseUrl && { base_url: opts.baseUrl }),
+            };
+            const data = await client.post("/products", body);
+            formatWorkspaceDetail(data, globals.json);
+            if (!globals.json && data.id) {
+                const url = getWebUrl(globals, `/${data.id}`);
+                console.error(`\n  ${terminalLink(url, "Open in browser ↗")}\n`);
+            }
+        });
+    });
+    workspace
+        .command("get")
+        .description("Get workspace details")
+        .argument("<id>", "Workspace ID")
+        .action(async (id, _opts, cmd) => {
+        await withClient(cmd, async (client, globals) => {
+            const data = await client.get(`/products/${id}`);
+            formatWorkspaceDetail(data, globals.json);
+            if (!globals.json) {
+                const url = getWebUrl(globals, `/${id}`);
+                console.error(`\n  ${terminalLink(url, "Open in browser ↗")}\n`);
+            }
+        });
+    });
+    workspace
+        .command("update")
+        .description("Update a workspace")
+        .argument("<id>", "Workspace ID")
+        .option("--name <name>", "Workspace name")
+        .option("--description <description>", "Workspace description")
+        .option("--base-url <url>", "Default base URL")
+        .action(async (id, opts, cmd) => {
+        await withClient(cmd, async (client, globals) => {
+            const body = {};
+            if (opts.name !== undefined)
+                body.name = opts.name;
+            if (opts.description !== undefined)
+                body.description = opts.description;
+            if (opts.baseUrl !== undefined)
+                body.base_url = opts.baseUrl;
+            const data = await client.put(`/products/${id}`, body);
+            formatWorkspaceDetail(data, globals.json);
+        });
+    });
+    workspace
+        .command("delete")
+        .description("Delete a workspace")
+        .argument("<id>", "Workspace ID")
+        .action(async (id, _opts, cmd) => {
+        await withClient(cmd, async (client, globals) => {
+            await client.del(`/products/${id}`);
+            output({ message: "Workspace deleted" }, globals.json);
+        });
+    });
+}

package/dist/index.js

@@ -4,18 +4,35 @@ import { runTunnel } from "./connect.js";
 import { login, getAppUrl } from "./auth.js";
 import { loadConfig, saveConfig } from "./config.js";
 import { upgrade } from "./upgrade.js";
+import { registerWorkspaceCommands } from "./commands/workspace.js";
+import { registerStudyCommands } from "./commands/study.js";
+import { registerIterationCommands } from "./commands/iteration.js";
+import { registerTesterProfileCommands } from "./commands/tester-profile.js";
+import { registerTesterCommands } from "./commands/tester.js";
+import { registerSimulationCommands } from "./commands/simulation.js";
+import { registerConfigCommands } from "./commands/config.js";
 import pkg from "../package.json" with { type: "json" };
 const { version } = pkg;
 program
     .name("speqs")
-    .description("Speqs CLI tools")
+    .description("Speqs CLI — manage workspaces, studies, simulations, and more")
     .version(version);
+// Global options
+program
+    .option("-t, --token <token>", "Auth token (or set SPEQS_TOKEN env var)")
+    .option("--api-url <url>", "Backend API URL (default: SPEQS_API_URL or https://api.speqs.io)")
+    .addOption(new Option("--dev", "Use local dev API (http://localhost:8000)").hideHelp())
+    .option("--json", "Output as JSON (for programmatic use)")
+    .option("-q, --quiet", "Suppress progress messages on stderr");
+// --- Inline commands (from upstream) ---
 program
     .command("login")
     .description("Authenticate with Speqs via your browser")
-    .action(async () => {
+    .action(async (_opts, cmd) => {
     try {
-        const tokens = await login(getAppUrl());
+        const globals = cmd.optsWithGlobals();
+        const appUrl = globals.dev ? "http://localhost:3000" : getAppUrl();
+        const tokens = await login(appUrl);
         const config = loadConfig();
         config.access_token = tokens.accessToken;
         config.refresh_token = tokens.refreshToken;
@@ -42,18 +59,24 @@ program
     .command("connect")
     .description("Expose your localhost to Speqs via a Cloudflare tunnel")
     .argument("<port>", "Local port to connect (e.g. 3000)")
-    .option("-t, --token <token>", "Auth token (or set SPEQS_TOKEN, or save via interactive prompt)")
-    .option("--api-url <url>", "Backend API URL (default: SPEQS_API_URL or https://api.speqs.io)")
-    .addOption(new Option("--dev", "Use local dev API (http://localhost:8000)").hideHelp())
-    .action(async (port, options) => {
+    .action(async (port, _opts, cmd) => {
     const portNum = parseInt(port, 10);
     if (isNaN(portNum) || portNum < 1 || portNum > 65535) {
         console.error(`Invalid port: ${port}`);
         process.exit(1);
     }
-    const apiUrl = options.dev ? "http://localhost:8000" : options.apiUrl;
-    await runTunnel(portNum, options.token, apiUrl);
+    const globals = cmd.optsWithGlobals();
+    const apiUrl = globals.dev ? "http://localhost:8000" : globals.apiUrl;
+    await runTunnel(portNum, globals.token, apiUrl);
 });
+// --- Modular command groups ---
+registerWorkspaceCommands(program);
+registerStudyCommands(program);
+registerIterationCommands(program);
+registerTesterProfileCommands(program);
+registerTesterCommands(program);
+registerSimulationCommands(program);
+registerConfigCommands(program);
 program
     .command("upgrade")
     .description("Update speqs to the latest version")

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

@@ -0,0 +1,27 @@
+/**
+ * Shared HTTP API client for the Speqs backend.
+ */
+export declare class ApiError extends Error {
+    status: number;
+    statusText: string;
+    body: unknown;
+    error_code: string;
+    retryable: boolean;
+    constructor(status: number, statusText: string, body: unknown);
+}
+export declare class ApiClient {
+    private baseUrl;
+    private token;
+    constructor(opts: {
+        apiUrl: string;
+        token: string;
+    });
+    private headers;
+    get<T = unknown>(path: string, params?: Record<string, string>): Promise<T>;
+    post<T = unknown>(path: string, body?: unknown, opts?: {
+        timeout?: number;
+    }): Promise<T>;
+    put<T = unknown>(path: string, body?: unknown): Promise<T>;
+    del(path: string): Promise<void>;
+    private handleResponse;
+}

package/dist/lib/api-client.js

@@ -0,0 +1,121 @@
+/**
+ * Shared HTTP API client for the Speqs backend.
+ */
+import { API_BASE } from "./auth.js";
+function mapErrorCode(status) {
+    if (status === 401)
+        return "auth_failed";
+    if (status === 403)
+        return "forbidden";
+    if (status === 404)
+        return "not_found";
+    if (status === 402)
+        return "insufficient_credits";
+    if (status === 422)
+        return "validation_error";
+    if (status === 429)
+        return "rate_limited";
+    if (status >= 500)
+        return "server_error";
+    return "request_failed";
+}
+function isRetryable(status) {
+    return status === 429 || status >= 500;
+}
+export class ApiError extends Error {
+    status;
+    statusText;
+    body;
+    error_code;
+    retryable;
+    constructor(status, statusText, body) {
+        const msg = typeof body === "object" && body !== null && "detail" in body
+            ? String(body.detail)
+            : `HTTP ${status} ${statusText}`;
+        super(msg);
+        this.status = status;
+        this.statusText = statusText;
+        this.body = body;
+        this.name = "ApiError";
+        this.error_code = mapErrorCode(status);
+        this.retryable = isRetryable(status);
+    }
+}
+export class ApiClient {
+    baseUrl;
+    token;
+    constructor(opts) {
+        this.baseUrl = `${opts.apiUrl}${API_BASE}`;
+        this.token = opts.token;
+    }
+    headers() {
+        return {
+            Authorization: `Bearer ${this.token}`,
+            "Content-Type": "application/json",
+        };
+    }
+    async get(path, params) {
+        let url = `${this.baseUrl}${path}`;
+        if (params) {
+            const filtered = Object.entries(params).filter(([, v]) => v !== undefined && v !== "");
+            if (filtered.length > 0) {
+                url += "?" + new URLSearchParams(filtered).toString();
+            }
+        }
+        const resp = await fetch(url, {
+            headers: this.headers(),
+            signal: AbortSignal.timeout(15_000),
+        });
+        return this.handleResponse(resp);
+    }
+    async post(path, body, opts) {
+        const resp = await fetch(`${this.baseUrl}${path}`, {
+            method: "POST",
+            headers: this.headers(),
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+            signal: AbortSignal.timeout(opts?.timeout ?? 15_000),
+        });
+        return this.handleResponse(resp);
+    }
+    async put(path, body) {
+        const resp = await fetch(`${this.baseUrl}${path}`, {
+            method: "PUT",
+            headers: this.headers(),
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+            signal: AbortSignal.timeout(15_000),
+        });
+        return this.handleResponse(resp);
+    }
+    async del(path) {
+        const resp = await fetch(`${this.baseUrl}${path}`, {
+            method: "DELETE",
+            headers: this.headers(),
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!resp.ok) {
+            let body;
+            try {
+                body = await resp.json();
+            }
+            catch {
+                body = null;
+            }
+            throw new ApiError(resp.status, resp.statusText, body);
+        }
+    }
+    async handleResponse(resp) {
+        if (!resp.ok) {
+            let body;
+            try {
+                body = await resp.json();
+            }
+            catch {
+                body = null;
+            }
+            throw new ApiError(resp.status, resp.statusText, body);
+        }
+        if (resp.status === 204)
+            return undefined;
+        return await resp.json();
+    }
+}

package/dist/lib/auth.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shared authentication and configuration utilities for CLI commands.
+ * Uses the canonical config from src/config.ts and OAuth refresh from src/auth.ts.
+ */
+export declare const DEFAULT_API_URL = "https://api.speqs.io";
+export declare const API_BASE = "/api/v1";
+export declare function resolveApiUrl(apiUrlArg?: string, dev?: boolean): string;
+export declare function resolveToken(tokenArg: string | undefined, apiUrl: string): Promise<string>;

package/dist/lib/auth.js

@@ -0,0 +1,70 @@
+/**
+ * Shared authentication and configuration utilities for CLI commands.
+ * Uses the canonical config from src/config.ts and OAuth refresh from src/auth.ts.
+ */
+import { loadConfig, saveConfig } from "../config.js";
+import { refreshTokens, isTokenExpired } from "../auth.js";
+export const DEFAULT_API_URL = "https://api.speqs.io";
+export const API_BASE = "/api/v1";
+export function resolveApiUrl(apiUrlArg, dev) {
+    if (dev)
+        return "http://localhost:8000";
+    if (apiUrlArg)
+        return apiUrlArg;
+    return process.env.SPEQS_API_URL ?? DEFAULT_API_URL;
+}
+async function verifyToken(token, apiUrl) {
+    try {
+        const resp = await fetch(`${apiUrl}${API_BASE}/connect/active`, {
+            headers: { Authorization: `Bearer ${token}` },
+            signal: AbortSignal.timeout(10_000),
+        });
+        // 404 = valid token, no connection (expected). 401/403 = bad token.
+        return resp.status !== 401 && resp.status !== 403;
+    }
+    catch {
+        // Network error — can't verify, assume ok
+        console.error("Warning: Could not verify token (network error). Proceeding anyway.");
+        return true;
+    }
+}
+export async function resolveToken(tokenArg, apiUrl) {
+    // 1. Explicit token argument
+    if (tokenArg)
+        return tokenArg;
+    // 2. Environment variable
+    const envToken = process.env.SPEQS_TOKEN;
+    if (envToken)
+        return envToken;
+    // 3. Saved config with OAuth tokens (access_token + refresh_token)
+    const config = loadConfig();
+    if (config.access_token && config.refresh_token) {
+        let accessToken = config.access_token;
+        // Refresh if expired or close to expiry
+        if (isTokenExpired(accessToken)) {
+            try {
+                const tokens = await refreshTokens(config.refresh_token);
+                accessToken = tokens.accessToken;
+                config.access_token = tokens.accessToken;
+                config.refresh_token = tokens.refreshToken;
+                saveConfig(config);
+            }
+            catch {
+                throw new Error('Session expired. Run "speqs login" to re-authenticate.');
+            }
+        }
+        if (await verifyToken(accessToken, apiUrl)) {
+            return accessToken;
+        }
+        throw new Error('Saved token is invalid. Run "speqs login" to re-authenticate.');
+    }
+    // 4. Legacy saved token (no refresh token)
+    if (config.token) {
+        if (await verifyToken(config.token, apiUrl)) {
+            return config.token;
+        }
+        throw new Error('Saved token is invalid. Run "speqs login" to re-authenticate.');
+    }
+    // 5. No token found
+    throw new Error('No auth token found. Run "speqs login" or set SPEQS_TOKEN environment variable or pass --token <token>.');
+}

package/dist/lib/command-helpers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared helpers for command actions.
+ * Resolves global options, creates API client, handles errors.
+ */
+import type { Command } from "commander";
+import { ApiClient } from "./api-client.js";
+export interface GlobalOpts {
+    token?: string;
+    apiUrl?: string;
+    dev?: boolean;
+    json: boolean;
+    quiet: boolean;
+}
+export declare function getGlobals(cmd: Command): GlobalOpts;
+/**
+ * Map errors to semantic exit codes.
+ * 0=success, 1=general, 2=usage/validation, 3=auth, 4=not found, 5=transient
+ */
+export declare function exitCodeFromError(err: unknown): number;
+export declare function createClient(globals: GlobalOpts): Promise<ApiClient>;
+export declare function withClient(cmd: Command, fn: (client: ApiClient, globals: GlobalOpts) => Promise<void>): Promise<void>;
+export declare function getWebUrl(globals: GlobalOpts, path: string): string;
+export declare function terminalLink(url: string, text: string): string;
+export declare function readJsonFileOrStdin(filePath?: string): Promise<unknown>;

package/dist/lib/command-helpers.js

@@ -0,0 +1,94 @@
+/**
+ * Shared helpers for command actions.
+ * Resolves global options, creates API client, handles errors.
+ */
+import * as fs from "node:fs";
+import { resolveApiUrl, resolveToken } from "./auth.js";
+import { getAppUrl } from "../auth.js";
+import { ApiClient, ApiError } from "./api-client.js";
+import { outputError } from "./output.js";
+export function getGlobals(cmd) {
+    const opts = cmd.optsWithGlobals();
+    return {
+        token: opts.token,
+        apiUrl: opts.apiUrl,
+        dev: opts.dev,
+        json: opts.json ?? false,
+        quiet: opts.quiet ?? false,
+    };
+}
+/**
+ * Map errors to semantic exit codes.
+ * 0=success, 1=general, 2=usage/validation, 3=auth, 4=not found, 5=transient
+ */
+export function exitCodeFromError(err) {
+    if (err instanceof ApiError) {
+        if (err.status === 401 || err.status === 403)
+            return 3;
+        if (err.status === 404)
+            return 4;
+        if (err.status === 400 || err.status === 422)
+            return 2;
+        if (err.retryable)
+            return 5;
+    }
+    // Auth-related client errors (e.g. missing token)
+    if (err instanceof Error && /token|auth/i.test(err.message))
+        return 3;
+    return 1;
+}
+export async function createClient(globals) {
+    const apiUrl = resolveApiUrl(globals.apiUrl, globals.dev);
+    const token = await resolveToken(globals.token, apiUrl);
+    return new ApiClient({ apiUrl, token });
+}
+export async function withClient(cmd, fn) {
+    const globals = getGlobals(cmd);
+    try {
+        const client = await createClient(globals);
+        await fn(client, globals);
+    }
+    catch (err) {
+        outputError(err, globals.json);
+        process.exit(exitCodeFromError(err));
+    }
+}
+export function getWebUrl(globals, path) {
+    const base = globals.dev ? "http://localhost:3000" : getAppUrl();
+    return `${base}${path}`;
+}
+export function terminalLink(url, text) {
+    return `\x1b]8;;${url}\x07${text}\x1b]8;;\x07`;
+}
+export function readJsonFileOrStdin(filePath) {
+    if (filePath) {
+        let content;
+        try {
+            content = fs.readFileSync(filePath, "utf-8");
+        }
+        catch (e) {
+            return Promise.reject(new Error(`Cannot read file: ${filePath}`));
+        }
+        try {
+            return Promise.resolve(JSON.parse(content));
+        }
+        catch {
+            return Promise.reject(new Error(`Invalid JSON in file: ${filePath}`));
+        }
+    }
+    // Read from stdin
+    return new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", (chunk) => { data += chunk; });
+        process.stdin.on("end", () => {
+            try {
+                resolve(JSON.parse(data));
+            }
+            catch (e) {
+                reject(new Error("Invalid JSON from stdin"));
+            }
+        });
+        process.stdin.on("error", reject);
+    });
+}