@wisebotai/cli 0.2.0 → 0.2.1

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,511 @@
+#!/usr/bin/env node
+const proc = globalThis.process;
+/**
+ * WisebotAI CLI — apps/web APIs + optional workflow webhook trigger:
+ *   GET /api/v1/status, /api/v1/activity, …
+ *   POST {WISEBOT_WORKFLOW_TRIGGER_ORIGIN}/workflows/trigger — see docs/workflows/cli-and-sdk; full CLI: docs/wisebot-cli
+ *
+ * Env (dashboard API): WISEBOTAI_BASE_URL, WISEBOT_ACCESS_TOKEN (or WISE_KEY)
+ * Env (workflow trigger): WISEBOT_WORKFLOW_TRIGGER_ORIGIN, WISEBOT_WORKFLOW_SECRET
+ */
+function baseUrl() {
+    const raw = proc.env.WISEBOTAI_BASE_URL?.trim() ?? "";
+    if (!raw) {
+        console.error("Missing WISEBOTAI_BASE_URL (apps/web origin, e.g. http://localhost:3000)");
+        proc.exit(1);
+    }
+    return raw.replace(/\/$/, "");
+}
+function bearer() {
+    const t = proc.env.WISEBOT_ACCESS_TOKEN?.trim() ||
+        proc.env.WISE_KEY?.trim() ||
+        "";
+    if (!t) {
+        console.error("Missing WISEBOT_ACCESS_TOKEN or WISE_KEY (JWT or wb_live_… API key)");
+        proc.exit(1);
+    }
+    return t;
+}
+async function cmdStatus() {
+    const res = await fetch(`${baseUrl()}/api/v1/status`, {
+        headers: { Authorization: `Bearer ${bearer()}` },
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        console.error(text || res.statusText);
+        proc.exit(1);
+    }
+    const data = JSON.parse(text);
+    console.log(JSON.stringify(data, null, 2));
+}
+async function cmdAgentsList() {
+    const res = await fetch(`${baseUrl()}/api/v1/agents`, {
+        headers: { Authorization: `Bearer ${bearer()}` },
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        console.error(text || res.statusText);
+        proc.exit(1);
+    }
+    const data = JSON.parse(text);
+    console.log(JSON.stringify(data, null, 2));
+}
+async function cmdApiKeysList() {
+    const res = await fetch(`${baseUrl()}/api/v1/api-keys`, {
+        headers: { Authorization: `Bearer ${bearer()}` },
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        console.error(text || res.statusText);
+        proc.exit(1);
+    }
+    const data = JSON.parse(text);
+    console.log(JSON.stringify(data, null, 2));
+}
+async function cmdWebhooksList() {
+    const res = await fetch(`${baseUrl()}/api/v1/webhooks`, {
+        headers: { Authorization: `Bearer ${bearer()}` },
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        console.error(text || res.statusText);
+        proc.exit(1);
+    }
+    const data = JSON.parse(text);
+    console.log(JSON.stringify(data, null, 2));
+}
+async function cmdLogs(tail) {
+    if (!tail) {
+        console.error("Usage: wisebot logs --tail");
+        proc.exit(1);
+    }
+    const res = await fetch(`${baseUrl()}/api/v1/activity?limit=20`, {
+        headers: { Authorization: `Bearer ${bearer()}` },
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        console.error(text || res.statusText);
+        proc.exit(1);
+    }
+    const data = JSON.parse(text);
+    for (const line of data.lines ?? []) {
+        const ts = new Date(line.createdAt).toISOString();
+        const agent = line.agentName ? ` agent=${line.agentName}` : "";
+        console.log(`[${ts}] conversation=${line.conversationId} status=${line.status}${agent}`);
+    }
+}
+function workflowTriggerOrigin() {
+    const raw = proc.env.WISEBOT_WORKFLOW_TRIGGER_ORIGIN?.trim() ||
+        proc.env.WISEBOT_CONVEX_SITE?.trim() ||
+        proc.env.CONVEX_SITE_URL?.trim() ||
+        "";
+    if (!raw) {
+        console.error("Missing WISEBOT_WORKFLOW_TRIGGER_ORIGIN (HTTPS origin for workflow triggers, e.g. https://trigger.example.com)");
+        proc.exit(1);
+    }
+    return raw.replace(/\/$/, "");
+}
+function workflowWebhookSecret() {
+    const s = proc.env.WISEBOT_WORKFLOW_SECRET?.trim() || "";
+    if (!s) {
+        console.error("Missing WISEBOT_WORKFLOW_SECRET (from the workflow editor → webhook secret)");
+        proc.exit(1);
+    }
+    return s;
+}
+function playgroundJwt() {
+    const t = bearer();
+    if (t.startsWith("wb_live_")) {
+        console.error("Playground commands require a dashboard JWT (not wb_live_ API keys)");
+        proc.exit(1);
+    }
+    return t;
+}
+async function pgFetch(path, init) {
+    return fetch(`${baseUrl()}${path}`, {
+        ...init,
+        headers: {
+            Authorization: `Bearer ${playgroundJwt()}`,
+            ...(init?.headers ?? {}),
+        },
+    });
+}
+async function cmdPlaygroundSessionCreate(agentId, forceNew) {
+    const res = await pgFetch("/api/v1/playground/sessions", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            ...(agentId ? { agentId } : {}),
+            ...(forceNew ? { forceNew: true } : {}),
+        }),
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        console.error(text || res.statusText);
+        proc.exit(1);
+    }
+    console.log(JSON.stringify(JSON.parse(text), null, 2));
+}
+async function cmdPlaygroundSessionsList(agentId) {
+    const q = new URLSearchParams({ agentId });
+    const res = await pgFetch(`/api/v1/playground/sessions?${q}`);
+    const text = await res.text();
+    if (!res.ok) {
+        console.error(text || res.statusText);
+        proc.exit(1);
+    }
+    console.log(JSON.stringify(JSON.parse(text), null, 2));
+}
+async function cmdPlaygroundSessionResume(conversationId) {
+    const res = await pgFetch("/api/v1/playground/sessions/resume", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ conversationId }),
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        console.error(text || res.statusText);
+        proc.exit(1);
+    }
+    console.log(JSON.stringify(JSON.parse(text), null, 2));
+}
+async function cmdPlaygroundSend(conversationId, contactSessionId, message) {
+    const res = await pgFetch("/api/v1/playground/messages", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ conversationId, contactSessionId, message }),
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        console.error(text || res.statusText);
+        proc.exit(1);
+    }
+    console.log(JSON.stringify(JSON.parse(text), null, 2));
+}
+async function cmdPlaygroundWait(conversationId, timeoutSec) {
+    const deadline = Date.now() + timeoutSec * 1000;
+    while (Date.now() < deadline) {
+        const q = new URLSearchParams({ conversationId });
+        const res = await pgFetch(`/api/v1/playground/runs/latest?${q}`);
+        const text = await res.text();
+        if (!res.ok) {
+            console.error(text || res.statusText);
+            proc.exit(1);
+        }
+        const data = JSON.parse(text);
+        const status = data.run?.status ?? "";
+        if (status === "completed" ||
+            status === "completed_with_warnings" ||
+            status === "failed" ||
+            status === "stopped" ||
+            status === "needs_approval") {
+            console.log(JSON.stringify(data.run, null, 2));
+            return;
+        }
+        await new Promise((r) => setTimeout(r, 1000));
+    }
+    console.error(`Timed out after ${timeoutSec}s`);
+    proc.exit(1);
+}
+async function cmdPlaygroundApprovalsPending(runId) {
+    const q = new URLSearchParams({ runId });
+    const res = await pgFetch(`/api/v1/playground/approvals/pending?${q}`);
+    const text = await res.text();
+    if (!res.ok) {
+        console.error(text || res.statusText);
+        proc.exit(1);
+    }
+    console.log(JSON.stringify(JSON.parse(text), null, 2));
+}
+async function cmdPlaygroundApprove(approvalId) {
+    const res = await pgFetch(`/api/v1/playground/approvals/${encodeURIComponent(approvalId)}/approve`, { method: "POST" });
+    const text = await res.text();
+    if (!res.ok) {
+        console.error(text || res.statusText);
+        proc.exit(1);
+    }
+    console.log(JSON.stringify(JSON.parse(text), null, 2));
+}
+async function cmdPlaygroundDeny(approvalId) {
+    const res = await pgFetch(`/api/v1/playground/approvals/${encodeURIComponent(approvalId)}/deny`, { method: "POST" });
+    const text = await res.text();
+    if (!res.ok) {
+        console.error(text || res.statusText);
+        proc.exit(1);
+    }
+    console.log(JSON.stringify(JSON.parse(text), null, 2));
+}
+async function cmdPlaygroundStop(conversationId) {
+    const res = await pgFetch("/api/v1/playground/runs/stop", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ conversationId }),
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        console.error(text || res.statusText);
+        proc.exit(1);
+    }
+    console.log(JSON.stringify(JSON.parse(text), null, 2));
+}
+async function cmdPlaygroundMessages(threadId) {
+    const q = new URLSearchParams({ threadId });
+    const res = await pgFetch(`/api/v1/playground/messages?${q}`);
+    const text = await res.text();
+    if (!res.ok) {
+        console.error(text || res.statusText);
+        proc.exit(1);
+    }
+    console.log(JSON.stringify(JSON.parse(text), null, 2));
+}
+async function cmdPlaygroundTraces(runId) {
+    const res = await pgFetch(`/api/v1/playground/runs/${encodeURIComponent(runId)}/traces`);
+    const text = await res.text();
+    if (!res.ok) {
+        console.error(text || res.statusText);
+        proc.exit(1);
+    }
+    console.log(JSON.stringify(JSON.parse(text), null, 2));
+}
+async function cmdWorkflowTrigger(workflowId, body) {
+    const url = `${workflowTriggerOrigin()}/workflows/trigger?workflowId=${encodeURIComponent(workflowId)}`;
+    const res = await fetch(url, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${workflowWebhookSecret()}`,
+            ...(body ? { "Content-Type": "application/json" } : {}),
+        },
+        ...(body ? { body } : {}),
+    });
+    const text = await res.text();
+    try {
+        console.log(JSON.stringify(JSON.parse(text), null, 2));
+    }
+    catch {
+        console.log(text);
+    }
+    if (!res.ok) {
+        proc.exit(1);
+    }
+}
+function printHelp() {
+    console.log(`wisebot — WisebotAI CLI
+
+Environment (dashboard API):
+  WISEBOTAI_BASE_URL     apps/web origin (no path)
+  WISEBOT_ACCESS_TOKEN   dashboard JWT, org API key (wb_live_…), or WISE_KEY
+
+Environment (workflow webhook trigger — separate from dashboard token):
+  WISEBOT_WORKFLOW_TRIGGER_ORIGIN   HTTPS origin for POST /workflows/trigger (copy from workflow editor)
+  WISEBOT_WORKFLOW_SECRET           Secret from the workflow editor
+
+Commands:
+  wisebot status              Session + organization metrics (JWT or API key)
+  wisebot logs --tail         Recent conversations (JWT or API key)
+  wisebot agents list         List agents (JWT or API key)
+  wisebot api-keys list       List key metadata — requires dashboard JWT
+  wisebot webhooks list       List webhook endpoints — requires dashboard JWT
+  wisebot workflow trigger <workflowId> [--data '{"key":"value"}']
+                              POST to workflow trigger URL (env: origin + secret)
+
+Playground (dashboard JWT only — not wb_live_ API keys):
+  wisebot playground session create [--agent ID] [--force-new]
+  wisebot playground sessions list --agent ID
+  wisebot playground session resume --conversation ID
+  wisebot playground send --conversation ID --session ID --message "..."
+  wisebot playground wait --conversation ID [--timeout 120]
+  wisebot playground approvals pending --run ID
+  wisebot playground approve --id ID
+  wisebot playground deny --id ID
+  wisebot playground stop --conversation ID
+  wisebot playground messages --thread ID
+  wisebot playground traces --run ID
+
+For full observability, use the dashboard: Analytics and Conversations.`);
+}
+async function main() {
+    const argv = proc.argv.slice(2);
+    if (argv.length === 0 || argv[0] === "-h" || argv[0] === "--help") {
+        printHelp();
+        return;
+    }
+    const [cmd, ...rest] = argv;
+    if (cmd === "status") {
+        await cmdStatus();
+        return;
+    }
+    if (cmd === "logs" && rest[0] === "--tail") {
+        await cmdLogs(true);
+        return;
+    }
+    if (cmd === "agents" && rest[0] === "list") {
+        await cmdAgentsList();
+        return;
+    }
+    if (cmd === "api-keys" && rest[0] === "list") {
+        await cmdApiKeysList();
+        return;
+    }
+    if (cmd === "webhooks" && rest[0] === "list") {
+        await cmdWebhooksList();
+        return;
+    }
+    if (cmd === "workflow" && rest[0] === "trigger") {
+        const wfIdRaw = rest[1];
+        if (!wfIdRaw) {
+            console.error('Usage: wisebot workflow trigger <workflowId> [--data \'{"key":"value"}\']');
+            proc.exit(1);
+        }
+        const wfId = String(wfIdRaw);
+        const di = rest.indexOf("--data");
+        let jsonBody;
+        if (di >= 0) {
+            const raw = rest[di + 1];
+            if (!raw) {
+                console.error("wisebot workflow trigger: --data requires a JSON string");
+                proc.exit(1);
+            }
+            jsonBody = String(raw);
+            try {
+                JSON.parse(jsonBody);
+            }
+            catch {
+                console.error("wisebot workflow trigger: --data must be valid JSON");
+                proc.exit(1);
+            }
+        }
+        await cmdWorkflowTrigger(wfId, jsonBody);
+        return;
+    }
+    if (cmd === "playground") {
+        const sub = rest[0];
+        if (sub === "session" && rest[1] === "create") {
+            let agentId;
+            let forceNew = false;
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === "--agent" && rest[i + 1]) {
+                    agentId = rest[++i];
+                }
+                else if (rest[i] === "--force-new") {
+                    forceNew = true;
+                }
+            }
+            await cmdPlaygroundSessionCreate(agentId, forceNew);
+            return;
+        }
+        if (sub === "sessions" && rest[1] === "list") {
+            const ai = rest.indexOf("--agent");
+            const agentId = ai >= 0 ? rest[ai + 1] : undefined;
+            if (!agentId) {
+                console.error("Usage: wisebot playground sessions list --agent ID");
+                proc.exit(1);
+            }
+            await cmdPlaygroundSessionsList(String(agentId));
+            return;
+        }
+        if (sub === "session" && rest[1] === "resume") {
+            const ci = rest.indexOf("--conversation");
+            const conversationId = ci >= 0 ? rest[ci + 1] : undefined;
+            if (!conversationId) {
+                console.error("Usage: wisebot playground session resume --conversation ID");
+                proc.exit(1);
+            }
+            await cmdPlaygroundSessionResume(String(conversationId));
+            return;
+        }
+        if (sub === "send") {
+            const getFlag = (flag) => {
+                const i = rest.indexOf(flag);
+                return i >= 0 ? rest[i + 1] : undefined;
+            };
+            const conversationId = getFlag("--conversation");
+            const contactSessionId = getFlag("--session");
+            const message = getFlag("--message");
+            if (!conversationId || !contactSessionId || !message) {
+                console.error("Usage: wisebot playground send --conversation ID --session ID --message \"...\"");
+                proc.exit(1);
+            }
+            await cmdPlaygroundSend(String(conversationId), String(contactSessionId), String(message));
+            return;
+        }
+        if (sub === "wait") {
+            const ci = rest.indexOf("--conversation");
+            const conversationId = ci >= 0 ? rest[ci + 1] : undefined;
+            const ti = rest.indexOf("--timeout");
+            const timeout = ti >= 0 ? Number(rest[ti + 1]) : 120;
+            if (!conversationId) {
+                console.error("Usage: wisebot playground wait --conversation ID [--timeout 120]");
+                proc.exit(1);
+            }
+            await cmdPlaygroundWait(String(conversationId), Number.isFinite(timeout) ? timeout : 120);
+            return;
+        }
+        if (sub === "approvals" && rest[1] === "pending") {
+            const ri = rest.indexOf("--run");
+            const runId = ri >= 0 ? rest[ri + 1] : undefined;
+            if (!runId) {
+                console.error("Usage: wisebot playground approvals pending --run ID");
+                proc.exit(1);
+            }
+            await cmdPlaygroundApprovalsPending(String(runId));
+            return;
+        }
+        if (sub === "approve") {
+            const ii = rest.indexOf("--id");
+            const id = ii >= 0 ? rest[ii + 1] : undefined;
+            if (!id) {
+                console.error("Usage: wisebot playground approve --id ID");
+                proc.exit(1);
+            }
+            await cmdPlaygroundApprove(String(id));
+            return;
+        }
+        if (sub === "deny") {
+            const ii = rest.indexOf("--id");
+            const id = ii >= 0 ? rest[ii + 1] : undefined;
+            if (!id) {
+                console.error("Usage: wisebot playground deny --id ID");
+                proc.exit(1);
+            }
+            await cmdPlaygroundDeny(String(id));
+            return;
+        }
+        if (sub === "stop") {
+            const ci = rest.indexOf("--conversation");
+            const conversationId = ci >= 0 ? rest[ci + 1] : undefined;
+            if (!conversationId) {
+                console.error("Usage: wisebot playground stop --conversation ID");
+                proc.exit(1);
+            }
+            await cmdPlaygroundStop(String(conversationId));
+            return;
+        }
+        if (sub === "messages") {
+            const ti = rest.indexOf("--thread");
+            const threadId = ti >= 0 ? rest[ti + 1] : undefined;
+            if (!threadId) {
+                console.error("Usage: wisebot playground messages --thread ID");
+                proc.exit(1);
+            }
+            await cmdPlaygroundMessages(String(threadId));
+            return;
+        }
+        if (sub === "traces") {
+            const ri = rest.indexOf("--run");
+            const runId = ri >= 0 ? rest[ri + 1] : undefined;
+            if (!runId) {
+                console.error("Usage: wisebot playground traces --run ID");
+                proc.exit(1);
+            }
+            await cmdPlaygroundTraces(String(runId));
+            return;
+        }
+    }
+    printHelp();
+    proc.exit(1);
+}
+main().catch((e) => {
+    console.error(e instanceof Error ? e.message : e);
+    proc.exit(1);
+});
+export {};

package/package.json

@@ -1,26 +1,29 @@
-{
-  "name": "@wisebotai/cli",
-  "version": "0.2.0",
-  "description": "WisebotAI CLI (status + recent conversation activity)",
-  "type": "module",
-  "publishConfig": {
-    "access": "public"
-  },
-  "bin": {
-    "wisebot": "./dist/cli.js"
-  },
-  "files": ["dist"],
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "typecheck": "tsc --noEmit"
-  },
-  "devDependencies": {
-    "@types/node": "^20",
-    "@workspace/typescript-config": "workspace:*",
-    "typescript": "5.7.3"
-  },
-  "engines": {
-    "node": ">=20"
-  }
-}
+{
+  "name": "@wisebotai/cli",
+  "version": "0.2.1",
+  "description": "WisebotAI CLI (status + recent conversation activity)",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "wisebot": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "^20",
+    "typescript": "5.7.3",
+    "@workspace/typescript-config": "0.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc",
+    "postbuild": "chmod +x dist/cli.js",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}