@indigoai-us/hq-cli 5.345.76 → 5.345.78

package/dist/commands/members.js

@@ -371,6 +371,108 @@ export async function changeMemberRole(token, companyUid, membershipKey, newRole
         throw new InviteHttpError(res.status, err.message ?? err.error ?? res.statusText, err.code);
     }
 }
+/** Guests remain active members, so company-wide (@all) grants still apply. */
+export const GUEST_COMPANY_WIDE_NOTE = "Guests stay active members. Company-wide grants (Everyone in company / @all) still apply to them. Demoting to guest does not lock someone out. Use `hq members remove <email>`.";
+export function personUidFromMembershipKey(membershipKey) {
+    const hash = membershipKey.indexOf("#");
+    return hash === -1 ? membershipKey : membershipKey.slice(0, hash);
+}
+/** Paths granted to this person or their email — not company-wide or group. */
+export function personalGrantPaths(grants) {
+    if (!grants)
+        return [];
+    const paths = [];
+    for (const grant of grants) {
+        if (typeof grant.path !== "string" || grant.path.length === 0)
+            continue;
+        const sources = Array.isArray(grant.sources) ? grant.sources : [];
+        if (sources.some((source) => source.via === "person" || source.via === "email")) {
+            paths.push(grant.path);
+        }
+    }
+    return [...new Set(paths)];
+}
+export async function fetchMemberAccessProjection(token, companyUid, personUid) {
+    const res = await vaultApiFetch({
+        token,
+        path: `/files/${encodeURIComponent(companyUid)}/members/${encodeURIComponent(personUid)}/access`,
+        method: "GET",
+    });
+    if (!res.ok)
+        return null;
+    return (await res.json().catch(() => null));
+}
+/**
+ * End an active membership via `POST /membership/revoke`, then drop person and
+ * email file/secret grants collected from the member-access projection.
+ * Company-wide and group grants are left in place — they belong to the company,
+ * not the person. Membership end already makes company-wide grants inert for
+ * this principal because they are no longer an active member.
+ */
+export async function removeActiveMember(token, companyUid, membershipKey, opts) {
+    const personUid = personUidFromMembershipKey(membershipKey);
+    const projection = await fetchMemberAccessProjection(token, companyUid, personUid);
+    const email = opts?.email ??
+        (typeof projection?.identity?.primaryEmail === "string"
+            ? projection.identity.primaryEmail
+            : undefined);
+    const filePaths = personalGrantPaths(projection?.files?.grants);
+    const secretPaths = personalGrantPaths(projection?.secrets?.grants);
+    await revokeInvite(token, membershipKey, companyUid);
+    const droppedFileGrants = [];
+    const droppedSecretGrants = [];
+    const skippedGrantDrops = [];
+    for (const prefix of filePaths) {
+        const personRes = await vaultApiFetch({
+            token,
+            path: `/files/${encodeURIComponent(companyUid)}/acl/revoke`,
+            method: "POST",
+            body: { prefix, granteeType: "person", granteeId: personUid },
+        });
+        let dropped = personRes.ok;
+        if (!dropped && email) {
+            const emailRes = await vaultApiFetch({
+                token,
+                path: `/files/${encodeURIComponent(companyUid)}/acl/revoke`,
+                method: "POST",
+                body: {
+                    prefix,
+                    granteeType: "email",
+                    granteeId: email.toLowerCase(),
+                },
+            });
+            dropped = emailRes.ok;
+        }
+        if (dropped)
+            droppedFileGrants.push(prefix);
+        else
+            skippedGrantDrops.push(prefix);
+    }
+    if (email) {
+        for (const secretPath of secretPaths) {
+            const res = await vaultApiFetch({
+                token,
+                path: `/secrets/${encodeURIComponent(companyUid)}/acl/revoke`,
+                method: "POST",
+                body: {
+                    path: secretPath,
+                    granteeType: "email",
+                    granteeId: email.toLowerCase(),
+                },
+            });
+            if (res.ok)
+                droppedSecretGrants.push(secretPath);
+            else
+                skippedGrantDrops.push(secretPath);
+        }
+    }
+    return {
+        membershipKey,
+        droppedFileGrants,
+        droppedSecretGrants,
+        skippedGrantDrops,
+    };
+}
 export function registerMembersCommand(program) {
     const members = program
         .command("members")
@@ -384,6 +486,7 @@ export function registerMembersCommand(program) {
             promote: "members:write",
             invite: "members:write",
             revoke: "members:write",
+            remove: "members:write",
         },
     });
     // Canonical role-change command. `promote` is the discoverable verb users
@@ -418,6 +521,10 @@ export function registerMembersCommand(program) {
                 console.log(chalk.dim(`${role === "owner" ? "Owners" : "Admins"} automatically have full read and write access to all of this company's context — no separate context grant is needed.\n` +
                     `What they actually see synced to their machine is governed by their sync mode (\`hq sync mode\`), not by access.`));
             }
+            else if (role === "guest") {
+                console.log(chalk.dim(GUEST_COMPANY_WIDE_NOTE));
+                console.log(chalk.dim(`Check what they can still reach with: hq access <path> --as ${target}`));
+            }
         }
         catch (err) {
             if (err instanceof InviteHttpError) {
@@ -708,9 +815,52 @@ export function registerMembersCommand(program) {
             process.exit(1);
         }
     });
+    members
+        .command("remove <target>")
+        .description("Remove an active member. Ends membership so company-wide grants no longer apply, and drops that person's file and secret grants. Accepts an email, prs_ personUid, agt_ agentUid, or full membership key.")
+        .action(async (target) => {
+        try {
+            const token = (await resolveVaultCredential()).token;
+            const companySlug = members.opts().company;
+            const companyUid = await getCompanyUid(token, companySlug);
+            const detected = detectTarget(target);
+            const membershipKey = await resolveRoleChangeTarget(token, companyUid, target);
+            const email = detected?.type === "email" ? detected.value : undefined;
+            const result = await removeActiveMember(token, companyUid, membershipKey, { email });
+            console.log(chalk.green(`Removed '${target}' from the company (membership ${result.membershipKey}).`));
+            console.log(chalk.dim("They are no longer an active member, so company-wide grants no longer apply to them."));
+            if (result.droppedFileGrants.length > 0) {
+                console.log(chalk.dim(`Dropped person file grants: ${result.droppedFileGrants.join(", ")}`));
+            }
+            if (result.droppedSecretGrants.length > 0) {
+                console.log(chalk.dim(`Dropped person secret grants: ${result.droppedSecretGrants.join(", ")}`));
+            }
+            if (result.skippedGrantDrops.length > 0) {
+                console.log(chalk.yellow(`Could not drop some person grants: ${result.skippedGrantDrops.join(", ")}`));
+            }
+            console.log(chalk.dim("A remaining teammate's access: hq access <path> --as <email>. After removal that check reports they are not an active member."));
+        }
+        catch (err) {
+            if (err instanceof InviteHttpError) {
+                const msg = err.status === 403
+                    ? err.code === "ADMIN_ROLE_TARGET_RESTRICTED"
+                        ? "Admin can only remove role=member; ask an owner to remove this membership"
+                        : "Not authorized — only admins and owners can remove members"
+                    : err.status === 404
+                        ? "Member not found — they may already have been removed"
+                        : err.status === 409 && err.code === "LAST_OWNER_UNREMOVABLE"
+                            ? "A company must keep at least one owner"
+                            : formatInviteHttpError(err.status, err.message, err.code);
+                console.error(chalk.red(msg));
+                process.exit(1);
+            }
+            console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
     members
         .command("revoke <target>")
-        .description("Revoke a pending invite. Accepts an email, personUid, full membershipKey, or legacy inviteToken.")
+        .description("Revoke a pending invite. For an active member, use `hq members remove` instead. Accepts an email, personUid, full membershipKey, or legacy inviteToken.")
         .action(async (target) => {
         try {
             const token = (await resolveVaultCredential()).token;

package/dist/commands/secrets.js

@@ -385,7 +385,7 @@ function parseSecretAclPrincipal(principal) {
 }
 function describeSecretAclPrincipal(principal) {
     return principal.granteeType === "company-wide"
-        ? "@all (entire company)"
+        ? "@all (entire company, including guests)"
         : principal.granteeId;
 }
 // Mirrors hq-pro's server-authoritative KNOWN_DESTINATION_REGISTRY

package/dist/lib/bot/api.d.ts

@@ -217,6 +217,17 @@ export declare class BotApi {
         body: string;
         rootEventId?: string;
         audience?: "human" | "agent" | "both";
+        /**
+         * Structured blocks shown next to the plain body (server: hq-pro-core
+         * vault-service/lib/rich-content.ts, `{ v: 1, blocks: [{ kind, ... }] }`).
+         * The body stays the fallback for clients that do not render them.
+         */
+        richContent?: {
+            v: 1;
+            blocks: ReadonlyArray<{
+                kind: string;
+            }>;
+        };
     }): Promise<{
         eventId?: string;
         createdAt?: string;

package/dist/lib/bot/api.js

@@ -158,6 +158,8 @@ export class BotApi {
             payload.rootEventId = input.rootEventId;
         if (input.audience)
             payload.audience = input.audience;
+        if (input.richContent)
+            payload.richContent = input.richContent;
         const { body } = await this.call("/v1/notify/dm", { method: "POST", body: payload });
         return body;
     }

package/dist/lib/bot/inflight.d.ts

@@ -66,6 +66,9 @@ export interface InflightTurn {
      */
     jobFailure?: {
         reason: string;
+        /** The plain run output to report (never the runtime's raw text). */
+        output?: string;
+        /** Older markers: the raw excerpt. Not reported anywhere since 5.345.76. */
         excerpt?: string;
     };
     rootEventId?: string;

package/dist/lib/bot/probe.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Readiness probe: one minimal model turn with the exact runtime, model and
+ * thinking level a bot would use, so the desktop can tell before saving a bot
+ * whether its first turn will work (`hq bot probe --runtime codex --json`).
+ *
+ * The turn goes through the same `runRuntimeTurn` a bot uses, with the same
+ * environment rules as a personal bot (`turnEnv`) and the same approval mode,
+ * so a version mismatch, a dead sign-in or an unknown model shows up here the
+ * way it would on the bot's first message. The version-mismatch retry applies
+ * too: a probe that only worked on a fallback model is `ok` and says so in
+ * `modelFallback`. It runs in an empty scratch directory, not the HQ root, so
+ * the tool loads no project settings, instructions or hooks: the check costs
+ * one tiny model turn and nothing else.
+ */
+import type { BotRuntimeId } from "./config.js";
+import { type RuntimeFailureClass } from "./runtime-failure.js";
+import { type BotRuntime, type RunTurnDeps, type RuntimeTurnInput, type RuntimeTurnResult } from "./runtime/index.js";
+export declare const PROBE_PROMPT = "This is a readiness check from HQ. Reply with exactly the word OK and nothing else. Do not run any commands or use any tools.";
+export declare const PROBE_SYSTEM_PROMPT = "You are an HQ bot being checked before it is created. Answer the check in one word.";
+/** A probe that has not answered by then is reported as `transient`. */
+export declare const PROBE_DEFAULT_TIMEOUT_MS = 120000;
+/** The plain sentence for a failed probe: what is wrong and the one fix. */
+export declare function probeFailureText(cls: RuntimeFailureClass, runtime: BotRuntimeId | string): string;
+export interface RuntimeProbeResult {
+    ok: boolean;
+    /** null when ok; otherwise the same classes a bot's failure DM uses. */
+    class: RuntimeFailureClass | null;
+    /** One plain sentence a person can read. Never the runtime's raw error. */
+    detail: string;
+    runtime: BotRuntimeId;
+    /** The model asked for; null = the runtime's own default. */
+    model: string | null;
+    /** The CLI was too old for `from`, and the probe answered on `to`. */
+    modelFallback?: {
+        from: string;
+        to: string;
+    };
+    /** The runtime's raw error, for logs only. Not for display. */
+    diagnostic?: string;
+    durationMs: number;
+}
+export interface ProbeOptions {
+    runtime: BotRuntimeId;
+    model?: string;
+    effort?: string;
+    /** Working directory of the turn. Default: an empty scratch directory, removed afterwards. */
+    cwd?: string;
+    autoApprove?: boolean;
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+    /** Test seams. */
+    runTurn?: (runtime: BotRuntime, input: RuntimeTurnInput, deps?: RunTurnDeps) => Promise<RuntimeTurnResult>;
+    runtimeImpl?: BotRuntime;
+    now?: () => number;
+}
+export declare function probeBotRuntime(opts: ProbeOptions): Promise<RuntimeProbeResult>;
+//# sourceMappingURL=probe.d.ts.map

package/dist/lib/bot/probe.js

@@ -0,0 +1,100 @@
+/**
+ * Readiness probe: one minimal model turn with the exact runtime, model and
+ * thinking level a bot would use, so the desktop can tell before saving a bot
+ * whether its first turn will work (`hq bot probe --runtime codex --json`).
+ *
+ * The turn goes through the same `runRuntimeTurn` a bot uses, with the same
+ * environment rules as a personal bot (`turnEnv`) and the same approval mode,
+ * so a version mismatch, a dead sign-in or an unknown model shows up here the
+ * way it would on the bot's first message. The version-mismatch retry applies
+ * too: a probe that only worked on a fallback model is `ok` and says so in
+ * `modelFallback`. It runs in an empty scratch directory, not the HQ root, so
+ * the tool loads no project settings, instructions or hooks: the check costs
+ * one tiny model turn and nothing else.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { classifyRuntimeError } from "./runtime-failure.js";
+import { runtimeDisplayName } from "./runtime-sign-in.js";
+import { RuntimeError, runRuntimeTurn, runtimeFor } from "./runtime/index.js";
+import { turnEnv } from "./run.js";
+export const PROBE_PROMPT = "This is a readiness check from HQ. Reply with exactly the word OK and nothing else. Do not run any commands or use any tools.";
+export const PROBE_SYSTEM_PROMPT = "You are an HQ bot being checked before it is created. Answer the check in one word.";
+/** A probe that has not answered by then is reported as `transient`. */
+export const PROBE_DEFAULT_TIMEOUT_MS = 120_000;
+/** The plain sentence for a failed probe: what is wrong and the one fix. */
+export function probeFailureText(cls, runtime) {
+    const tool = runtimeDisplayName(runtime);
+    switch (cls) {
+        case "signed-out":
+            return `${tool} is not signed in on this computer. Sign in to ${tool} in HQ, then check again.`;
+        case "cli-outdated":
+            return `${tool} on this computer is out of date for this model. Update ${tool}, then check again.`;
+        case "model-unsupported":
+            return `This model isn't available in ${tool} here. Choose a different model, then check again.`;
+        case "transient":
+            return `${tool} is busy or out of reach right now. Check again in a few minutes.`;
+        case "not-installed":
+            return `${tool} isn't installed on this computer. Install ${tool} from HQ, then check again.`;
+        default:
+            return `${tool} stopped with an error. Check again in a minute.`;
+    }
+}
+export async function probeBotRuntime(opts) {
+    const now = opts.now ?? Date.now;
+    const started = now();
+    const runtime = opts.runtimeImpl ?? runtimeFor(opts.runtime);
+    const runTurn = opts.runTurn ?? runRuntimeTurn;
+    const tool = runtimeDisplayName(opts.runtime);
+    const model = opts.model?.trim() || null;
+    const scratch = fs.mkdtempSync(path.join(os.tmpdir(), "hq-bot-probe-"));
+    const systemPromptFile = path.join(scratch, "system-prompt.md");
+    fs.writeFileSync(systemPromptFile, PROBE_SYSTEM_PROMPT + "\n");
+    const cwd = opts.cwd ?? path.join(scratch, "work");
+    fs.mkdirSync(cwd, { recursive: true });
+    const base = { runtime: opts.runtime, model };
+    try {
+        const turn = await runTurn(runtime, {
+            prompt: PROBE_PROMPT,
+            systemPrompt: PROBE_SYSTEM_PROMPT,
+            systemPromptFile,
+            cwd,
+            hqRoot: cwd,
+            autoApprove: opts.autoApprove !== false,
+            ...(model ? { model } : {}),
+            ...(opts.effort?.trim() ? { effort: opts.effort.trim() } : {}),
+            env: turnEnv(opts.env ?? process.env, "personal"),
+        }, { timeoutMs: opts.timeoutMs ?? PROBE_DEFAULT_TIMEOUT_MS });
+        const durationMs = now() - started;
+        if (turn.modelFallback) {
+            const { from, to } = turn.modelFallback;
+            return {
+                ok: true,
+                class: null,
+                detail: `${tool} works, but it is too old for ${from || "its configured model"}, so it answered on ${to}. Update ${tool} to use ${from || "that model"}.`,
+                ...base,
+                modelFallback: turn.modelFallback,
+                durationMs,
+            };
+        }
+        return { ok: true, class: null, detail: `${tool} answered${model ? ` on ${model}` : ""}.`, ...base, durationMs };
+    }
+    catch (err) {
+        const raw = err instanceof RuntimeError ? `${err.message}\n${err.stderrExcerpt}` : err instanceof Error ? err.message : String(err);
+        // Same rule as a bot turn: the runtime's reported error decides, never a tail of its output.
+        const cls = classifyRuntimeError(err);
+        return {
+            ok: false,
+            class: cls,
+            detail: probeFailureText(cls, opts.runtime),
+            ...base,
+            diagnostic: raw.slice(0, 400),
+            durationMs: now() - started,
+        };
+    }
+    finally {
+        fs.rmSync(scratch, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=probe.js.map

package/dist/lib/bot/run.d.ts

@@ -147,6 +147,8 @@ export interface BotRunDeps {
     maxParallelTurns?: number;
     /** Wait between retries while the coding tool needs a sign-in (default SIGN_IN_RETRY_MS). */
     signInRetryMs?: number;
+    /** How long model turns are held after FAILURE_LIMIT failures in a window (default FAILURE_WINDOW_MS). */
+    modelHoldMs?: number;
     /**
      * Downloads a chat attachment's bytes with the bot's own machine identity
      * (vault presign). Unset = attachments are listed with a "cannot download"
@@ -202,6 +204,8 @@ export declare function didNotFinishText(reason: string, progressPosted: boolean
 export { containsNoReplySentinel };
 /** Grok emits is_error with this message when the model produces only reasoning tokens. */
 export declare function isReasoningOnlyError(excerpt: string): boolean;
+/** The one note a person gets when the bot pauses after repeated failures. */
+export declare function holdNoticeText(holdMs: number, messagePending: boolean): string;
 /** Owner stop, `hq bot stop` or `hq bot restart`: all arrive as the same signal. */
 export declare const STOPPED_BY_OWNER_REASON = "I was stopped before I was done";
 export declare const RESTARTED_REASON = "I was restarted while I was working on it";