@fulldivevr/workcord-cli 1.3.0 → 2.17.0

package/dist/commands/messages.js

@@ -1,5 +1,7 @@
+import { randomUUID } from "node:crypto";
 import { actingUserId } from "../auth.js";
 import { call } from "../client.js";
+import { parseDuration } from "./agent.js";
 import { getOrCreateGroup } from "./_group.js";
 const MAX_LIMIT = 500;
 const MAX_PAGE_LIMIT = 100;
@@ -102,21 +104,165 @@ async function resolveMentions(roomId, asUserId, userIds) {
         return { userId, name, type: "user" };
     });
 }
+async function resolveAgentMentions(roomId, asUserId, agentIds) {
+    if (agentIds.length === 0)
+        return [];
+    const res = (await call({
+        method: "GET",
+        path: `/api/v1/rooms/${encodeURIComponent(roomId)}/members`,
+        query: { limit: MEMBER_PAGE_LIMIT },
+        asUserId,
+    }));
+    const names = new Map();
+    for (const member of res.data ?? []) {
+        if (member.memberType !== "agent" || !member.agentId)
+            continue;
+        names.set(member.agentId, member.displayName || member.agentId);
+    }
+    return agentIds.map((agentId) => {
+        const name = names.get(agentId);
+        if (name === undefined)
+            throw new Error(`Agent ${agentId} is not installed in room ${roomId}`);
+        return { agentId, name };
+    });
+}
+export function mentionedText(names, text) {
+    return names.length > 0 ? `${names.map((name) => `@${name}`).join(" ")} ${text.trimStart()}` : text;
+}
+export function resolveAgentTarget(members, agentId) {
+    const agents = members.filter((member) => member.memberType === "agent" && member.agentId);
+    const matches = agents.filter((member) => member.agentId === agentId.trim());
+    if (matches.length === 0) {
+        throw new Error(`Agent ${agentId} is not installed or enabled in this room.`);
+    }
+    return {
+        agentId: matches[0].agentId,
+        name: matches[0].displayName || matches[0].agentId,
+    };
+}
+export function agentRequestText(agentName, text, requestId) {
+    const marker = `[request:${requestId}]`;
+    return mentionedText([agentName], `${marker} ${text.trim()}\n\nReply once in this room, address the requesting Assistant by name, and repeat ${marker}.`);
+}
+export function matchingAgentReply(message, requestMessageId, agentId) {
+    const candidate = record(message);
+    const metadata = record(candidate.metadata);
+    const state = typeof metadata.a2aState === "string" ? metadata.a2aState.toLowerCase() : "";
+    if (candidate.senderType !== "agent"
+        || candidate.agentId !== agentId
+        || metadata.replyTo !== requestMessageId
+        || state === "working"
+        || state === "submitted") {
+        return undefined;
+    }
+    return candidate;
+}
+export async function waitForAgentReply(input) {
+    const now = input.now ?? Date.now;
+    const sleep = input.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const deadline = now() + input.timeoutMs;
+    while (true) {
+        const reply = (await input.read())
+            .map((message) => matchingAgentReply(message, input.requestMessageId, input.agentId))
+            .find((message) => message !== undefined);
+        if (reply)
+            return { reply, timedOut: false };
+        const remaining = deadline - now();
+        if (remaining <= 0)
+            return { reply: null, timedOut: true };
+        await sleep(Math.min(input.pollIntervalMs ?? 1000, remaining));
+    }
+}
+function messageId(value) {
+    const id = record(value).id;
+    if (typeof id !== "string" || !id)
+        throw new Error("Sent message response did not contain an id.");
+    return id;
+}
+function messageSentAt(value) {
+    const sentAt = record(value).sentAt;
+    return typeof sentAt === "string" && !Number.isNaN(new Date(sentAt).getTime()) ? sentAt : undefined;
+}
 export function registerMessages(program) {
     const group = getOrCreateGroup(program, "messages", "Messages operations");
+    group
+        .command("ask-agent")
+        .description("Post one visible request to an installed room agent and wait for its visible correlated reply.")
+        .requiredOption("--room <roomId>", "target room id")
+        .requiredOption("--text <text>", "request for the agent")
+        .requiredOption("--agent <agentInstallationId>", "installed room-agent id returned by Home")
+        .option("--timeout <duration>", "maximum local wait, such as 30s or 5m", "2m")
+        .action(async (opts) => {
+        const as = actingUserId(program);
+        const text = opts.text.trim();
+        if (!text)
+            throw new Error("--text must not be blank.");
+        const timeoutMs = parseDuration(opts.timeout);
+        const members = (await call({
+            method: "GET",
+            path: `/api/v1/rooms/${encodeURIComponent(opts.room)}/members`,
+            query: { limit: MEMBER_PAGE_LIMIT },
+            asUserId: as,
+        }));
+        const target = resolveAgentTarget(members.data ?? [], opts.agent);
+        const requestId = randomUUID().replace(/-/g, "").slice(0, 8);
+        const content = agentRequestText(target.name, text, requestId);
+        const request = await call({
+            method: "POST",
+            path: `/api/v1/rooms/${encodeURIComponent(opts.room)}/messages`,
+            body: { content, type: "text" },
+            asUserId: as,
+        });
+        const requestMessageId = messageId(request);
+        const after = messageSentAt(request);
+        const result = await waitForAgentReply({
+            requestMessageId,
+            agentId: target.agentId,
+            timeoutMs,
+            read: async () => {
+                const [room, thread] = await Promise.all([
+                    call({
+                        method: "GET",
+                        path: `/api/v1/rooms/${encodeURIComponent(opts.room)}/messages`,
+                        query: { limit: MAX_PAGE_LIMIT, after },
+                        asUserId: as,
+                    }),
+                    call({
+                        method: "GET",
+                        path: `/api/v1/rooms/${encodeURIComponent(opts.room)}/messages/${encodeURIComponent(requestMessageId)}/thread`,
+                        query: { limit: MAX_PAGE_LIMIT },
+                        asUserId: as,
+                    }),
+                ]);
+                return [
+                    ...(Array.isArray(record(room).data) ? record(room).data : []),
+                    ...(Array.isArray(record(thread).data) ? record(thread).data : []),
+                ];
+            },
+        });
+        process.stdout.write(JSON.stringify({
+            roomId: opts.room,
+            requestId,
+            target,
+            request: { messageId: requestMessageId, content },
+            ...result,
+        }) + "\n");
+    });
     group
         .command("send-text")
-        .description("Send a text message to a room. Use --mention-user to mention members without exposing raw ids.")
+        .description("Send one text message to a room. Mention flags prepend visible @Name text; exclude those names from --text.")
         .requiredOption("--room <roomId>", "target room id")
-        .requiredOption("--text <text>", "message body")
+        .requiredOption("--text <text>", "message body after any mentions added by mention flags")
         .option("--reply-to <messageId>", "parent message id (for threaded replies)")
-        .option("--mention-user <userId>", "room member to mention by display name; repeatable", collect, [])
+        .option("--mention-user <userId>", "prepend the room member's visible @Name; repeatable", collect, [])
+        .option("--mention-agent <agentId>", "prepend the installed room agent's visible @Name; repeatable", collect, [])
         .option("--attachments <urls>", "comma-separated GCS URLs (use `workcord rooms upload-image-file` to get URLs first)")
         .option("--no-shadow-guidance", "do not opt in to Shadow guidance cards")
         .action(async (opts) => {
         const as = actingUserId(program);
         const mentions = await resolveMentions(opts.room, as, opts.mentionUser);
-        const content = mentions.length > 0 ? `${mentions.map((m) => `@${m.name}`).join(" ")} ${opts.text}` : opts.text;
+        const agentMentions = await resolveAgentMentions(opts.room, as, opts.mentionAgent);
+        const content = mentionedText([...mentions, ...agentMentions].map((mention) => mention.name), opts.text);
         const body = {
             content,
             type: "text",

package/dist/commands/reflections.js

@@ -0,0 +1,96 @@
+import { actingUserId } from "../auth.js";
+import { call } from "../client.js";
+import { getOrCreateGroup } from "./_group.js";
+function list(value) {
+    return value?.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function output(value) {
+    process.stdout.write(JSON.stringify(value) + "\n");
+}
+export function registerReflections(program) {
+    const group = getOrCreateGroup(program, "reflections", "Create and manage Shadow reflections");
+    group.command("list").action(async () => output(await call({
+        path: "/api/v1/shadow/reflections",
+        asUserId: actingUserId(program),
+    })));
+    group.command("get")
+        .requiredOption("--reflection <id>", "reflection id")
+        .action(async (opts) => output(await call({
+        path: `/api/v1/shadow/reflections/${encodeURIComponent(opts.reflection)}`,
+        asUserId: actingUserId(program),
+    })));
+    group.command("create")
+        .requiredOption("--name <name>", "reflection name")
+        .option("--description <text>", "short description")
+        .option("--style <text>", "response style")
+        .option("--topics <items>", "comma-separated allowed topics")
+        .option("--refusal-message <text>", "reply used outside allowed topics")
+        .option("--knowledge <text>", "knowledge content")
+        .option("--policy <text>", "policy content")
+        .option("--examples <text>", "examples content")
+        .action(async (opts) => {
+        const { topics, ...body } = opts;
+        output(await call({
+            method: "POST",
+            path: "/api/v1/shadow/reflections",
+            body: { ...body, ...(topics === undefined ? {} : { allowedTopics: list(topics) }) },
+            asUserId: actingUserId(program),
+        }));
+    });
+    group.command("update")
+        .requiredOption("--reflection <id>", "reflection id")
+        .option("--name <name>", "reflection name")
+        .option("--description <text>", "short description")
+        .option("--style <text>", "response style")
+        .option("--topics <items>", "comma-separated allowed topics")
+        .option("--refusal-message <text>", "reply used outside allowed topics")
+        .option("--knowledge <text>", "knowledge content")
+        .option("--policy <text>", "policy content")
+        .option("--examples <text>", "examples content")
+        .action(async (opts) => {
+        const { reflection, topics, ...body } = opts;
+        output(await call({
+            method: "PATCH",
+            path: `/api/v1/shadow/reflections/${encodeURIComponent(reflection)}`,
+            body: { ...body, ...(topics === undefined ? {} : { allowedTopics: list(topics) }) },
+            asUserId: actingUserId(program),
+        }));
+    });
+    group.command("activate")
+        .requiredOption("--reflection <id>", "reflection id")
+        .action(async (opts) => output(await call({
+        method: "POST",
+        path: `/api/v1/shadow/reflections/${encodeURIComponent(opts.reflection)}/activate`,
+        asUserId: actingUserId(program),
+    })));
+    group.command("install")
+        .requiredOption("--reflection <id>", "reflection id")
+        .requiredOption("--room <roomId>", "target room id")
+        .action(async (opts) => output(await call({
+        method: "POST",
+        path: `/api/v1/shadow/reflections/${encodeURIComponent(opts.reflection)}/install`,
+        body: { roomId: opts.room },
+        asUserId: actingUserId(program),
+    })));
+    group.command("set-price")
+        .requiredOption("--reflection <id>", "reflection id")
+        .requiredOption("--multiplier <n>", "price multiplier")
+        .option("--subsidy-daily-cap <n>", "daily subsidy cap in credits")
+        .action(async (opts) => output(await call({
+        method: "PATCH",
+        path: `/api/v1/shadow/reflections/${encodeURIComponent(opts.reflection)}/price`,
+        body: {
+            multiplier: Number(opts.multiplier),
+            ...(opts.subsidyDailyCap === undefined ? {} : { subsidyDailyCapCredits: Number(opts.subsidyDailyCap) }),
+        },
+        asUserId: actingUserId(program),
+    })));
+    group.command("delete")
+        .requiredOption("--reflection <id>", "reflection id")
+        .action(async (opts) => output(await call({
+        method: "DELETE",
+        path: `/api/v1/shadow/reflections/${encodeURIComponent(opts.reflection)}`,
+        asUserId: actingUserId(program),
+    })));
+}
+//# sourceMappingURL=reflections.js.map

package/dist/commands/rooms.js

@@ -124,13 +124,17 @@ function inviteResolution(inviteToken, room) {
         room: normalized,
     };
 }
-function applyRoomVisibility(body, opts) {
+export function applyRoomVisibility(body, opts) {
     if (opts.public && opts.private)
         throw new Error("Use either --public or --private, not both");
-    if (opts.public)
+    if (opts.public) {
         body.isPublic = true;
-    if (opts.private)
+        body.accessLevel = "open";
+    }
+    if (opts.private) {
         body.isPublic = false;
+        body.accessLevel = "inviteOnly";
+    }
 }
 function addRoomShapeOptions(command, opts = {}) {
     let withOptions = command;

package/dist/generated/commands/agent-feedback-admin.js

@@ -0,0 +1,69 @@
+import { call } from "../../client.js";
+import { actingUserId } from "../../auth.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "agent-feedback-admin", "AgentFeedbackAdmin operations");
+    if (!hasSubcommand(group, "list")) {
+        group
+            .command("list")
+            .description("GET /api/v1/admin/agent-feedback")
+            .option("--status <value>", "string")
+            .option("--agent-id <value>", "string")
+            .option("--hermes-tenant-id <value>", "string")
+            .option("--brand <value>", "string")
+            .option("--cursor <value>", "string")
+            .option("--limit <value>", "string")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/admin/agent-feedback`;
+            const query = {};
+            {
+                const v = opts.status;
+                if (v !== undefined)
+                    query["status"] = v;
+            }
+            {
+                const v = opts.agentId;
+                if (v !== undefined)
+                    query["agentId"] = v;
+            }
+            {
+                const v = opts.hermesTenantId;
+                if (v !== undefined)
+                    query["hermesTenantId"] = v;
+            }
+            {
+                const v = opts.brand;
+                if (v !== undefined)
+                    query["brand"] = v;
+            }
+            {
+                const v = opts.cursor;
+                if (v !== undefined)
+                    query["cursor"] = v;
+            }
+            {
+                const v = opts.limit;
+                if (v !== undefined)
+                    query["limit"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "update")) {
+        group
+            .command("update")
+            .description("PATCH /api/v1/admin/agent-feedback/{id}")
+            .requiredOption("--id <value>", "id (path param)")
+            .option("--body <json>", "request body as JSON (no schema available)")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/admin/agent-feedback/${encodeURIComponent(opts.id)}`;
+            const body = opts.body ? JSON.parse(opts.body) : undefined;
+            const data = await call({ method: "PATCH", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=agent-feedback-admin.js.map

package/dist/generated/commands/ai.js

@@ -9,6 +9,7 @@ export function register(program) {
             .description("POST /api/v1/rooms/{roomId}/ai/ask")
             .requiredOption("--room-id <value>", "roomId (path param)")
             .requiredOption("--query <value>", "string, ≤500 chars")
+            .option("--call-id <value>", "string, ≤64 chars")
             .action(async (opts) => {
             const as = actingUserId(program);
             const path = `/api/v1/rooms/${encodeURIComponent(opts.roomId)}/ai/ask`;
@@ -18,6 +19,36 @@ export function register(program) {
                 if (v !== undefined)
                     body["query"] = v;
             }
+            {
+                const v = opts.callId;
+                if (v !== undefined)
+                    body["callId"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "ask-shadow")) {
+        group
+            .command("ask-shadow")
+            .description("POST /api/v1/rooms/{roomId}/ai/ask-shadow")
+            .requiredOption("--room-id <value>", "roomId (path param)")
+            .requiredOption("--query <value>", "string, ≤500 chars")
+            .option("--call-id <value>", "string, ≤64 chars")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/rooms/${encodeURIComponent(opts.roomId)}/ai/ask-shadow`;
+            const body = {};
+            {
+                const v = opts.query;
+                if (v !== undefined)
+                    body["query"] = v;
+            }
+            {
+                const v = opts.callId;
+                if (v !== undefined)
+                    body["callId"] = v;
+            }
             const data = await call({ method: "POST", path, asUserId: as, body });
             process.stdout.write(JSON.stringify(data) + "\n");
         });

package/dist/generated/commands/call-recordings.js

@@ -15,6 +15,48 @@ export function register(program) {
             process.stdout.write(JSON.stringify(data) + "\n");
         });
     }
+    if (!hasSubcommand(group, "set-cues")) {
+        group
+            .command("set-cues")
+            .description("POST /api/v1/rooms/{roomId}/call/cues")
+            .requiredOption("--room-id <value>", "roomId (path param)")
+            .option("--body <json>", "request body as JSON (no schema available)")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/rooms/${encodeURIComponent(opts.roomId)}/call/cues`;
+            const body = opts.body ? JSON.parse(opts.body) : undefined;
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "set-voice-agent")) {
+        group
+            .command("set-voice-agent")
+            .description("POST /api/v1/rooms/{roomId}/call/voice-agent")
+            .requiredOption("--room-id <value>", "roomId (path param)")
+            .option("--body <json>", "request body as JSON (no schema available)")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/rooms/${encodeURIComponent(opts.roomId)}/call/voice-agent`;
+            const body = opts.body ? JSON.parse(opts.body) : undefined;
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "silence-voice-agent")) {
+        group
+            .command("silence-voice-agent")
+            .description("POST /api/v1/rooms/{roomId}/call/voice-agent/silence")
+            .requiredOption("--room-id <value>", "roomId (path param)")
+            .option("--body <json>", "request body as JSON (no schema available)")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/rooms/${encodeURIComponent(opts.roomId)}/call/voice-agent/silence`;
+            const body = opts.body ? JSON.parse(opts.body) : undefined;
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
     if (!hasSubcommand(group, "live-segments")) {
         group
             .command("live-segments")
@@ -59,5 +101,19 @@ export function register(program) {
             process.stdout.write(JSON.stringify(data) + "\n");
         });
     }
+    if (!hasSubcommand(group, "ask-cue-agent")) {
+        group
+            .command("ask-cue-agent")
+            .description("POST /api/v1/rooms/{roomId}/call/cues/ask")
+            .requiredOption("--room-id <value>", "roomId (path param)")
+            .option("--body <json>", "request body as JSON (no schema available)")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/rooms/${encodeURIComponent(opts.roomId)}/call/cues/ask`;
+            const body = opts.body ? JSON.parse(opts.body) : undefined;
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
 }
 //# sourceMappingURL=call-recordings.js.map

package/dist/generated/commands/contact-match.js

@@ -20,10 +20,29 @@ export function register(program) {
         group
             .command("list")
             .description("GET /api/v1/users/me/contacts")
+            .option("--limit <value>", "string")
+            .option("--cursor <value>", "string")
+            .option("--search <value>", "string")
             .action(async (opts) => {
             const as = actingUserId(program);
             const path = `/api/v1/users/me/contacts`;
-            const data = await call({ method: "GET", path, asUserId: as });
+            const query = {};
+            {
+                const v = opts.limit;
+                if (v !== undefined)
+                    query["limit"] = v;
+            }
+            {
+                const v = opts.cursor;
+                if (v !== undefined)
+                    query["cursor"] = v;
+            }
+            {
+                const v = opts.search;
+                if (v !== undefined)
+                    query["search"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
             process.stdout.write(JSON.stringify(data) + "\n");
         });
     }

package/dist/generated/commands/credit-packs.js

@@ -0,0 +1,112 @@
+import { call } from "../../client.js";
+import { actingUserId } from "../../auth.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "credit-packs", "CreditPacks operations");
+    if (!hasSubcommand(group, "list")) {
+        group
+            .command("list")
+            .description("GET /api/v1/credit-packs")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/credit-packs`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "verify-apple")) {
+        group
+            .command("verify-apple")
+            .description("POST /api/v1/credit-packs/apple/verify")
+            .requiredOption("--signed-transaction-jws <value>", "string")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/credit-packs/apple/verify`;
+            const body = {};
+            {
+                const v = opts.signedTransactionJws;
+                if (v !== undefined)
+                    body["signedTransactionJws"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "verify-google")) {
+        group
+            .command("verify-google")
+            .description("POST /api/v1/credit-packs/google/verify")
+            .requiredOption("--purchase-token <value>", "string")
+            .requiredOption("--product-id <value>", "string")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/credit-packs/google/verify`;
+            const body = {};
+            {
+                const v = opts.purchaseToken;
+                if (v !== undefined)
+                    body["purchaseToken"] = v;
+            }
+            {
+                const v = opts.productId;
+                if (v !== undefined)
+                    body["productId"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "create-stripe-checkout")) {
+        group
+            .command("create-stripe-checkout")
+            .description("POST /api/v1/credit-packs/stripe/checkout-session")
+            .requiredOption("--product-id <value>", "string")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/credit-packs/stripe/checkout-session`;
+            const body = {};
+            {
+                const v = opts.productId;
+                if (v !== undefined)
+                    body["productId"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "stripe-purchase")) {
+        group
+            .command("stripe-purchase")
+            .description("GET /api/v1/credit-packs/stripe/purchase/{sessionId}")
+            .requiredOption("--session-id <value>", "sessionId (path param)")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/credit-packs/stripe/purchase/${encodeURIComponent(opts.sessionId)}`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "success-page")) {
+        group
+            .command("success-page")
+            .description("GET /api/v1/credit-packs/success")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/credit-packs/success`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "cancel-page")) {
+        group
+            .command("cancel-page")
+            .description("GET /api/v1/credit-packs/cancel")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/credit-packs/cancel`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=credit-packs.js.map