@wabery/cli 0.1.1

package/dist/cli.js

@@ -0,0 +1,661 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { readFile, writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { platform } from "node:os";
+import { stdin } from "node:process";
+import { WaberyApiClient, WaberyApiError } from "./api-client.js";
+import { createExampleConfig } from "./config-example.js";
+import { checkWaberyConnection } from "./diagnostics.js";
+import { getConfigPath, writeLocalConfig } from "./local-config.js";
+import { runMcpServer } from "./mcp-server.js";
+async function main() {
+    const parsed = parseArgs(process.argv.slice(2));
+    const [command, subcommand, ...rest] = parsed.positionals;
+    if (!command ||
+        command === "help" ||
+        command === "--help" ||
+        command === "-h") {
+        printHelp();
+        return;
+    }
+    if (command === "config" &&
+        (subcommand === "example" || subcommand === "init")) {
+        await handleLocalConfig(subcommand, rest, parsed.flags);
+        return;
+    }
+    if (command === "login") {
+        await handleLogin(parsed.flags);
+        return;
+    }
+    if (command === "mcp-config") {
+        await handleMcpConfig(subcommand, parsed.flags);
+        return;
+    }
+    const client = new WaberyApiClient({
+        apiKey: stringFlag(parsed.flags, "api-key"),
+        baseUrl: stringFlag(parsed.flags, "base-url"),
+        apiVersion: stringFlag(parsed.flags, "api-version"),
+    });
+    if (command === "mcp") {
+        await runMcpServer(client);
+        return;
+    }
+    if (command === "doctor" || command === "check") {
+        await printJson(await checkWaberyConnection(client));
+        return;
+    }
+    if (command === "config") {
+        await handleConfig(client, subcommand, rest, parsed.flags);
+        return;
+    }
+    if (command === "projects") {
+        await handleProjects(client, subcommand, parsed.flags);
+        return;
+    }
+    if (command === "channels" && subcommand === "list") {
+        await printJson(await client.get("/channels"));
+        return;
+    }
+    if (command === "limits" && subcommand === "get") {
+        await printJson(await client.get("/limits"));
+        return;
+    }
+    if (command === "contacts") {
+        await handleContacts(client, subcommand, rest, parsed.flags);
+        return;
+    }
+    if (command === "conversations") {
+        await handleConversations(client, subcommand, rest, parsed.flags);
+        return;
+    }
+    if (command === "messages") {
+        await handleMessages(client, subcommand, parsed.flags);
+        return;
+    }
+    if (command === "templates") {
+        await handleTemplates(client, subcommand, rest, parsed.flags);
+        return;
+    }
+    if (command === "flows") {
+        await handleFlows(client, subcommand, rest, parsed.flags);
+        return;
+    }
+    if (command === "submissions" && subcommand === "list") {
+        await printJson(await client.get("/submissions", {
+            agent_id: stringFlag(parsed.flags, "agent-id"),
+            flow_id: stringFlag(parsed.flags, "flow-id"),
+            limit: numberFlag(parsed.flags, "limit"),
+            starting_after: stringFlag(parsed.flags, "starting-after"),
+        }));
+        return;
+    }
+    if (command === "dispatches") {
+        await handleDispatches(client, subcommand, rest, parsed.flags);
+        return;
+    }
+    throw new Error(`Unknown command: ${[command, subcommand].filter(Boolean).join(" ")}`);
+}
+async function handleConfig(client, subcommand, rest, flags) {
+    if (subcommand === "schema") {
+        await printJson(await client.get("/config/schema"));
+        return;
+    }
+    if (subcommand === "export") {
+        await printJson(await client.get("/config"));
+        return;
+    }
+    const config = await readJsonInput(rest[0] ?? stringFlag(flags, "file"));
+    if (subcommand === "validate") {
+        await printJson(await client.post("/config/validate", config));
+        return;
+    }
+    if (subcommand === "diff") {
+        await printJson(await client.post("/config/diff", config));
+        return;
+    }
+    if (subcommand === "apply") {
+        await printJson(await client.put("/config", config));
+        return;
+    }
+    throw new Error("Usage: wabery config schema|export|example|init|validate|diff|apply [wabery.config.json]");
+}
+async function handleLocalConfig(subcommand, rest, flags) {
+    if (subcommand === "example") {
+        await printJson(createExampleConfig(stringFlag(flags, "project-id")));
+        return;
+    }
+    const outputPath = rest[0] ?? stringFlag(flags, "file") ?? "wabery.config.json";
+    const config = createExampleConfig(stringFlag(flags, "project-id"));
+    await writeFile(outputPath, `${JSON.stringify(config, null, 2)}\n`, {
+        flag: booleanFlag(flags, "force") ? "w" : "wx",
+    });
+    await printJson({ object: "config_file", path: outputPath, config });
+}
+async function handleMcpConfig(client, flags) {
+    const target = client ?? stringFlag(flags, "client") ?? "claude";
+    const baseUrl = stringFlag(flags, "base-url") ??
+        process.env.WABERY_BASE_URL ??
+        "https://app.wabery.com";
+    if (stringFlag(flags, "api-key")) {
+        throw new Error("mcp-config does not embed raw API keys. Set WABERY_API_KEY in your shell or MCP client's secret storage instead.");
+    }
+    const apiKey = "wab_live_...";
+    const apiVersion = stringFlag(flags, "api-version");
+    const localBin = stringFlag(flags, "local-bin");
+    const command = localBin ? "node" : "wabery";
+    const args = localBin ? [localBin, "mcp"] : ["mcp"];
+    const env = {
+        WABERY_API_KEY: apiKey,
+        WABERY_BASE_URL: baseUrl,
+        ...(apiVersion ? { WABERY_API_VERSION: apiVersion } : {}),
+        ...(booleanFlag(flags, "write") ? { WABERY_MCP_MODE: "write" } : {}),
+    };
+    if (target === "claude") {
+        const config = { mcpServers: { wabery: { command, args, env } } };
+        if (booleanFlag(flags, "raw")) {
+            await printText(`${JSON.stringify(config, null, 2)}\n`);
+            return;
+        }
+        await printJson({
+            object: "mcp_config",
+            client: "claude",
+            format: "json",
+            config,
+        });
+        return;
+    }
+    if (target === "codex") {
+        const envToml = Object.entries(env)
+            .map(([key, value]) => `${key} = ${JSON.stringify(value)}`)
+            .join(", ");
+        const toml = `[mcp_servers.wabery]
+command = ${JSON.stringify(command)}
+args = ${JSON.stringify(args)}
+env = { ${envToml} }
+`;
+        if (booleanFlag(flags, "raw")) {
+            await printText(toml);
+            return;
+        }
+        await printJson({
+            object: "mcp_config",
+            client: "codex",
+            format: "toml",
+            config: toml,
+        });
+        return;
+    }
+    if (target === "opencode") {
+        const config = {
+            $schema: "https://opencode.ai/config.json",
+            mcp: {
+                wabery: {
+                    type: "local",
+                    command: [command, ...args],
+                    enabled: true,
+                    environment: env,
+                },
+            },
+        };
+        if (booleanFlag(flags, "raw")) {
+            await printText(`${JSON.stringify(config, null, 2)}\n`);
+            return;
+        }
+        await printJson({
+            object: "mcp_config",
+            client: "opencode",
+            format: "json",
+            config,
+        });
+        return;
+    }
+    throw new Error("Usage: wabery mcp-config claude|codex|opencode [--local-bin <path>]");
+}
+async function handleLogin(flags) {
+    const baseUrl = normalizeAppBaseUrl(stringFlag(flags, "base-url") ??
+        process.env.WABERY_BASE_URL ??
+        "https://app.wabery.com");
+    const state = randomBytes(32).toString("base64url");
+    const login = await waitForBrowserLogin({
+        baseUrl,
+        state,
+        openBrowser: booleanFlag(flags, "no-open") !== true,
+    });
+    const configPath = writeLocalConfig({
+        apiKey: login.apiKey,
+        baseUrl: login.baseUrl,
+    });
+    await printText(`Logged in to Wabery. Credentials saved to ${configPath}\n`);
+}
+async function waitForBrowserLogin({ baseUrl, state, openBrowser, }) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const timeout = setTimeout(() => {
+            finish(new Error("Timed out waiting for browser login."));
+        }, 5 * 60 * 1000);
+        const server = createServer(async (req, res) => {
+            const requestUrl = new URL(req.url ?? "/", "http://127.0.0.1");
+            if (requestUrl.pathname !== "/callback") {
+                res.writeHead(404, { "content-type": "text/plain" });
+                res.end("Not found");
+                return;
+            }
+            if (req.method !== "POST") {
+                res.writeHead(405, { "content-type": "text/plain" });
+                res.end("Method not allowed");
+                return;
+            }
+            try {
+                const body = await readRequestBody(req);
+                const form = new URLSearchParams(body);
+                const returnedState = form.get("state");
+                const apiKey = form.get("api_key");
+                const returnedBaseUrl = form.get("base_url") ?? baseUrl;
+                if (returnedState !== state) {
+                    throw new Error("Login state mismatch. Run `wabery login` again.");
+                }
+                if (!apiKey?.startsWith("wab_live_")) {
+                    throw new Error("Login response did not include a valid API key.");
+                }
+                res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+                res.end("<!doctype html><html><body><h1>Wabery CLI authorized</h1><p>You can close this window and return to your terminal.</p></body></html>");
+                finish(null, {
+                    apiKey,
+                    baseUrl: normalizeAppBaseUrl(returnedBaseUrl),
+                });
+            }
+            catch (error) {
+                res.writeHead(400, { "content-type": "text/plain" });
+                res.end(error instanceof Error ? error.message : "Login failed");
+                finish(error instanceof Error ? error : new Error("Login failed"));
+            }
+        });
+        function finish(error, result) {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            server.close();
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(result);
+        }
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            const callback = `http://127.0.0.1:${address.port}/callback`;
+            const loginUrl = new URL("/cli/login", baseUrl);
+            loginUrl.searchParams.set("callback", callback);
+            loginUrl.searchParams.set("state", state);
+            loginUrl.searchParams.set("base_url", baseUrl);
+            process.stdout.write(`Opening ${loginUrl.toString()}\n`);
+            if (!openBrowser || !openUrl(loginUrl.toString())) {
+                process.stdout.write(`Open this URL in your browser to continue:\n${loginUrl.toString()}\n`);
+            }
+        });
+        server.on("error", (error) => finish(error));
+    });
+}
+async function readRequestBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        if (Buffer.concat(chunks).length > 16 * 1024) {
+            throw new Error("Login response was too large.");
+        }
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+function openUrl(url) {
+    const currentPlatform = platform();
+    const command = currentPlatform === "darwin"
+        ? "open"
+        : currentPlatform === "win32"
+            ? "cmd"
+            : "xdg-open";
+    const args = currentPlatform === "win32" ? ["/c", "start", "", url] : [url];
+    try {
+        const child = spawn(command, args, {
+            detached: true,
+            stdio: "ignore",
+        });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeAppBaseUrl(value) {
+    return value.replace(/\/api\/v1\/?$/, "").replace(/\/+$/, "");
+}
+async function handleProjects(client, subcommand, flags) {
+    if (subcommand === "list") {
+        await printJson(await client.get("/projects"));
+        return;
+    }
+    if (subcommand === "create") {
+        await printJson(await client.post("/projects", {
+            name: requiredStringFlag(flags, "name"),
+            description: stringFlag(flags, "description"),
+            webhook_url: stringFlag(flags, "webhook-url"),
+            webhook_signing_enabled: booleanFlag(flags, "webhook-signing-enabled") ?? true,
+        }));
+        return;
+    }
+    throw new Error("Usage: wabery projects list|create --name <name>");
+}
+async function handleContacts(client, subcommand, rest, flags) {
+    if (subcommand === "list") {
+        await printJson(await client.get("/contacts", {
+            limit: numberFlag(flags, "limit"),
+            starting_after: stringFlag(flags, "starting-after"),
+        }));
+        return;
+    }
+    if (subcommand === "get") {
+        const contactId = rest[0] ?? stringFlag(flags, "contact-id");
+        await printJson(await client.get(`/contacts/${requiredValue(contactId, "contact-id")}`));
+        return;
+    }
+    if (subcommand === "enroll") {
+        await printJson(await client.post("/contacts", {
+            phone: requiredStringFlag(flags, "phone"),
+            project_id: requiredStringFlag(flags, "project-id"),
+            name: stringFlag(flags, "name"),
+            reference_id: stringFlag(flags, "reference-id"),
+            metadata: optionalJsonFlag(flags, "metadata"),
+            opt_in: optionalJsonFlag(flags, "opt-in"),
+        }));
+        return;
+    }
+    if (subcommand === "unenroll" || subcommand === "delete") {
+        const contactId = rest[0] ?? stringFlag(flags, "contact-id");
+        const erase = booleanFlag(flags, "erase");
+        await printJson(await client.delete(`/contacts/${requiredValue(contactId, "contact-id")}${erase ? "?erase=true" : ""}`));
+        return;
+    }
+    throw new Error("Usage: wabery contacts list|get|enroll|unenroll --phone <phone> --project-id <id>");
+}
+async function handleConversations(client, subcommand, rest, flags) {
+    if (subcommand === "list") {
+        await printJson(await client.get("/conversations", {
+            contact_id: stringFlag(flags, "contact-id"),
+            active: stringFlag(flags, "active"),
+            limit: numberFlag(flags, "limit"),
+            starting_after: stringFlag(flags, "starting-after"),
+        }));
+        return;
+    }
+    const conversationId = rest[0] ?? stringFlag(flags, "conversation-id");
+    if (subcommand === "get") {
+        await printJson(await client.get(`/conversations/${requiredValue(conversationId, "conversation-id")}`));
+        return;
+    }
+    if (subcommand === "messages") {
+        await printJson(await client.get(`/conversations/${requiredValue(conversationId, "conversation-id")}/messages`, {
+            limit: numberFlag(flags, "limit"),
+            starting_after: stringFlag(flags, "starting-after"),
+            order: stringFlag(flags, "order"),
+        }));
+        return;
+    }
+    throw new Error("Usage: wabery conversations list|get|messages <conversation_id>");
+}
+async function handleMessages(client, subcommand, flags) {
+    if (subcommand === "send") {
+        const body = optionalJsonFlag(flags, "body") ??
+            {
+                channel_id: requiredStringFlag(flags, "channel-id"),
+                conversation_id: stringFlag(flags, "conversation-id"),
+                to: stringFlag(flags, "to"),
+                text: stringFlag(flags, "text"),
+                template: optionalJsonFlag(flags, "template"),
+                media: optionalJsonFlag(flags, "media"),
+                interactive: optionalJsonFlag(flags, "interactive"),
+                idempotency_key: stringFlag(flags, "idempotency-key"),
+            };
+        await printJson(await client.post("/messages", body));
+        return;
+    }
+    throw new Error("Usage: wabery messages send --body '<json>'");
+}
+async function handleTemplates(client, subcommand, rest, flags) {
+    if (subcommand === "list") {
+        await printJson(await client.get("/templates", {
+            channel_id: stringFlag(flags, "channel-id"),
+            status: stringFlag(flags, "status"),
+        }));
+        return;
+    }
+    const templateId = rest[0] ?? stringFlag(flags, "template-id");
+    if (subcommand === "get") {
+        await printJson(await client.get(`/templates/${requiredValue(templateId, "template-id")}`));
+        return;
+    }
+    if (subcommand === "create") {
+        const body = optionalJsonFlag(flags, "body") ??
+            {
+                channel_id: requiredStringFlag(flags, "channel-id"),
+                name: requiredStringFlag(flags, "name"),
+                language: requiredStringFlag(flags, "language"),
+                category: requiredStringFlag(flags, "category"),
+                components: optionalJsonFlag(flags, "components"),
+            };
+        await printJson(await client.post("/templates", body));
+        return;
+    }
+    throw new Error("Usage: wabery templates list|get|create");
+}
+async function handleFlows(client, subcommand, rest, flags) {
+    if (subcommand === "list") {
+        await printJson(await client.get("/flows"));
+        return;
+    }
+    const flowId = rest[0] ?? stringFlag(flags, "flow-id");
+    if (subcommand === "get") {
+        await printJson(await client.get(`/flows/${requiredValue(flowId, "flow-id")}`));
+        return;
+    }
+    if (subcommand === "publish") {
+        await printJson(await client.post(`/flows/${requiredValue(flowId, "flow-id")}/publish`));
+        return;
+    }
+    if (subcommand === "send") {
+        await printJson(await client.post(`/flows/${requiredValue(flowId, "flow-id")}/send`, {
+            channel_id: requiredStringFlag(flags, "channel-id"),
+            contact_id: stringFlag(flags, "contact-id"),
+            conversation_id: stringFlag(flags, "conversation-id"),
+            to: stringFlag(flags, "to"),
+            flow_cta: stringFlag(flags, "flow-cta"),
+            body_text: stringFlag(flags, "body-text"),
+            header_text: stringFlag(flags, "header-text"),
+            footer_text: stringFlag(flags, "footer-text"),
+            first_screen: stringFlag(flags, "first-screen"),
+            screen_data: optionalJsonFlag(flags, "screen-data"),
+        }));
+        return;
+    }
+    throw new Error("Usage: wabery flows list|get|publish|send");
+}
+async function handleDispatches(client, subcommand, rest, flags) {
+    if (subcommand === "list") {
+        await printJson(await client.get("/dispatches", {
+            flow_id: stringFlag(flags, "flow-id"),
+            contact_id: stringFlag(flags, "contact-id"),
+            status: stringFlag(flags, "status"),
+            limit: numberFlag(flags, "limit"),
+            starting_after: stringFlag(flags, "starting-after"),
+        }));
+        return;
+    }
+    if (subcommand === "get") {
+        const flowToken = rest[0] ?? stringFlag(flags, "flow-token");
+        await printJson(await client.get(`/dispatches/${requiredValue(flowToken, "flow-token")}`));
+        return;
+    }
+    throw new Error("Usage: wabery dispatches list|get <flow_token>");
+}
+function parseArgs(args) {
+    const positionals = [];
+    const flags = {};
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        if (!arg.startsWith("--")) {
+            positionals.push(arg);
+            continue;
+        }
+        const [rawKey, inlineValue] = arg.slice(2).split("=", 2);
+        if (inlineValue !== undefined) {
+            flags[rawKey] = inlineValue;
+            continue;
+        }
+        const next = args[index + 1];
+        if (!next || next.startsWith("--")) {
+            flags[rawKey] = true;
+            continue;
+        }
+        flags[rawKey] = next;
+        index++;
+    }
+    return { positionals, flags };
+}
+async function readJsonInput(path) {
+    if (!path || path === "-") {
+        return JSON.parse(await readStdin());
+    }
+    return JSON.parse(await readFile(path, "utf8"));
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+function stringFlag(flags, key) {
+    const value = flags[key];
+    return typeof value === "string" ? value : undefined;
+}
+function requiredStringFlag(flags, key) {
+    return requiredValue(stringFlag(flags, key), key);
+}
+function numberFlag(flags, key) {
+    const value = stringFlag(flags, key);
+    return value ? Number(value) : undefined;
+}
+function booleanFlag(flags, key) {
+    const value = flags[key];
+    if (typeof value === "boolean")
+        return value;
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    return undefined;
+}
+function optionalJsonFlag(flags, key) {
+    const value = stringFlag(flags, key);
+    return value ? JSON.parse(value) : undefined;
+}
+function requiredValue(value, name) {
+    if (!value)
+        throw new Error(`Missing required --${name}`);
+    return value;
+}
+async function printJson(data) {
+    process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
+async function printText(text) {
+    process.stdout.write(text);
+}
+function shouldPrintDebugErrors() {
+    return process.env.WABERY_DEBUG === "1" || process.argv.includes("--debug");
+}
+function redactSensitive(value) {
+    if (Array.isArray(value))
+        return value.map(redactSensitive);
+    if (!value || typeof value !== "object")
+        return value;
+    const sensitivePattern = /(authorization|api[-_]?key|token|secret|signature|phone|from|to|email|webhook|payload|submission)/i;
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+        key,
+        sensitivePattern.test(key) ? "[REDACTED]" : redactSensitive(entry),
+    ]));
+}
+function printHelp() {
+    process.stdout.write(`Wabery CLI and MCP server
+
+Environment:
+  WABERY_API_KEY       API key override. Defaults to wabery login config.
+  WABERY_BASE_URL      Defaults to https://app.wabery.com.
+  WABERY_API_VERSION   Optional dated API version.
+
+Global flags:
+  --api-key <key>      Override WABERY_API_KEY.
+  --base-url <url>     Override WABERY_BASE_URL.
+  --api-version <ver>  Override WABERY_API_VERSION.
+
+Authentication:
+  wabery login
+  wabery login --no-open
+  Config file: ${getConfigPath()}
+
+MCP:
+  wabery mcp
+  wabery mcp-config claude [--write]
+  wabery mcp-config codex [--write]
+  wabery mcp-config opencode [--write]
+  wabery mcp-config claude --local-bin /path/to/dist/cli.js
+
+Diagnostics:
+  wabery doctor
+
+Config:
+  wabery config schema
+  wabery config export
+  wabery config example --project-id <project_id>
+  wabery config init wabery.config.json --project-id <project_id>
+  wabery config validate wabery.config.json
+  wabery config diff wabery.config.json
+  wabery config apply wabery.config.json
+
+Projects and contacts:
+  wabery projects list
+  wabery projects create --name "Demo"
+  wabery contacts enroll --project-id <id> --phone +15555550123 --name "Jane" --opt-in '{"source":"checkout"}'
+  wabery contacts get <contact_id>
+  wabery contacts unenroll <contact_id>
+  wabery contacts delete <contact_id> --erase
+  wabery contacts list
+
+Templates, messages, and conversations:
+  wabery templates list --channel-id <id>
+  wabery templates create --body '<json>'
+  wabery messages send --body '<json>'
+  wabery conversations list
+  wabery conversations messages <conversation_id>
+  wabery limits get
+
+Flows:
+  wabery flows list
+  wabery flows get <flow_id>
+  wabery flows publish <flow_id>
+  wabery flows send <flow_id> --channel-id <id> --contact-id <contact_id>
+`);
+}
+main().catch((error) => {
+    if (error instanceof WaberyApiError) {
+        const body = shouldPrintDebugErrors()
+            ? error.body
+            : redactSensitive(error.body);
+        process.stderr.write(`Wabery API error (${error.status}): ${error.message}\n${JSON.stringify(body, null, 2)}\n`);
+        process.exit(1);
+    }
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map