@fulldivevr/workcord-cli 1.1.1 → 1.2.0

package/dist/config.js

@@ -12,6 +12,7 @@ export async function readConfig() {
         return {
             baseUrl: typeof config.baseUrl === "string" ? config.baseUrl : undefined,
             token: typeof config.token === "string" ? config.token : undefined,
+            hermes: readHermes(config.hermes),
         };
     }
     catch (err) {
@@ -20,6 +21,29 @@ export async function readConfig() {
         throw new Error(`Could not read ${configPath}: ${err.message}`);
     }
 }
+function readHermes(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const out = {};
+    for (const [ref, raw] of Object.entries(value)) {
+        if (!raw || typeof raw !== "object")
+            continue;
+        const entry = raw;
+        if (typeof entry.key !== "string" || typeof entry.hubBaseUrl !== "string")
+            continue;
+        out[ref] = {
+            key: entry.key,
+            tenantId: typeof entry.tenantId === "string" ? entry.tenantId : "",
+            hubBaseUrl: entry.hubBaseUrl,
+            revealedAt: typeof entry.revealedAt === "string" ? entry.revealedAt : "",
+        };
+    }
+    return Object.keys(out).length ? out : undefined;
+}
+export async function saveHermesEntry(agentRef, entry) {
+    const current = await readConfig();
+    await saveConfig({ hermes: { ...current.hermes, [agentRef]: entry } });
+}
 export async function saveConfig(update) {
     const current = await readConfig();
     const next = { ...current, ...update };

package/dist/generated/commands/custom-agents.js

@@ -232,6 +232,20 @@ export function register(program) {
             process.stdout.write(JSON.stringify(data) + "\n");
         });
     }
+    if (!hasSubcommand(group, "reveal-hermes-cli-key")) {
+        group
+            .command("reveal-hermes-cli-key")
+            .description("POST /api/v1/agents/{id}/hermes-cli-key/reveal")
+            .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/agents/${encodeURIComponent(opts.id)}/hermes-cli-key/reveal`;
+            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, "install-hermes-flavor-to-room")) {
         group
             .command("install-hermes-flavor-to-room")

package/dist/generated/commands/health.js

@@ -0,0 +1,29 @@
+import { call } from "../../client.js";
+import { actingUserId } from "../../auth.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "health", "Health operations");
+    if (!hasSubcommand(group, "health")) {
+        group
+            .command("health")
+            .description("GET /api/health")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/health`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "hello")) {
+        group
+            .command("hello")
+            .description("GET /api/hello")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/hello`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=health.js.map

package/dist/generated/commands/live-kit-webhook.js

@@ -0,0 +1,20 @@
+import { call } from "../../client.js";
+import { actingUserId } from "../../auth.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "live-kit-webhook", "LiveKitWebhook operations");
+    if (!hasSubcommand(group, "webhook")) {
+        group
+            .command("webhook")
+            .description("POST /api/v1/livekit/webhook")
+            .option("--body <json>", "request body as JSON (no schema available)")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/livekit/webhook`;
+            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=live-kit-webhook.js.map

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

@@ -0,0 +1,33 @@
+import { call } from "../../client.js";
+import { actingUserId } from "../../auth.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "room-call", "RoomCall operations");
+    if (!hasSubcommand(group, "token")) {
+        group
+            .command("token")
+            .description("POST /api/v1/rooms/{roomId}/call/token")
+            .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/token`;
+            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, "state")) {
+        group
+            .command("state")
+            .description("GET /api/v1/rooms/{roomId}/call")
+            .requiredOption("--room-id <value>", "roomId (path param)")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/rooms/${encodeURIComponent(opts.roomId)}/call`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=room-call.js.map

package/dist/generated/commands/rooms.js

@@ -237,6 +237,30 @@ export function register(program) {
             process.stdout.write(JSON.stringify(data) + "\n");
         });
     }
+    if (!hasSubcommand(group, "list-agent-install-targets")) {
+        group
+            .command("list-agent-install-targets")
+            .description("GET /api/v1/rooms/agent-install-targets")
+            .option("--cursor <value>", "string")
+            .option("--limit <value>", "string")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/rooms/agent-install-targets`;
+            const query = {};
+            {
+                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, "list-channel-templates")) {
         group
             .command("list-channel-templates")

package/dist/generated/index.js

@@ -25,6 +25,7 @@ import { register as register_invite_redirect } from "./commands/invite-redirect
 import { register as register_jesuscord_admin } from "./commands/jesuscord-admin.js";
 import { register as register_join } from "./commands/join.js";
 import { register as register_kits } from "./commands/kits.js";
+import { register as register_live_kit_webhook } from "./commands/live-kit-webhook.js";
 import { register as register_meetings } from "./commands/meetings.js";
 import { register as register_message_folders } from "./commands/message-folders.js";
 import { register as register_messages } from "./commands/messages.js";
@@ -40,6 +41,7 @@ import { register as register_referrals } from "./commands/referrals.js";
 import { register as register_reports } from "./commands/reports.js";
 import { register as register_room_a2_a } from "./commands/room-a2-a.js";
 import { register as register_room_agents } from "./commands/room-agents.js";
+import { register as register_room_call } from "./commands/room-call.js";
 import { register as register_room_invites } from "./commands/room-invites.js";
 import { register as register_room_owned_agent } from "./commands/room-owned-agent.js";
 import { register as register_room_page } from "./commands/room-page.js";
@@ -89,6 +91,7 @@ export function registerAll(program) {
     register_jesuscord_admin(program);
     register_join(program);
     register_kits(program);
+    register_live_kit_webhook(program);
     register_meetings(program);
     register_message_folders(program);
     register_messages(program);
@@ -104,6 +107,7 @@ export function registerAll(program) {
     register_reports(program);
     register_room_a2_a(program);
     register_room_agents(program);
+    register_room_call(program);
     register_room_invites(program);
     register_room_owned_agent(program);
     register_room_page(program);

package/dist/hermes-client.js

@@ -0,0 +1,87 @@
+import { applyQuery, fetchWithRetry, httpError, normalizeBaseUrl, safeJson } from "./http.js";
+function buildUrl(hubBaseUrl, path, query) {
+    return applyQuery(new URL(normalizeBaseUrl(hubBaseUrl) + path), query);
+}
+function authHeaders(key, headers) {
+    return { authorization: `Bearer ${key}`, ...headers };
+}
+async function failure(method, path, res) {
+    const text = await res.text();
+    throw httpError(`${method} ${path}`, res.status, text ? safeJson(text) : null);
+}
+export async function hermesCall({ hubBaseUrl, key, method = "GET", path, query, body, headers }) {
+    const url = buildUrl(hubBaseUrl, path, query);
+    const res = await fetchWithRetry(() => ({
+        url,
+        init: {
+            method,
+            headers: { "content-type": "application/json", ...authHeaders(key, headers) },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        },
+    }));
+    if (!res.ok)
+        return failure(method, path, res);
+    const text = await res.text();
+    return text ? safeJson(text) : null;
+}
+export async function hermesUpload({ hubBaseUrl, key, method = "POST", path, query, headers, contentType, data }) {
+    const url = buildUrl(hubBaseUrl, path, query);
+    const res = await fetchWithRetry(() => ({
+        url,
+        init: { method, headers: { "content-type": contentType, ...authHeaders(key, headers) }, body: data },
+    }));
+    if (!res.ok)
+        return failure(method, path, res);
+    const text = await res.text();
+    return text ? safeJson(text) : null;
+}
+export async function hermesBinary({ hubBaseUrl, key, method = "GET", path, query, body, headers, out = process.stdout }) {
+    const url = buildUrl(hubBaseUrl, path, query);
+    const res = await fetchWithRetry(() => ({
+        url,
+        init: {
+            method,
+            headers: authHeaders(key, headers),
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        },
+    }));
+    if (!res.ok)
+        return failure(method, path, res);
+    const buffer = Buffer.from(await res.arrayBuffer());
+    out.write(buffer);
+}
+export async function hermesStream({ hubBaseUrl, key, method = "GET", path, query, body, headers, lastEventId, out = process.stdout }) {
+    const url = buildUrl(hubBaseUrl, path, query);
+    const res = await fetchWithRetry(() => ({
+        url,
+        init: {
+            method,
+            headers: {
+                accept: "text/event-stream",
+                ...(body !== undefined ? { "content-type": "application/json" } : {}),
+                ...(lastEventId ? { "last-event-id": lastEventId } : {}),
+                ...authHeaders(key, headers),
+            },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        },
+    }));
+    if (!res.ok)
+        return failure(method, path, res);
+    if (!res.body)
+        return;
+    const decoder = new TextDecoder();
+    let pending = "";
+    for await (const chunk of res.body) {
+        pending += decoder.decode(chunk, { stream: true });
+        let index = pending.indexOf("\n");
+        while (index >= 0) {
+            out.write(pending.slice(0, index + 1));
+            pending = pending.slice(index + 1);
+            index = pending.indexOf("\n");
+        }
+    }
+    pending += decoder.decode();
+    if (pending)
+        out.write(pending + "\n");
+}
+//# sourceMappingURL=hermes-client.js.map

package/dist/hermes-guards.js

@@ -0,0 +1,70 @@
+export const MAX_ARCHIVE_BYTES = 32 * 1024 * 1024;
+export function rolloutBody(flags) {
+    const tenants = flags.tenant ?? [];
+    if (flags.allMatching && tenants.length > 0) {
+        throw new Error("--all-matching and --tenant are mutually exclusive.");
+    }
+    if (tenants.length > 0) {
+        if (flags.canary) {
+            throw new Error("--canary selects the canary cohort of an automatic rollout and cannot be combined with --tenant.");
+        }
+        return { tenantIds: tenants };
+    }
+    if (flags.allMatching) {
+        if (flags.canary) {
+            throw new Error("--canary requires the automatic rollout and cannot be combined with --all-matching.");
+        }
+        if (!flags.force) {
+            throw new Error("--all-matching sends automatic:false, which re-pins EVERY tenant on this hub pinned to this flavor id and ignores each target tenant's own pinned update policy. Re-run with --force to accept that blast radius, drop --all-matching for the policy-respecting rollout, or pass --tenant <id> to target named tenants.");
+        }
+        return { allMatching: true, automatic: false };
+    }
+    return { allMatching: true, automatic: true, ...(flags.canary ? { canary: true } : {}) };
+}
+export function compareVersions(a, b) {
+    const parse = (v) => v.split(".").map((part) => Number.parseInt(part, 10) || 0);
+    const left = parse(a);
+    const right = parse(b);
+    const length = Math.max(left.length, right.length);
+    for (let i = 0; i < length; i++) {
+        const diff = (left[i] ?? 0) - (right[i] ?? 0);
+        if (diff !== 0)
+            return diff < 0 ? -1 : 1;
+    }
+    return 0;
+}
+export function flavorSetWarnings(currentVersion, targetVersion, versions) {
+    const warnings = [];
+    const target = versions.find((v) => v.version === targetVersion);
+    if (target?.deprecated) {
+        warnings.push(`flavor version ${targetVersion} is marked deprecated on the hub`);
+    }
+    if (currentVersion && compareVersions(targetVersion, currentVersion) < 0) {
+        warnings.push(`this is a downgrade: ${currentVersion} -> ${targetVersion}`);
+    }
+    return warnings;
+}
+export function assertArchiveSize(bytes, path) {
+    if (bytes > MAX_ARCHIVE_BYTES) {
+        throw new Error(`${path} is ${bytes} bytes; the hub rejects packages over ${MAX_ARCHIVE_BYTES} bytes (32 MiB). Trim the package and retry.`);
+    }
+}
+export function ownershipError(kind, namespaceId, tenantId, body) {
+    const who = tenantId || "this tenant";
+    const err = new Error(`Hermes Hub refused this as ${who}: it does not own the ${kind} namespace "${namespaceId}". A WorkCord agent tenant is provisioned as a consumer and owns no ${kind} namespace. Ownership is admin-assigned only (PUT /v1/${kind}s/${namespaceId}/owner) and there is no self-service bootstrap — ask a hub operator to assign "${namespaceId}" to ${who}.`);
+    err.status = 403;
+    err.body = body;
+    return err;
+}
+export async function guardOwnership(kind, namespaceId, tenantId, run) {
+    try {
+        return await run();
+    }
+    catch (err) {
+        if (err.status === 403) {
+            throw ownershipError(kind, namespaceId, tenantId, err.body);
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=hermes-guards.js.map

package/dist/http.js

@@ -0,0 +1,68 @@
+export function normalizeBaseUrl(raw) {
+    const trimmed = raw.replace(/\/+$/, "");
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        throw new Error(`Invalid API base URL: ${raw}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error(`API base URL must be http or https: ${raw}`);
+    }
+    if (parsed.pathname !== "/" || parsed.search || parsed.hash) {
+        throw new Error(`API base URL must be an origin with no path, query or fragment: ${raw}`);
+    }
+    return parsed.origin;
+}
+const RETRY_MAX = Number(process.env.WORKCORD_RETRY_MAX ?? 3);
+const RETRY_BACKOFF_MS = Number(process.env.WORKCORD_RETRY_BACKOFF_MS ?? 200);
+const RETRY_STATUSES = new Set([408, 429, 502, 503, 504]);
+export async function fetchWithRetry(build) {
+    let lastErr;
+    for (let attempt = 0; attempt <= RETRY_MAX; attempt++) {
+        try {
+            const { url, init } = build();
+            const res = await fetch(url, init);
+            if (!RETRY_STATUSES.has(res.status))
+                return res;
+            lastErr = res;
+            if (attempt >= RETRY_MAX)
+                return res;
+        }
+        catch (err) {
+            lastErr = err;
+            if (attempt >= RETRY_MAX)
+                throw err;
+        }
+        const delay = RETRY_BACKOFF_MS * Math.pow(3, attempt);
+        await new Promise((r) => setTimeout(r, delay));
+    }
+    if (lastErr instanceof Response)
+        return lastErr;
+    throw lastErr;
+}
+export function safeJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return s;
+    }
+}
+export function httpError(label, status, body) {
+    const err = new Error(`${label} -> ${status}`);
+    err.status = status;
+    err.body = body;
+    return err;
+}
+export function applyQuery(url, query) {
+    if (!query)
+        return url;
+    for (const [k, v] of Object.entries(query)) {
+        if (v !== undefined && v !== null)
+            url.searchParams.set(k, String(v));
+    }
+    return url;
+}
+//# sourceMappingURL=http.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fulldivevr/workcord-cli",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "CLI for the WorkCord API. One invocation = one user action.",
   "private": false,
   "license": "UNLICENSED",