@fulldivevr/workcord-cli 1.0.0

package/dist/commands/challenges.js

@@ -0,0 +1,51 @@
+import { call } from "../client.js";
+import { getOrCreateGroup } from "./_group.js";
+function currentUser(program) {
+    const { as } = program.opts();
+    if (!as)
+        throw new Error("--as <userId> is required");
+    return as;
+}
+/**
+ * Custom challenge commands that are NOT covered by the OpenAPI-generated
+ * commands (src/generated/commands/challenges.ts). Everything else — create,
+ * list, leaderboard, close, regenerate-image, delete, etc. — comes from the
+ * generated group and uses its option names (--room-id, --id, …), so we must
+ * NOT redefine those here or they'll diverge from what the API expects.
+ *
+ * This is registered AFTER the generated commands so it only fills the gap.
+ */
+export function registerChallenges(program) {
+    const group = getOrCreateGroup(program, "challenges", "Challenge operations");
+    group
+        .command("regenerate-cards")
+        .description("Regenerate share cards for every participant of a challenge.")
+        .requiredOption("--id <challengeId>", "challenge ID")
+        .action(async (opts) => {
+        let offset = 0;
+        const totals = {
+            total: 0,
+            regenerated: 0,
+            failed: 0,
+            failures: [],
+        };
+        // Server hard-caps the chunk at 10 (CPU-bound resvg + sharp).
+        while (true) {
+            const data = (await call({
+                method: "POST",
+                path: `/api/v1/challenges/${encodeURIComponent(opts.id)}/regenerate-cards?offset=${offset}&limit=10`,
+                asUserId: currentUser(program),
+                body: {},
+            }));
+            totals.total = data.total;
+            totals.regenerated += data.regenerated;
+            totals.failed += data.failed;
+            totals.failures.push(...data.failures);
+            if (data.nextOffset === null)
+                break;
+            offset = data.nextOffset;
+        }
+        process.stdout.write(JSON.stringify(totals) + "\n");
+    });
+}
+//# sourceMappingURL=challenges.js.map

package/dist/commands/custom-agents.js

@@ -0,0 +1,120 @@
+import { readFileSync } from "node:fs";
+import { call } from "../client.js";
+import { getOrCreateGroup } from "./_group.js";
+function currentUser(program) {
+    const { as } = program.opts();
+    if (!as)
+        throw new Error("--as <userId> is required");
+    return as;
+}
+function bool(v, name) {
+    if (v === undefined)
+        return undefined;
+    if (v === "true")
+        return true;
+    if (v === "false")
+        return false;
+    throw new Error(`${name} must be true or false`);
+}
+function list(v) {
+    return v?.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function maybeNumber(v, name) {
+    if (v === undefined)
+        return undefined;
+    const n = Number(v);
+    if (!Number.isFinite(n) || n < 0 || n > 2) {
+        throw new Error(`${name} must be a number from 0 to 2`);
+    }
+    return n;
+}
+function promptFrom(opts) {
+    if (opts.prompt && opts.promptFile)
+        throw new Error("Use either --prompt or --prompt-file, not both");
+    return opts.promptFile ? readFileSync(opts.promptFile, "utf8") : opts.prompt;
+}
+export function registerCustomAgents(program) {
+    const group = getOrCreateGroup(program, "custom-agents", "CustomAgents operations");
+    group
+        .command("create-hosted")
+        .description("Create a WorkCord-hosted custom agent with typed flags.")
+        .requiredOption("--name <name>", "agent name")
+        .requiredOption("--description <text>", "short description")
+        .option("--prompt <text>", "system prompt")
+        .option("--prompt-file <path>", "read system prompt from a local file")
+        .option("--model <model>", "model id", "x-ai/grok-4-fast")
+        .option("--temperature <n>", "temperature", "0.4")
+        .option("--tools <items>", "comma-separated tools, e.g. web_search,image_gen")
+        .option("--category <category>", "marketplace category", "other")
+        .option("--published <true|false>", "publish to marketplace", "false")
+        .option("--rich-card-output <true|false>", "render URLs as rich cards", "true")
+        .action(async (opts) => {
+        const systemPrompt = promptFrom(opts) ?? "";
+        const temperature = maybeNumber(opts.temperature, "--temperature");
+        const data = await call({
+            method: "POST",
+            path: "/api/v1/agents",
+            asUserId: currentUser(program),
+            body: {
+                name: opts.name,
+                description: opts.description,
+                model: opts.model,
+                systemPrompt,
+                temperature,
+                enabledTools: list(opts.tools) ?? [],
+                category: opts.category,
+                isPublished: bool(opts.published, "--published"),
+                richCardOutput: bool(opts.richCardOutput, "--rich-card-output"),
+            },
+        });
+        process.stdout.write(JSON.stringify(data) + "\n");
+    });
+    group
+        .command("update-hosted")
+        .description("Update a WorkCord-hosted custom agent with typed flags.")
+        .requiredOption("--agent <agentId>", "hosted custom agent id")
+        .option("--name <name>", "agent name")
+        .option("--description <text>", "short description")
+        .option("--prompt <text>", "system prompt")
+        .option("--prompt-file <path>", "read system prompt from a local file")
+        .option("--model <model>", "model id")
+        .option("--temperature <n>", "temperature")
+        .option("--tools <items>", "comma-separated tools, e.g. web_search,image_gen")
+        .option("--category <category>", "marketplace category")
+        .option("--published <true|false>", "publish to marketplace")
+        .option("--rich-card-output <true|false>", "render URLs as rich cards")
+        .action(async (opts) => {
+        const body = {};
+        if (opts.name !== undefined)
+            body.name = opts.name;
+        if (opts.description !== undefined)
+            body.description = opts.description;
+        const systemPrompt = promptFrom(opts);
+        if (systemPrompt !== undefined)
+            body.systemPrompt = systemPrompt;
+        if (opts.model !== undefined)
+            body.model = opts.model;
+        const temperature = maybeNumber(opts.temperature, "--temperature");
+        if (temperature !== undefined)
+            body.temperature = temperature;
+        const enabledTools = list(opts.tools);
+        if (enabledTools !== undefined)
+            body.enabledTools = enabledTools;
+        if (opts.category !== undefined)
+            body.category = opts.category;
+        const isPublished = bool(opts.published, "--published");
+        if (isPublished !== undefined)
+            body.isPublished = isPublished;
+        const richCardOutput = bool(opts.richCardOutput, "--rich-card-output");
+        if (richCardOutput !== undefined)
+            body.richCardOutput = richCardOutput;
+        const data = await call({
+            method: "PATCH",
+            path: `/api/v1/agents/${encodeURIComponent(opts.agent)}`,
+            asUserId: currentUser(program),
+            body,
+        });
+        process.stdout.write(JSON.stringify(data) + "\n");
+    });
+}
+//# sourceMappingURL=custom-agents.js.map

package/dist/commands/dm.js

@@ -0,0 +1,35 @@
+import { call } from "../client.js";
+import { getOrCreateGroup } from "./_group.js";
+export function registerDm(program) {
+    const group = getOrCreateGroup(program, "dm", "Dm operations");
+    group
+        .command("send-text")
+        .description("Open or get a DM with --to <userId>, then send --text. Composite of dm/start + messages send. " +
+        "Returns { dm, message }.")
+        .requiredOption("--to <userId>", "the other user")
+        .requiredOption("--text <text>", "message body — mention users with @userId inline")
+        .option("--reply-to <messageId>", "parent message id (for threaded replies)")
+        .action(async (opts) => {
+        const { as } = program.opts();
+        if (!as)
+            throw new Error("--as <userId> is required");
+        const dm = (await call({
+            method: "POST",
+            path: "/api/v1/dm/start",
+            body: { targetUserId: opts.to },
+            asUserId: as,
+        }));
+        const roomId = dm?.id ?? dm?.roomId;
+        if (!roomId) {
+            throw new Error(`dm/start did not return a room id: ${JSON.stringify(dm)}`);
+        }
+        const message = await call({
+            method: "POST",
+            path: `/api/v1/rooms/${encodeURIComponent(roomId)}/messages`,
+            body: { content: opts.text, type: "text", replyToId: opts.replyTo },
+            asUserId: as,
+        });
+        process.stdout.write(JSON.stringify({ dm, message }) + "\n");
+    });
+}
+//# sourceMappingURL=dm.js.map

package/dist/commands/messages.js

@@ -0,0 +1,360 @@
+import { call } from "../client.js";
+import { getOrCreateGroup } from "./_group.js";
+const MAX_LIMIT = 500;
+const MAX_PAGE_LIMIT = 100;
+const MESSAGE_FILTERS = new Set(["pinned", "myMessages", "allDiscussions", "myThreads", "myDiscussions"]);
+function parseMessageFilter(v) {
+    if (v === undefined)
+        return undefined;
+    if (!MESSAGE_FILTERS.has(v)) {
+        throw new Error(`--filter must be one of: ${Array.from(MESSAGE_FILTERS).join(", ")}`);
+    }
+    return v;
+}
+function parseIsoOrThrow(v, name) {
+    if (v === undefined)
+        return undefined;
+    if (Number.isNaN(new Date(v).getTime()))
+        throw new Error(`${name} not a valid ISO timestamp: ${v}`);
+    return v;
+}
+function collect(value, previous = []) {
+    previous.push(value);
+    return previous;
+}
+function parsePositiveInt(value, name, max) {
+    const n = Number(value);
+    if (!Number.isInteger(n) || n < 1 || n > max) {
+        throw new Error(`${name} must be an integer from 1 to ${max}`);
+    }
+    return n;
+}
+function parseSince(value) {
+    if (value === undefined)
+        return undefined;
+    const ms = new Date(value).getTime();
+    if (Number.isNaN(ms))
+        throw new Error(`--since not a valid ISO timestamp: ${value}`);
+    return ms;
+}
+function record(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function roomId(room) {
+    const r = record(room);
+    const id = r.id ?? r.roomId;
+    return typeof id === "string" ? id : undefined;
+}
+function roomSummary(room) {
+    const r = record(room);
+    const id = roomId(room) ?? null;
+    return {
+        id,
+        roomId: id,
+        name: r.name ?? r.roomName ?? null,
+        type: r.type ?? null,
+        isPublic: r.isPublic ?? null,
+        inboxCategory: r.inboxCategory ?? null,
+        lastActivity: r.lastActivity ?? null,
+        unreadCount: r.unreadCount ?? null,
+    };
+}
+function sentAtMs(message) {
+    const sentAt = record(message).sentAt;
+    if (typeof sentAt !== "string")
+        return 0;
+    const ms = new Date(sentAt).getTime();
+    return Number.isNaN(ms) ? 0 : ms;
+}
+const MEMBER_PAGE_LIMIT = 500;
+const MAX_MEMBER_PAGES = 20;
+// The members endpoint's ?query= searches displayName only, so a userId lookup
+// has to walk the cursor. Room agents are appended to page 1 with a synthetic
+// `agent-<id>` userId and are not mentionable as users.
+async function resolveMentions(roomId, asUserId, userIds) {
+    if (userIds.length === 0)
+        return [];
+    const wanted = new Set(userIds);
+    const found = new Map();
+    let cursor;
+    for (let page = 0; page < MAX_MEMBER_PAGES && found.size < wanted.size; page++) {
+        const res = (await call({
+            method: "GET",
+            path: `/api/v1/rooms/${encodeURIComponent(roomId)}/members`,
+            query: { limit: MEMBER_PAGE_LIMIT, cursor },
+            asUserId,
+        }));
+        for (const m of res.data ?? []) {
+            if (!m.userId || m.memberType === "agent")
+                continue;
+            if (wanted.has(m.userId))
+                found.set(m.userId, m.displayName || m.userId);
+        }
+        cursor = res.cursor ?? undefined;
+        if (!res.hasMore || !cursor)
+            break;
+    }
+    return userIds.map((userId) => {
+        const name = found.get(userId);
+        if (name === undefined)
+            throw new Error(`User ${userId} is not a member of room ${roomId}`);
+        return { userId, name, type: "user" };
+    });
+}
+export function registerMessages(program) {
+    const group = getOrCreateGroup(program, "messages", "Messages operations");
+    group
+        .command("send-text")
+        .description("Send a text message to a room. Use --mention-user to mention members without exposing raw ids.")
+        .requiredOption("--room <roomId>", "target room id")
+        .requiredOption("--text <text>", "message body")
+        .option("--reply-to <messageId>", "parent message id (for threaded replies)")
+        .option("--mention-user <userId>", "room member to mention by display 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 } = program.opts();
+        if (!as)
+            throw new Error("--as <userId> is required");
+        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 body = {
+            content,
+            type: "text",
+            replyToId: opts.replyTo,
+            mentions: mentions.length > 0 ? mentions : undefined,
+            attachmentUrls: opts.attachments ? opts.attachments.split(",").map((s) => s.trim()).filter(Boolean) : undefined,
+        };
+        const data = await call({
+            method: "POST",
+            path: `/api/v1/rooms/${encodeURIComponent(opts.room)}/messages`,
+            query: { shadowGuidanceCards: opts.shadowGuidance ? "true" : undefined },
+            body,
+            asUserId: as,
+        });
+        process.stdout.write(JSON.stringify(data) + "\n");
+    });
+    group
+        .command("list")
+        .description("List a page of room messages, newest-first. Output: { data, cursor, hasMore }.")
+        .requiredOption("--room <roomId>", "target room id")
+        .option("--limit <n>", `page size, 1-${MAX_PAGE_LIMIT}`, "20")
+        .option("--cursor <iso>", "pagination cursor (sentAt of the oldest message seen)")
+        .option("--after <iso>", "only messages with sentAt > this ISO timestamp; overrides --cursor server-side")
+        .option("--filter <filter>", `one of: ${Array.from(MESSAGE_FILTERS).join(", ")}`)
+        .action(async (opts) => {
+        const { as } = program.opts();
+        if (!as)
+            throw new Error("--as <userId> is required");
+        const data = await call({
+            method: "GET",
+            path: `/api/v1/rooms/${encodeURIComponent(opts.room)}/messages`,
+            query: {
+                limit: parsePositiveInt(opts.limit, "--limit", MAX_PAGE_LIMIT),
+                cursor: opts.cursor,
+                after: parseIsoOrThrow(opts.after, "--after"),
+                filter: parseMessageFilter(opts.filter),
+            },
+            asUserId: as,
+        });
+        process.stdout.write(JSON.stringify(data) + "\n");
+    });
+    group
+        .command("thread")
+        .description("List replies in a message's thread, oldest-first. Agent replies default to landing in threads, " +
+        "so most agent output is only visible here. Output: { data, cursor, hasMore }.")
+        .requiredOption("--room <roomId>", "target room id")
+        .requiredOption("--message <messageId>", "thread root message id")
+        .option("--include-root", "include the root message (only honoured on the first page)")
+        .option("--limit <n>", `page size, 1-${MAX_PAGE_LIMIT}`, "20")
+        .option("--cursor <iso>", "pagination cursor from the previous page's cursor")
+        .action(async (opts) => {
+        const { as } = program.opts();
+        if (!as)
+            throw new Error("--as <userId> is required");
+        const data = await call({
+            method: "GET",
+            path: `/api/v1/rooms/${encodeURIComponent(opts.room)}/messages/${encodeURIComponent(opts.message)}/thread`,
+            query: {
+                includeRoot: opts.includeRoot ? "true" : undefined,
+                limit: parsePositiveInt(opts.limit, "--limit", MAX_PAGE_LIMIT),
+                cursor: opts.cursor,
+            },
+            asUserId: as,
+        });
+        process.stdout.write(JSON.stringify(data) + "\n");
+    });
+    group
+        .command("mark-thread-read")
+        .description("Mark a thread as read up to now. Output: { threadId, lastReadAt }.")
+        .requiredOption("--room <roomId>", "target room id")
+        .requiredOption("--message <messageId>", "thread root message id")
+        .action(async (opts) => {
+        const { as } = program.opts();
+        if (!as)
+            throw new Error("--as <userId> is required");
+        const data = await call({
+            method: "POST",
+            path: `/api/v1/rooms/${encodeURIComponent(opts.room)}/messages/${encodeURIComponent(opts.message)}/thread/read`,
+            asUserId: as,
+        });
+        process.stdout.write(JSON.stringify(data) + "\n");
+    });
+    group
+        .command("new")
+        .description("Get messages newer than --since (ISO timestamp), oldest-first. Walks pagination internally — " +
+        "the server's cursor is 'older than', this flips it for polling. Output: { data, count, fetchedPages, truncated }.")
+        .requiredOption("--room <roomId>", "target room id")
+        .requiredOption("--since <iso>", 'ISO 8601 timestamp; only messages with sentAt > since are returned (e.g. "2026-04-28T10:00:00Z")')
+        .option("--limit <n>", "max messages per page (server caps at 100)", "50")
+        .option("--max-pages <n>", "safety cap on pages walked back", "20")
+        .action(async (opts) => {
+        const { as } = program.opts();
+        if (!as)
+            throw new Error("--as <userId> is required");
+        const sinceMs = new Date(opts.since).getTime();
+        if (Number.isNaN(sinceMs))
+            throw new Error(`--since not a valid ISO timestamp: ${opts.since}`);
+        const limit = Number(opts.limit);
+        const maxPages = Number(opts.maxPages);
+        const collected = [];
+        let cursor;
+        let pages = 0;
+        let stopped = false;
+        while (pages < maxPages) {
+            pages++;
+            const page = (await call({
+                method: "GET",
+                path: `/api/v1/rooms/${encodeURIComponent(opts.room)}/messages`,
+                query: { cursor, limit },
+                asUserId: as,
+            }));
+            if (!page.data || page.data.length === 0)
+                break;
+            for (const msg of page.data) {
+                if (new Date(msg.sentAt).getTime() <= sinceMs) {
+                    stopped = true;
+                    break;
+                }
+                collected.push(msg);
+            }
+            if (stopped || !page.hasMore)
+                break;
+            cursor = page.data[page.data.length - 1].sentAt;
+        }
+        const truncated = pages >= maxPages && !stopped;
+        collected.reverse();
+        process.stdout.write(JSON.stringify({ data: collected, count: collected.length, fetchedPages: pages, truncated }) + "\n");
+    });
+    group
+        .command("latest")
+        .description("Get the latest messages visible to the acting user across their rooms. " +
+        "Composite command: lists rooms, fetches recent room messages, then merges by sentAt descending.")
+        .option("--limit <n>", `max messages to return, 1-${MAX_LIMIT}`, "50")
+        .option("--per-room-limit <n>", `messages to fetch per room, 1-${MAX_PAGE_LIMIT}`, "10")
+        .option("--room-page-limit <n>", `rooms to fetch per page, 1-${MAX_PAGE_LIMIT}`, "100")
+        .option("--max-room-pages <n>", "safety cap on room pages scanned", "10")
+        .option("--since <iso>", "only include messages with sentAt > this ISO timestamp")
+        .option("--status <value>", "room status filter")
+        .option("--inbox-category <value>", "room inbox category filter")
+        .option("--no-shadow-guidance", "do not opt in to Shadow guidance cards")
+        .action(async (opts) => {
+        const { as } = program.opts();
+        if (!as)
+            throw new Error("--as <userId> is required");
+        const limit = parsePositiveInt(opts.limit, "--limit", MAX_LIMIT);
+        const perRoomLimit = parsePositiveInt(opts.perRoomLimit, "--per-room-limit", MAX_PAGE_LIMIT);
+        const roomPageLimit = parsePositiveInt(opts.roomPageLimit, "--room-page-limit", MAX_PAGE_LIMIT);
+        const maxRoomPages = parsePositiveInt(opts.maxRoomPages, "--max-room-pages", 1000);
+        const sinceMs = parseSince(opts.since);
+        const messages = [];
+        const failedRooms = [];
+        let roomCursor;
+        let roomPagesFetched = 0;
+        let roomsScanned = 0;
+        let hasMoreRooms = true;
+        while (hasMoreRooms && roomPagesFetched < maxRoomPages) {
+            roomPagesFetched++;
+            const roomsPage = (await call({
+                method: "GET",
+                path: "/api/v1/rooms",
+                query: {
+                    cursor: roomCursor,
+                    limit: roomPageLimit,
+                    status: opts.status,
+                    inboxCategory: opts.inboxCategory,
+                    shadowGuidanceCards: opts.shadowGuidance ? "true" : undefined,
+                },
+                asUserId: as,
+            }));
+            const rooms = roomsPage.data ?? [];
+            for (const room of rooms) {
+                const id = roomId(room);
+                if (!id)
+                    continue;
+                roomsScanned++;
+                try {
+                    const roomMessages = (await call({
+                        method: "GET",
+                        path: `/api/v1/rooms/${encodeURIComponent(id)}/messages`,
+                        query: { limit: perRoomLimit },
+                        asUserId: as,
+                    }));
+                    const summary = roomSummary(room);
+                    for (const message of roomMessages.data ?? []) {
+                        if (sinceMs !== undefined && sentAtMs(message) <= sinceMs)
+                            continue;
+                        messages.push({
+                            ...record(message),
+                            room: summary,
+                            roomId: record(message).roomId ?? summary.roomId,
+                            roomName: summary.name,
+                        });
+                    }
+                }
+                catch (err) {
+                    const e = err;
+                    failedRooms.push({
+                        room: roomSummary(room),
+                        error: e.message,
+                        status: e.status ?? null,
+                        body: e.body ?? null,
+                    });
+                }
+            }
+            roomCursor = roomsPage.cursor ?? undefined;
+            hasMoreRooms = Boolean(roomsPage.hasMore && roomCursor);
+        }
+        messages.sort((a, b) => sentAtMs(b) - sentAtMs(a));
+        const data = messages.slice(0, limit);
+        process.stdout.write(JSON.stringify({
+            data,
+            count: data.length,
+            collectedCount: messages.length,
+            roomsScanned,
+            roomPagesFetched,
+            truncatedRooms: hasMoreRooms,
+            failedRooms,
+        }) + "\n");
+    });
+    group
+        .command("react")
+        .description("Add a reaction to a message. --emoji can be either an emoji character or a reaction id " +
+        "(server stores it as the `type` field).")
+        .requiredOption("--room <roomId>", "target room")
+        .requiredOption("--message <messageId>", "target message")
+        .requiredOption("--emoji <type>", 'reaction type — emoji or id (e.g. "👍" or "thumbs_up")')
+        .action(async (opts) => {
+        const { as } = program.opts();
+        if (!as)
+            throw new Error("--as <userId> is required");
+        const data = await call({
+            method: "POST",
+            path: `/api/v1/rooms/${encodeURIComponent(opts.room)}/messages/${encodeURIComponent(opts.message)}/reactions`,
+            body: { type: opts.emoji },
+            asUserId: as,
+        });
+        process.stdout.write(JSON.stringify(data) + "\n");
+    });
+}
+//# sourceMappingURL=messages.js.map

package/dist/commands/room-agents.js

@@ -0,0 +1,47 @@
+import { call } from "../client.js";
+import { getOrCreateGroup } from "./_group.js";
+function currentUser(program) {
+    const { as } = program.opts();
+    if (!as)
+        throw new Error("--as <userId> is required");
+    return as;
+}
+function bool(v, name) {
+    if (v === undefined)
+        return undefined;
+    if (v === "true")
+        return true;
+    if (v === "false")
+        return false;
+    throw new Error(`${name} must be true or false`);
+}
+export function registerRoomAgents(program) {
+    const group = getOrCreateGroup(program, "room-agents", "RoomAgents operations");
+    group
+        .command("install-hosted")
+        .description("Install a WorkCord-hosted custom/system agent into a room.")
+        .requiredOption("--room <roomId>", "target room id")
+        .requiredOption("--agent <agentId>", "hosted custom/system agent id")
+        .option("--reply-in-thread <true|false>", "whether the agent replies in threads")
+        .action(async (opts) => {
+        const asUserId = currentUser(program);
+        const installed = (await call({
+            method: "POST",
+            path: `/api/v1/rooms/${encodeURIComponent(opts.room)}/agents/install/${encodeURIComponent(opts.agent)}`,
+            asUserId,
+        }));
+        const replyInThread = bool(opts.replyInThread, "--reply-in-thread");
+        if (replyInThread === undefined || !installed.id) {
+            process.stdout.write(JSON.stringify(installed) + "\n");
+            return;
+        }
+        const updated = await call({
+            method: "PATCH",
+            path: `/api/v1/rooms/${encodeURIComponent(opts.room)}/agents/${encodeURIComponent(installed.id)}`,
+            asUserId,
+            body: { replyInThread },
+        });
+        process.stdout.write(JSON.stringify(updated) + "\n");
+    });
+}
+//# sourceMappingURL=room-agents.js.map