@indigoai-us/hq-cli 5.130.0 → 5.132.0

package/dist/commands/files.js

@@ -8,6 +8,13 @@ import { GROUP_ID_PATTERN, EMAIL_PATTERN, normalizeFilePrefix } from "./_pattern
 import { looksLikeCompanyUid } from "../utils/vault-api.js";
 import { AuthError } from "../utils/auth-error.js";
 import { formatAccessDenied, offerAccessLadder, } from "../utils/access-denied-hint.js";
+import { fetchChannels, matchChannelsByName } from "./dm.js";
+import { resolveCompanySlug, resolvePersonWithRosterFallback, } from "./people.js";
+import { findHqRoot } from "../utils/manifest.js";
+const PERSON_UID_PATTERN = /^(prs|agt)_[A-Za-z0-9_-]+$/;
+function collectMentions(value, previous) {
+    return [...previous, value];
+}
 // ---------------------------------------------------------------------------
 // Pure helpers (exported for unit tests)
 // ---------------------------------------------------------------------------
@@ -129,8 +136,23 @@ export function registerFilesCommand(program) {
         .option("--full", "Grant access to the ENTIRE vault (the '*' wildcard prefix) — no need to quote a glob. Requires --with; defaults to write permission.")
         .option("--expires <duration>", "Token expiry duration for share-session URL (e.g. 15m, 1h, 24h). Default 15m. Max 24h.")
         .option("--no-open", "Print the share-session URL but do not launch the browser")
+        .option("--channel <name>", "Post the share record to this named channel instead of a DM")
+        .option("--mention <person>", "Mention a person on the channel share record (repeatable)", collectMentions, [])
         .action(async (paths, opts) => {
         try {
+            const mentions = opts.mention ?? [];
+            if (mentions.length > 0 && opts.channel === undefined) {
+                console.error(chalk.red("--mention requires --channel <name>."));
+                process.exit(1);
+            }
+            const companySlug = files.opts().company;
+            const channelTarget = opts.channel !== undefined
+                ? await resolveShareChannelTarget({
+                    channelName: opts.channel,
+                    mentions,
+                    companySlug,
+                })
+                : undefined;
             // Full-vault grant: a glob-safe affordance for "give this person the
             // whole vault" so admins never have to quote a `*` (an unquoted glob
             // expands to local filenames and instantly fails the one-prefix
@@ -150,8 +172,9 @@ export function registerFilesCommand(program) {
                     prefix: "*",
                     principal: opts.with,
                     permission: opts.permission ?? "write",
-                    companySlug: files.opts().company,
+                    companySlug,
                     fullVault: true,
+                    ...channelTarget,
                 });
                 return;
             }
@@ -159,9 +182,9 @@ export function registerFilesCommand(program) {
                 console.error(chalk.red("usage: hq files share <paths...> [--with <principal>]"));
                 process.exit(1);
             }
-            // Fork: --with present → existing direct-grant path. No --with →
-            // browser-launch share-session path. The direct-grant path
-            // operates on a single prefix.
+            // Fork: --with present → existing direct-grant path. --channel without
+            // --with grants each --mention as a person. No --with and no --channel
+            // → browser-launch share-session path.
             if (opts.with !== undefined) {
                 if (paths.length !== 1) {
                     console.error(chalk.red("Direct grant (--with) takes exactly one prefix. Pass multiple paths only when minting a share-session URL."));
@@ -171,15 +194,42 @@ export function registerFilesCommand(program) {
                     prefix: paths[0],
                     principal: opts.with,
                     permission: opts.permission,
-                    companySlug: files.opts().company,
+                    companySlug,
+                    ...channelTarget,
                 });
                 return;
             }
+            if (channelTarget) {
+                if (channelTarget.mentionPersonUids.length === 0) {
+                    console.error(chalk.red("--channel requires --with <principal> or --mention <person>."));
+                    process.exit(1);
+                }
+                if (paths.length !== 1) {
+                    console.error(chalk.red("Channel share takes exactly one prefix. Pass multiple paths only when minting a share-session URL."));
+                    process.exit(1);
+                }
+                const permission = opts.permission ?? "read";
+                for (const [index, uid] of channelTarget.mentionPersonUids.entries()) {
+                    await runDirectGrant({
+                        prefix: paths[0],
+                        principal: uid,
+                        permission,
+                        companySlug,
+                        ...(index === 0
+                            ? {
+                                channelId: channelTarget.channelId,
+                                mentionPersonUids: channelTarget.mentionPersonUids,
+                            }
+                            : {}),
+                    });
+                }
+                return;
+            }
             await runShareSession({
                 paths,
                 expires: opts.expires,
                 launchBrowser: opts.open,
-                companySlug: files.opts().company,
+                companySlug,
             });
         }
         catch (err) {
@@ -511,6 +561,64 @@ export function registerFilesCommand(program) {
     // files-browse.ts) onto the same group without re-creating it.
     return files;
 }
+async function resolveShareChannelTarget(params) {
+    const token = (await resolveVaultCredential()).token;
+    const channels = await fetchChannels(token);
+    const matches = matchChannelsByName(channels, params.channelName);
+    if (matches.length === 0) {
+        console.error(chalk.red(`No channel named '${params.channelName}' — run \`hq channels\` to see your channels.`));
+        process.exit(1);
+    }
+    if (matches.length > 1) {
+        const scopes = matches
+            .map((c) => c.scope ?? "unknown")
+            .join(", ");
+        console.error(chalk.red(`'${params.channelName}' matches ${matches.length} channels (${scopes}) — this is ambiguous.`));
+        process.exit(1);
+    }
+    const channelId = matches[0].channelId;
+    const mentionPersonUids = [];
+    for (const mention of params.mentions) {
+        mentionPersonUids.push(await resolveMentionPersonUid(mention, params.companySlug));
+    }
+    return { channelId, mentionPersonUids };
+}
+async function resolveMentionPersonUid(mention, companySlug) {
+    const trimmed = mention.trim();
+    if (PERSON_UID_PATTERN.test(trimmed))
+        return trimmed;
+    const hqRoot = findHqRoot();
+    const slug = resolveCompanySlug(hqRoot, companySlug);
+    const result = await resolvePersonWithRosterFallback({
+        hqRoot,
+        slug,
+        name: trimmed,
+    });
+    if (result.status === "found" && result.person.personUid) {
+        return result.person.personUid;
+    }
+    if (result.status === "ambiguous") {
+        const names = result.matches.map((p) => p.name).join(", ");
+        console.error(chalk.red(`'${trimmed}' matches multiple people (${names}) — use a person uid or email.`));
+        process.exit(1);
+    }
+    const membership = await resolvePersonWithRosterFallback({
+        hqRoot,
+        slug,
+        name: trimmed,
+        opts: { membershipOnly: true },
+    });
+    if (membership.status === "found" && membership.person.personUid) {
+        return membership.person.personUid;
+    }
+    if (membership.status === "ambiguous") {
+        const names = membership.matches.map((p) => p.name).join(", ");
+        console.error(chalk.red(`'${trimmed}' matches multiple people (${names}) — use a person uid or email.`));
+        process.exit(1);
+    }
+    console.error(chalk.red(`Could not resolve --mention '${trimmed}' to a person.`));
+    process.exit(1);
+}
 async function runDirectGrant(params) {
     const canonicalPrefix = normalizeCompanyFilePrefix(params.prefix, {
         mutating: true,
@@ -535,11 +643,18 @@ async function runDirectGrant(params) {
     const isAll = principal === "@all";
     const isEmail = !isAll && EMAIL_PATTERN.test(principal);
     const isGroup = !isAll && GROUP_ID_PATTERN.test(principal);
-    if (!isAll && !isEmail && !isGroup) {
-        console.error(chalk.red(`Invalid principal '${principal}': must be '@all', an email address, or a group id matching grp_<alphanumeric>`));
+    const isPerson = !isAll && !isEmail && !isGroup && PERSON_UID_PATTERN.test(principal);
+    if (!isAll && !isEmail && !isGroup && !isPerson) {
+        console.error(chalk.red(`Invalid principal '${principal}': must be '@all', an email address, a person uid, or a group id matching grp_<alphanumeric>`));
         process.exit(1);
     }
-    const granteeType = isAll ? "company-wide" : isEmail ? "email" : "group";
+    const granteeType = isAll
+        ? "company-wide"
+        : isEmail
+            ? "email"
+            : isPerson
+                ? "person"
+                : "group";
     const granteeId = isAll
         ? ""
         : isEmail
@@ -558,6 +673,10 @@ async function runDirectGrant(params) {
             granteeType,
             granteeId,
             permission: params.permission,
+            ...(params.channelId ? { channelId: params.channelId } : {}),
+            ...(params.mentionPersonUids && params.mentionPersonUids.length > 0
+                ? { mentionPersonUids: params.mentionPersonUids }
+                : {}),
         },
     });
     // No ACL row exists yet for this prefix. Auto-create one with this
@@ -572,6 +691,10 @@ async function runDirectGrant(params) {
             body: {
                 prefix: canonicalPrefix,
                 entries: [{ granteeType, granteeId, permission: params.permission }],
+                ...(params.channelId ? { channelId: params.channelId } : {}),
+                ...(params.mentionPersonUids && params.mentionPersonUids.length > 0
+                    ? { mentionPersonUids: params.mentionPersonUids }
+                    : {}),
             },
         });
         autoCreated = res.ok;
@@ -610,6 +733,11 @@ async function runDirectGrant(params) {
     else {
         console.log(chalk.green(`${verb} ${params.permission} on ${printedPrefix} to ${principalLabel}`));
     }
+    if (typeof data.record?.error === "string" &&
+        typeof data.record.status === "number" &&
+        data.record.status >= 400) {
+        console.log(data.record.error);
+    }
 }
 async function runShareSession(params) {
     // Validate every path before minting a session; an anchored path must never

package/dist/commands/lanes.d.ts

@@ -10,6 +10,7 @@ import { emitLaneDecisionEvents, type LaneMesh } from "../lib/lanes/mesh-events.
 import { type LaneCompanyRef, type LaneRecord, type QuestionRecord, type ResolvedLaneWorker, type SeniorRef, type LivenessDeps, type MachineIdentity, type RunCommand, type ThrottleDeps } from "../lib/lanes/index.js";
 import { questionBodyAbsPath } from "../lib/lanes/questions.js";
 import { type RunCompactionFn } from "../lib/lanes/compaction.js";
+import { type KnownModelsDeps, type ProbeCommand } from "../lib/lanes/models.js";
 import { spawnLaneWorker, type KillProcessFn, type ProveDetachedFn, type SpawnProcessFn } from "../lib/lanes/spawn.js";
 export { spawnLaneWorker };
 export { questionBodyAbsPath };
@@ -62,6 +63,8 @@ export interface LanesCommandDeps {
     presenceConnected?: boolean;
     systemdRoot?: string;
     runSystemctl?: RunCommand;
+    /** Provider CLI probe for --model validation; tests inject a fake. */
+    probeProvider?: ProbeCommand;
     resolveMachineIdentity?: () => MachineIdentity;
     stageOutpostPayload?: (outpostId: string, bytes: Uint8Array) => Promise<{
         getUrl: string;
@@ -100,14 +103,22 @@ export declare function composeWorkerBrief(worker: ResolvedLaneWorker, taskBrief
  */
 export declare function composeGeneralBrief(taskBrief: string): string;
 export declare function parseMaxRuntimeSeconds(raw: unknown, workerId: string): number | undefined;
-export declare const PICKUP_TERMINAL_REASONS: readonly ["account_not_logged_in", "unknown_account", "account_disabled"];
+export declare const PICKUP_TERMINAL_REASONS: readonly ["account_not_logged_in", "unknown_account", "account_disabled", "model_unsupported"];
 export declare const DISPATCH_TERMINAL_REASON: "outpost_dispatch_failed";
 export type PickupTerminalReason = (typeof PICKUP_TERMINAL_REASONS)[number];
+/**
+ * The CAS updater a pickup failure applies. A lane that is already terminal
+ * for any reason (a cancel that landed after the caller's last read, an
+ * earlier pickup failure) is returned unchanged: the guard lives inside the
+ * same compare-and-swap that writes the failure, so no read-then-write gap
+ * can overwrite another writer's terminal decision.
+ */
+export declare function pickupFailureUpdater(reasonRaw: string, details: Record<string, unknown>): (current: LaneRecord) => LaneRecord;
 /**
  * Outpost-side account bind (spec §5.2). Writes a named terminal reason,
  * never a plain `failed`.
  */
-export declare function applyOutpostAccountPickup(hqRoot: string, laneId: string): LaneRecord;
+export declare function applyOutpostAccountPickup(hqRoot: string, laneId: string, modelDeps?: KnownModelsDeps): LaneRecord;
 export declare function cancelPendingQuestionsForLane(hqRoot: string, laneId: string, nowIso: string, operatorReason?: string): QuestionRecord[];
 export declare function stopCommittedState(state: LaneRecord["state"]): "cancelled" | "killed";
 export declare function registerLanesCommand(parent: Command, deps?: LanesCommandDeps): Command;