@indigoai-us/hq-cli 5.116.0 → 5.117.1

package/dist/lib/bot/split.js

@@ -0,0 +1,241 @@
+/**
+ * A long reply, cut into posts HQ Cloud will actually accept.
+ *
+ * `POST /v1/notify/dm` refuses a body over DM_BODY_MAX characters with
+ * `400: Message body exceeds 4000 characters`. Nothing used to split, so a
+ * model answer over the limit was sent whole, refused, saved on the in-flight
+ * marker and re-sent identically on every poll — the answer was lost, the
+ * person was never told, and the bot asked the API to do the impossible about
+ * twice a second for as long as it ran.
+ *
+ * `splitBody` is the fix, and it is pure so it can be tested on its own:
+ *
+ * - a body at or under the limit comes back untouched, as one part
+ * - a longer body is cut on paragraph boundaries first, then on sentence
+ *   boundaries, and only hard-wrapped when a single sentence is still too long
+ * - a fenced code block is kept whole when it fits; when it cannot fit, the
+ *   fence is closed at the end of one part and reopened (with its language) at
+ *   the start of the next, so neither part renders as broken markdown
+ * - when there is more than one part, each is prefixed `(2/3)` on its own line
+ *   so the reader can see the order; the prefix is paid for out of the limit,
+ *   never added on top of it
+ *
+ * Every returned part is guaranteed to be at most `max` characters long.
+ */
+/** The largest body HQ Cloud accepts on a DM or channel post. */
+export const DM_BODY_MAX = 4000;
+const FENCE_RE = /^[ \t]*(`{3,}|~{3,})(.*)$/;
+function bare(line) {
+    return line.replace(/\r?\n$/, "");
+}
+/**
+ * The body as paragraphs and whole fenced code blocks, in order. Concatenating
+ * every `raw` reproduces the input exactly, so nothing is lost or reflowed
+ * before a cut is actually needed.
+ */
+function segmentize(body) {
+    const segments = [];
+    let buf = "";
+    let fence = null;
+    const flush = (fenceOpen) => {
+        if (buf)
+            segments.push({ raw: buf, fenceOpen });
+        buf = "";
+    };
+    for (const line of body.split(/(?<=\n)/)) {
+        const text = bare(line);
+        if (fence) {
+            buf += line;
+            const m = FENCE_RE.exec(text);
+            // A closing fence is the same character, at least as long, and bare.
+            if (m && m[1][0] === fence.marker[0] && m[1].length >= fence.marker.length && m[2].trim() === "") {
+                flush(fence.open);
+                fence = null;
+            }
+            continue;
+        }
+        const m = FENCE_RE.exec(text);
+        if (m) {
+            flush(null);
+            fence = { open: text.trimEnd(), marker: m[1] };
+            buf = line;
+            continue;
+        }
+        if (text.trim() === "") {
+            // A blank line closes the paragraph it follows.
+            if (buf)
+                buf += line;
+            else
+                buf = line;
+            flush(null);
+            continue;
+        }
+        buf += line;
+    }
+    flush(fence ? fence.open : null);
+    return segments;
+}
+/** Break points inside a paragraph: after sentence-ending punctuation, or at a line end. */
+function splitSentences(text) {
+    const parts = [];
+    const re = /(?:[.!?…]["'”’)\]]*|\n)[ \t]*\n?[ \t]*/g;
+    let start = 0;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const end = m.index + m[0].length;
+        if (end <= start) {
+            re.lastIndex = start + 1;
+            continue;
+        }
+        parts.push(text.slice(start, end));
+        start = end;
+    }
+    if (start < text.length)
+        parts.push(text.slice(start));
+    return parts.length > 0 ? parts : [text];
+}
+/** Last resort: a run of text with no usable break, cut at whitespace when there is any. */
+function hardWrap(text, budget) {
+    const out = [];
+    let rest = text;
+    while (rest.length > budget) {
+        const window = rest.slice(0, budget);
+        const ws = Math.max(window.lastIndexOf(" "), window.lastIndexOf("\n"));
+        const cut = ws > 0 && ws >= Math.floor(budget * 0.6) ? ws : budget;
+        const piece = rest.slice(0, cut).trim();
+        if (piece)
+            out.push(piece);
+        rest = rest.slice(cut).replace(/^[ \t\n]+/, "");
+    }
+    const tail = rest.trim();
+    if (tail)
+        out.push(tail);
+    return out;
+}
+/** A code block too long for one part: closed and reopened around every cut. */
+function splitFenced(segment, budget) {
+    const open = segment.fenceOpen ?? "```";
+    const marker = FENCE_RE.exec(open)?.[1] ?? "```";
+    const overhead = open.length + marker.length + 2; // the two fence lines and their newlines
+    const inner = budget - overhead;
+    if (inner < 1)
+        return splitPlain(segment.raw, budget);
+    const lines = segment.raw.split(/(?<=\n)/).slice(1);
+    const last = lines[lines.length - 1];
+    if (last !== undefined) {
+        const m = FENCE_RE.exec(bare(last));
+        if (m && m[1][0] === marker[0] && m[2].trim() === "")
+            lines.pop();
+    }
+    const pieces = [];
+    let buf = "";
+    const emit = () => {
+        const code = buf.replace(/\n+$/, "");
+        buf = "";
+        if (code.trim() === "")
+            return;
+        pieces.push(`${open}\n${code}\n${marker}`);
+    };
+    for (const line of lines) {
+        if ((buf + line).replace(/\n+$/, "").length <= inner) {
+            buf += line;
+            continue;
+        }
+        emit();
+        const one = bare(line);
+        if (one.length <= inner) {
+            buf = line;
+            continue;
+        }
+        for (const wrapped of hardWrap(one, inner)) {
+            buf = wrapped;
+            emit();
+        }
+    }
+    emit();
+    return pieces.length > 0 ? pieces : splitPlain(segment.raw, budget);
+}
+/** A paragraph too long for one part: sentences first, hard wrap only if one sentence is still too long. */
+function splitPlain(text, budget) {
+    const out = [];
+    let buf = "";
+    const flush = () => {
+        const t = buf.trim();
+        buf = "";
+        if (t)
+            out.push(t);
+    };
+    for (const sentence of splitSentences(text)) {
+        if ((buf + sentence).trim().length <= budget) {
+            buf += sentence;
+            continue;
+        }
+        flush();
+        if (sentence.trim().length <= budget) {
+            buf = sentence;
+            continue;
+        }
+        for (const wrapped of hardWrap(sentence.trim(), budget))
+            out.push(wrapped);
+    }
+    flush();
+    return out.length > 0 ? out : hardWrap(text.trim(), budget);
+}
+function pack(body, budget) {
+    const out = [];
+    let acc = "";
+    const flush = () => {
+        const t = acc.trim();
+        acc = "";
+        if (t)
+            out.push(t);
+    };
+    for (const segment of segmentize(body)) {
+        if ((acc + segment.raw).trim().length <= budget) {
+            acc += segment.raw;
+            continue;
+        }
+        flush();
+        if (segment.raw.trim().length <= budget) {
+            acc = segment.raw;
+            continue;
+        }
+        for (const piece of segment.fenceOpen ? splitFenced(segment, budget) : splitPlain(segment.raw, budget)) {
+            out.push(piece);
+        }
+    }
+    flush();
+    return out;
+}
+/** `(2/3)` and its newline, at the widest the count can make it. */
+function prefixWidth(count) {
+    return `(${count}/${count})\n`.length;
+}
+function label(parts) {
+    if (parts.length < 2)
+        return parts;
+    return parts.map((part, i) => `(${i + 1}/${parts.length})\n${part}`);
+}
+/**
+ * One outbound body as the ordered parts to post, each at most `max`
+ * characters. A body that already fits comes back unchanged.
+ */
+export function splitBody(body, max = DM_BODY_MAX) {
+    const limit = Math.max(1, Math.floor(max));
+    if (body.length <= limit)
+        return [body];
+    let reserve = prefixWidth(2);
+    let parts = [];
+    for (let round = 0; round < 6; round += 1) {
+        parts = pack(body, Math.max(1, limit - reserve));
+        const needed = parts.length > 1 ? prefixWidth(parts.length) : 0;
+        if (needed <= reserve)
+            break;
+        reserve = needed;
+    }
+    if (parts.length === 0)
+        parts = [body.trim() || body];
+    // Belt and braces: whatever the shape of the input, no part may exceed the limit.
+    return label(parts).flatMap((part) => (part.length <= limit ? [part] : hardWrap(part, limit)));
+}
+//# sourceMappingURL=split.js.map

package/dist/lib/mesh/live/daemon/credentials.d.ts

@@ -131,4 +131,31 @@ export declare class CredentialRenewalManager {
     stop(): void;
     private clear;
 }
+/**
+ * Contract-2 (personal) realtime vend. Backed server-side by the personal
+ * session policy, which grants Subscribe/Receive on the caller's own
+ * `hq/{principalUid}/{dm,sessions,work,notifications,meeting,sync}` topics —
+ * unlike contract 3, whose policy only covers company presence and the thread
+ * directory. Doorbell listeners on personal topics MUST use this contract;
+ * subscribing to personal topics with a contract-3 session makes AWS IoT drop
+ * the connection before SUBACK.
+ */
+export interface PersonalRealtimeBundle {
+    contractVersion: 2;
+    credentials: IotCredentials;
+    iotEndpoint: string;
+    region: string;
+    clientId: string;
+    actorUid: string;
+    /** Advertised personal topics keyed by kind (dm, sessions, work, notifications, …). */
+    topics: Record<string, string>;
+    expiresAt: string;
+}
+export type PersonalCredentialsFetcher = () => Promise<PersonalRealtimeBundle>;
+export declare function normalizePersonalRealtimeBundle(raw: unknown): PersonalRealtimeBundle;
+export declare function createPersonalRealtimeFetcher(opts: {
+    token: string;
+    baseUrl?: string;
+    post?: (path: string, body: unknown) => Promise<CredentialVendPostResult>;
+}): PersonalCredentialsFetcher;
 //# sourceMappingURL=credentials.d.ts.map

package/dist/lib/mesh/live/daemon/credentials.js

@@ -385,4 +385,99 @@ export class CredentialRenewalManager {
         }
     }
 }
+export function normalizePersonalRealtimeBundle(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error("contract-2 vend response is not an object");
+    }
+    const r = raw;
+    if (r.contractVersion !== 2) {
+        throw new Error(`expected contractVersion 2, got ${String(r.contractVersion)}`);
+    }
+    const creds = r.credentials;
+    if (!creds ||
+        typeof creds.accessKeyId !== "string" ||
+        typeof creds.secretAccessKey !== "string" ||
+        typeof creds.sessionToken !== "string") {
+        throw new Error("contract-2 vend missing credentials");
+    }
+    for (const key of ["clientId", "iotEndpoint", "region"]) {
+        if (typeof r[key] !== "string" || !r[key].trim()) {
+            throw new Error(`contract-2 vend missing ${key}`);
+        }
+    }
+    const topicsRaw = r.topics && typeof r.topics === "object" && !Array.isArray(r.topics)
+        ? r.topics
+        : {};
+    const topics = {};
+    for (const [k, v] of Object.entries(topicsRaw)) {
+        if (typeof v === "string" && v.trim())
+            topics[k] = v.trim();
+    }
+    if (!topics.dm && typeof r.topic === "string")
+        topics.dm = r.topic;
+    const actorUid = (typeof r.principalUid === "string" && /^(?:prs|agt)_[A-Za-z0-9]+$/.test(r.principalUid)
+        ? r.principalUid
+        : undefined) ||
+        actorUidFromPersonalTopic(topics.dm) ||
+        "";
+    if (!actorUid)
+        throw new Error("contract-2 vend could not derive actorUid");
+    // Only keep topics that belong to the vended principal.
+    for (const [k, v] of Object.entries(topics)) {
+        if (actorUidFromPersonalTopic(v) !== actorUid)
+            delete topics[k];
+    }
+    const expiresAt = (typeof r.expiresAt === "string" && r.expiresAt) ||
+        (typeof creds.expiration === "string" && creds.expiration) ||
+        "";
+    if (!expiresAt)
+        throw new Error("contract-2 vend missing expiresAt");
+    return {
+        contractVersion: 2,
+        credentials: {
+            accessKeyId: creds.accessKeyId,
+            secretAccessKey: creds.secretAccessKey,
+            sessionToken: creds.sessionToken,
+            expiration: expiresAt,
+        },
+        iotEndpoint: r.iotEndpoint,
+        region: r.region,
+        clientId: r.clientId,
+        actorUid,
+        topics,
+        expiresAt,
+    };
+}
+export function createPersonalRealtimeFetcher(opts) {
+    return async () => {
+        if (opts.post) {
+            const res = await opts.post(REALTIME_CREDENTIALS_PATH, { contractVersion: 2 });
+            if (res.status < 200 || res.status >= 300) {
+                throw classifyCredentialVendFailure(res.status, res.body, headerGet(res.headers, "Retry-After"));
+            }
+            return normalizePersonalRealtimeBundle(res.body);
+        }
+        const res = await vaultApiFetch({
+            token: opts.token,
+            path: REALTIME_CREDENTIALS_PATH,
+            method: "POST",
+            body: { contractVersion: 2 },
+            baseUrl: opts.baseUrl ?? DEFAULT_VAULT_API_URL,
+        });
+        const text = await res.text();
+        let body = {};
+        if (text) {
+            try {
+                body = JSON.parse(text);
+            }
+            catch {
+                body = { raw: text.slice(0, 200) };
+            }
+        }
+        if (!res.ok) {
+            throw classifyCredentialVendFailure(res.status, body, res.headers.get("Retry-After"));
+        }
+        return normalizePersonalRealtimeBundle(body);
+    };
+}
 //# sourceMappingURL=credentials.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.116.0",
+  "version": "5.117.1",
   "description": "HQ by Indigo management CLI \u2014 modules and cloud sync",
   "main": "dist/index.js",
   "bin": {