@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/commands/core-dm-bind-native.js

@@ -0,0 +1,668 @@
+/** Native implementation of core/scripts/hq-dm-bind.sh. */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { resolveLiveRoot } from "../utils/hq-roots.js";
+import { bundledShellUnboundValue, registerNativeUtility, utilityError } from "./core-native-utilities.js";
+export const DM_BIND_ASSET = "core/scripts/hq-dm-bind.sh";
+export const DM_BIND_HELP = `# hq-dm-bind.sh — bind the current session to one HQ DM channel, post
+# structured updates to it, and listen for replies (feedback / requests).
+#
+# Usage:
+#   core/scripts/hq-dm-bind.sh bind <channel>                 # bind + set the read cursor to "now"
+#   core/scripts/hq-dm-bind.sh status                         # show the binding and cursor
+#   core/scripts/hq-dm-bind.sh post --title <t> [--state <s>] [--line <l>]... [--next <l>]... [--ask <l>]... [--to <name>]... [--topic <t>] [--under <id>] [--new-thread]
+#   core/scripts/hq-dm-bind.sh post --title <t> - < body.md    # body from stdin (already structured)
+#   core/scripts/hq-dm-bind.sh threads                        # list the channel's recent top-level threads (id, replies, author, text)
+#   core/scripts/hq-dm-bind.sh roster                         # print the channel members a post will @-mention
+#   core/scripts/hq-dm-bind.sh poll                           # print new messages since the cursor, advance it
+#   core/scripts/hq-dm-bind.sh listen [--interval 60] [--timeout 1800]
+#                                                             # block until a new message arrives (or timeout)
+#   core/scripts/hq-dm-bind.sh unbind
+#
+# The binding lives in the session's meta.yaml (\`dm_channel\`) via hq-session.sh;
+# the cursor is \`workspace/sessions/<sid>/dm-bind.cursor\` (the last seen sort
+# key from \`hq dm channel --json\`). \`listen\` is meant to run detached
+# (Bash run_in_background): it exits 0 and prints the new messages the moment
+# one lands, exits 3 on timeout with nothing new.
+#
+# Every post opens with an @-mention of every other member of the channel, so
+# the update reaches people (HQ mentions are structured: the \`hq\` CLI resolves
+# the \`@"Display Name"\` tokens against the roster and sends the real mention
+`;
+export const createDmBindDeps = (root, cwd, env, now, home = env.HOME || os.homedir()) => ({
+    root, cwd, env, home, now, fs,
+    runHq: (args, childEnv) => {
+        const result = spawnSync("hq", args, { cwd, env: { ...childEnv, HQ_ROOT: root }, encoding: "utf8" });
+        return { code: result.status ?? 127, stdout: result.stdout ?? "", stderr: result.stderr ?? (result.error ? `${result.error.message}\n` : "") };
+    },
+    runHqSession: (args, childEnv) => {
+        const result = spawnSync("bash", [path.join(root, "core/scripts/hq-session.sh"), ...args], { cwd, env: childEnv, encoding: "utf8" });
+        return { code: result.status ?? 127, stdout: result.stdout ?? "", stderr: result.stderr ?? (result.error ? `${result.error.message}\n` : "") };
+    },
+    fetch: globalThis.fetch,
+    readStdin: () => new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => { data += chunk; });
+        process.stdin.on("end", () => resolve(data));
+        process.stdin.on("error", reject);
+    }),
+    sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+});
+const fail = (message, code = 2) => utilityError(`hq-dm-bind: ${message}`, code);
+const sessionDirectory = (d, sid) => path.join(d.root, "workspace/sessions", sid);
+const filePath = (d, sid, name) => path.join(sessionDirectory(d, sid), name);
+const sessionArgs = (d, args) => d.runHqSession(args, d.env);
+const validSid = (value) => value !== "" && value !== "." && value !== ".." && /^[A-Za-z0-9._-]+$/.test(value);
+export function resolveDmBindSessionId(d) {
+    for (const key of ["HQ_SESSION_ID", "CLAUDE_CODE_SESSION_ID", "CLAUDE_SESSION_ID", "CODEX_SESSION_ID", "CODEX_THREAD_ID", "GROK_SESSION_ID"]) {
+        const candidate = (d.env[key] ?? "").replace(/\s/g, "");
+        if (validSid(candidate))
+            return candidate;
+    }
+    try {
+        const candidate = d.fs.readFileSync(path.join(d.root, "workspace/sessions/.current"), "utf8").replace(/\s/g, "");
+        return validSid(candidate) ? candidate : "";
+    }
+    catch {
+        return "";
+    }
+}
+function sessionId(d) {
+    const result = sessionArgs(d, ["current"]);
+    return result.stdout.replace(/\n+$/g, "");
+}
+function channel(d) {
+    const result = sessionArgs(d, ["get", "dm_channel"]);
+    return result.code === 0 ? result.stdout.replace(/"/g, "").replace(/\n+$/g, "") : "";
+}
+function requireChannel(d) {
+    const value = channel(d);
+    return value && value !== "null" ? value : fail("session is not bound — run: core/scripts/hq-dm-bind.sh bind <channel>");
+}
+function ensureDir(d, sid) {
+    const directory = sessionDirectory(d, sid);
+    d.fs.mkdirSync(directory, { recursive: true });
+    return directory;
+}
+function hasHqOnPath(d) {
+    for (const directory of (d.env.PATH ?? "").split(path.delimiter)) {
+        if (!directory)
+            continue;
+        try {
+            const stat = d.fs.statSync(path.join(directory, "hq"));
+            if (stat.isFile() && (stat.mode & 0o111) !== 0)
+                return true;
+        }
+        catch { /* PATH entry is absent */ }
+    }
+    return false;
+}
+function textFile(d, file) {
+    try {
+        return d.fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function jsonObject(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function itemsFromHq(d, ch, limit = 30) {
+    const result = d.runHq(["dm", "channel", ch, "--limit", String(limit), "--json"], { ...d.env, HQ_ROOT: d.root });
+    try {
+        const parsed = JSON.parse(result.stdout);
+        const object = parsed;
+        const rows = Array.isArray(parsed) ? parsed : (jqAlternative(jqAlternative(object?.messages, object?.items), []));
+        return Array.isArray(rows) ? rows.filter((row) => !!row && typeof row === "object" && !Array.isArray(row)) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function jqAlternative(value, fallback) {
+    return value === null || value === undefined || value === false ? fallback : value;
+}
+function latestSk(d, ch, limit = 5) {
+    const rows = itemsFromHq(d, ch, limit);
+    return String(jqAlternative(rows.at(-1)?.sk, ""));
+}
+function cliVersion(d) {
+    const result = d.runHq(["--version"], { ...d.env, HQ_ROOT: d.root });
+    if (result.code !== 0)
+        throw new Error("hq-dm-bind: could not read the installed hq-cli version");
+    const first = result.stdout.match(/^CLI\s+([0-9]+(?:\.[0-9]+){2})/m)?.[1];
+    return first ?? result.stdout.match(/[0-9]+\.[0-9]+\.[0-9]+/)?.[0] ?? "";
+}
+function requireCliVersion(d) {
+    let actual;
+    try {
+        actual = cliVersion(d);
+    }
+    catch (error) {
+        return utilityError(String(error instanceof Error ? error.message : error), 2);
+    }
+    const nums = actual.split(".").map(Number);
+    const okay = nums.length === 3 && (nums[0] > 5 || (nums[0] === 5 && (nums[1] > 137 || (nums[1] === 137 && nums[2] >= 0))));
+    return okay ? undefined : utilityError(`hq-dm-bind: hq-cli >= 5.137.0 is required for machine-principal DM binding (found ${actual || "unknown"}); update hq-cli and retry.`, 2);
+}
+function usesCliAuth(d) {
+    try {
+        d.fs.accessSync(path.join(d.home, ".hq/config.json"), fs.constants.R_OK);
+        d.fs.accessSync(path.join(d.home, ".hq/cognito-tokens.json"), fs.constants.R_OK);
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+function whoamiText(d, json = false) {
+    const result = d.runHq(json ? ["whoami", "--json"] : ["whoami"], { ...d.env, HQ_ROOT: d.root });
+    return result.code === 0 ? result.stdout : "";
+}
+function selfEmail(d) { return whoamiText(d).match(/[A-Za-z0-9._+-]+@[A-Za-z0-9.-]+\.[A-Za-z]+/)?.[0] ?? ""; }
+function slug(value) { return String(value ?? "").trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, ""); }
+async function fetchRoster(d, ch) {
+    const me = selfEmail(d);
+    if (usesCliAuth(d)) {
+        const versionError = requireCliVersion(d);
+        if (versionError)
+            return { stdout: "", stderr: versionError.stderr };
+        const result = d.runHq(["channels", "members", ch], { ...d.env, HQ_ROOT: d.root });
+        return { stdout: result.stdout, stderr: result.code === 0 ? result.stderr : `${result.stderr}hq-dm-bind: could not read the channel roster through hq-cli\n` };
+    }
+    try {
+        const config = JSON.parse(d.fs.readFileSync(path.join(d.home, ".hq/config.json"), "utf8"));
+        const token = JSON.parse(d.fs.readFileSync(path.join(d.home, ".hq/cognito-tokens.json"), "utf8")).idToken;
+        const headers = { Authorization: `Bearer ${token}` };
+        const response = await d.fetch(`${config.vaultApiUrl}/v1/notify/channels`, { headers });
+        const channels = await response.json();
+        const rows = Array.isArray(channels) ? channels : channels.channels ?? [];
+        const hit = rows.find((entry) => entry.channelId === ch || slug(entry.name) === slug(ch) || entry.slug === slug(ch));
+        if (!hit?.channelId)
+            return { stdout: "", stderr: "" };
+        const membersResponse = await d.fetch(`${config.vaultApiUrl}/v1/notify/channels/${encodeURIComponent(String(hit.channelId))}/members`, { headers });
+        const members = await membersResponse.json();
+        const list = Array.isArray(members) ? members : members.members ?? [];
+        const lines = list.flatMap((member) => {
+            if (me && String(member.email ?? "").toLowerCase() === me.toLowerCase())
+                return [];
+            const name = String(member.displayName ?? "").trim();
+            const uid = String(member.personUid ?? member.participantUid ?? member.uid ?? "").trim();
+            return name ? [`${name}\t${uid}`] : [];
+        });
+        return { stdout: lines.length ? `${lines.join("\n")}\n` : "", stderr: "" };
+    }
+    catch {
+        return { stdout: "", stderr: "" };
+    }
+}
+async function roster(d, sid, ch) {
+    const file = filePath(d, sid, "dm-bind.roster");
+    if (usesCliAuth(d)) {
+        const versionError = requireCliVersion(d);
+        if (versionError)
+            return { names: [], stderr: versionError.stderr };
+    }
+    const fresh = await fetchRoster(d, ch);
+    let stderr = fresh.stderr;
+    if (fresh.stdout.trim())
+        d.fs.writeFileSync(file, `${fresh.stdout.replace(/\n+$/, "")}\n`);
+    const contents = textFile(d, file);
+    const names = contents.split(/\r?\n/).filter(Boolean).map((row) => row.split("\t")[0] ?? "");
+    return { names, stderr };
+}
+function rosterRows(d, sid) {
+    return textFile(d, filePath(d, sid, "dm-bind.roster")).split(/\r?\n/).filter(Boolean).map((row) => {
+        const [name = "", uid = ""] = row.split("\t");
+        return { name, uid };
+    });
+}
+function mentionsJson(d, sid, names) {
+    const uid = new Map(rosterRows(d, sid).map(({ name, uid: value }) => [name, value]));
+    return names.filter((name) => jqAlternative(uid.get(name), "") !== "").map((name) => {
+        const participantUid = uid.get(name);
+        return { participantUid, participantType: participantUid.startsWith("agt_") ? "agent" : "human", displayName: name };
+    });
+}
+function getTopicRoot(d, sid, topic) {
+    const rows = textFile(d, filePath(d, sid, "dm-bind.threads")).split(/\r?\n/);
+    let found = "";
+    for (const line of rows) {
+        const [key, root] = line.split("\t");
+        if (key === topic && root)
+            found = root;
+    }
+    return found;
+}
+function addTopicRoot(d, sid, topic, root) {
+    d.fs.appendFileSync(filePath(d, sid, "dm-bind.threads"), `${topic}\t${root}\n`);
+}
+function recentRoots(d, ch) { return itemsFromHq(d, ch, 100).filter((row) => !row.rootEventId); }
+function resolveRoot(d, ch, prefix) {
+    const hits = recentRoots(d, ch).map((row) => String(jqAlternative(row.eventId, ""))).filter((id) => id.startsWith(prefix));
+    if (!hits.length)
+        return fail(`--under '${prefix}' matches no recent top-level message (see: hq-dm-bind.sh threads)`);
+    if (hits.length !== 1)
+        return fail(`--under '${prefix}' matches several messages — use more of the id`);
+    return hits[0];
+}
+function findMentions(d, sid, ch, tos) {
+    // Caller ensures the directory exists before using these per-session files.
+    const content = textFile(d, filePath(d, sid, "dm-bind.roster"));
+    const allNames = content.split(/\r?\n/).filter(Boolean).map((line) => line.split("\t")[0] ?? "");
+    const stderr = "";
+    if (!allNames.length)
+        return { names: [], stderr, error: fail("could not read the channel roster — not posting an update that notifies nobody (check `hq whoami` and that node is on PATH, then retry)") };
+    const rows = rosterRows(d, sid);
+    let selected;
+    if (!tos.length) {
+        selected = rows.filter((row) => !row.uid.startsWith("agt_")).map((row) => row.name);
+        if (!selected.length)
+            selected = allNames;
+    }
+    else {
+        selected = [];
+        for (let want of tos) {
+            want = want.replace(/^@/, "");
+            let hit = allNames.find((name) => name.toLowerCase() === want.toLowerCase()) ?? "";
+            if (!hit) {
+                const matches = allNames.filter((name) => name.toLowerCase().includes(want.toLowerCase()));
+                if (matches.length === 1)
+                    hit = matches[0];
+            }
+            if (!hit) {
+                const members = allNames.map((name) => `  ${name}`).join("\n");
+                return { names: [], stderr: "", error: utilityError(`hq-dm-bind: --to '${want}' does not match exactly one channel member. Members:\n${members}`, 2) };
+            }
+            if (!selected.includes(hit))
+                selected.push(hit);
+        }
+    }
+    return { value: selected.map((name) => `@"${name}"`).join(" "), names: selected, stderr };
+}
+function identity(d) {
+    const raw = whoamiText(d, true);
+    const parsed = jsonObject(raw);
+    return parsed ?? utilityError("hq-dm-bind: hq-cli returned an invalid identity", 1);
+}
+function isUtilityOutput(value) {
+    return typeof value.code === "number" && typeof value.stdout === "string" && typeof value.stderr === "string";
+}
+function latestCliEventId(d, ch) {
+    const who = identity(d);
+    if (isUtilityOutput(who))
+        return who;
+    const agent = String(jqAlternative(who.agentUid, ""));
+    const username = String(jqAlternative(who.username, ""));
+    const person = String(jqAlternative(who.personUid, ""));
+    const email = String(jqAlternative(who.email, ""));
+    const rows = itemsFromHq(d, ch, 50).filter((row) => {
+        if (agent || username) {
+            const sender = String(jqAlternative(row.senderMachineUid, jqAlternative(row.fromMachineUid, "")));
+            return sender === agent || sender === username;
+        }
+        if (person)
+            return row.fromPersonUid === person;
+        if (email)
+            return String(jqAlternative(row.fromEmail, "")).toLowerCase() === email.toLowerCase();
+        return false;
+    });
+    return String(jqAlternative(rows.at(-1)?.eventId, jqAlternative(rows.at(-1)?.messageId, "")));
+}
+async function sendHuman(d, ch, payload) {
+    const config = JSON.parse(d.fs.readFileSync(path.join(d.home, ".hq/config.json"), "utf8"));
+    const token = JSON.parse(d.fs.readFileSync(path.join(d.home, ".hq/cognito-tokens.json"), "utf8")).idToken;
+    const headers = { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
+    const channelsResponse = await d.fetch(`${config.vaultApiUrl}/v1/notify/channels`, { headers });
+    const channels = await channelsResponse.json();
+    const rows = Array.isArray(channels) ? channels : channels.channels ?? [];
+    const hit = rows.find((entry) => entry.channelId === ch || slug(entry.name) === slug(ch) || entry.slug === slug(ch));
+    if (!hit?.channelId)
+        throw new Error(`channel not found: ${ch}`);
+    const response = await d.fetch(`${config.vaultApiUrl}/v1/notify/channels/${encodeURIComponent(String(hit.channelId))}/messages`, {
+        method: "POST", headers, body: JSON.stringify(payload),
+    });
+    const text = await response.text();
+    if (!response.ok)
+        throw new Error(`post failed: HTTP ${response.status} ${text.slice(0, 300)}`);
+    let json = {};
+    try {
+        json = JSON.parse(text);
+    }
+    catch { /* jq shell ignores malformed receipt JSON */ }
+    const message = jqAlternative(json.message, jqAlternative(json.event, json));
+    const sk = typeof message.sk === "string" && message.sk.includes("#") ? message.sk.split("#").at(-1) : "";
+    return String(jqAlternative(message.eventId, jqAlternative(sk, "")));
+}
+const stringValue = (value, fallback = "") => typeof value === "string" ? value : fallback;
+async function bind(d, arg) {
+    if (!arg)
+        return fail("bind needs a channel name (see: hq channels)");
+    const ch = arg.replace(/^#/, "");
+    const channels = d.runHq(["channels"], { ...d.env, HQ_ROOT: d.root });
+    if (channels.code !== 0 || !channels.stdout.includes(`hq dm ${ch} `))
+        return fail(`no channel named '${ch}' (see: hq channels)`);
+    const set = sessionArgs(d, ["set", "dm_channel", ch]);
+    if (set.code !== 0)
+        return { code: set.code, stdout: "", stderr: set.stderr };
+    const sk = latestSk(d, ch);
+    const sid = sessionId(d);
+    ensureDir(d, sid);
+    d.fs.writeFileSync(filePath(d, sid, "dm-bind.cursor"), `${sk}\n`);
+    const result = await roster(d, sid, ch);
+    const n = result.names.length;
+    return { code: 0, stdout: `bound session ${sid} to #${ch} (cursor: ${sk || "<empty>"}; will @-mention ${n} member(s))\n`, stderr: result.stderr + (n ? "" : "hq-dm-bind: could not read the channel roster — posts will not @-mention anyone until it is readable\n") };
+}
+function status(d) {
+    const sid = sessionId(d);
+    if (sid)
+        ensureDir(d, sid);
+    const ch = channel(d);
+    const cursor = sid ? textFile(d, filePath(d, sid, "dm-bind.cursor")).replace(/\n$/, "") || "<none>" : "<none>";
+    const stderr = sid ? "" : "hq-dm-bind: no current session (hq-session.sh current is empty)\n";
+    return { code: 0, stdout: `session:  ${sid}\nchannel:  ${ch || "<none>"}\ncursor:   ${cursor}\n`, stderr };
+}
+function unbind(d) {
+    const set = sessionArgs(d, ["set", "dm_channel", ""]);
+    if (set.code !== 0)
+        return { code: set.code, stdout: "", stderr: set.stderr };
+    const sid = sessionId(d);
+    for (const name of ["dm-bind.cursor", "dm-bind.roster", "dm-bind.threads"])
+        d.fs.rmSync(filePath(d, sid, name), { force: true });
+    return { code: 0, stdout: "unbound\n", stderr: "" };
+}
+async function cmdRoster(d) {
+    const ch = requireChannel(d);
+    if (typeof ch !== "string")
+        return ch;
+    const sid = sessionId(d);
+    ensureDir(d, sid);
+    const result = await roster(d, sid, ch);
+    return { code: 0, stdout: result.names.length ? `${result.names.join("\n")}\n` : "", stderr: result.stderr };
+}
+async function cmdThreads(d) {
+    const ch = requireChannel(d);
+    if (typeof ch !== "string")
+        return ch;
+    const rows = recentRoots(d, ch).slice(-25).map((row) => {
+        const eventId = Array.from(String(jqAlternative(row.eventId, ""))).slice(0, 8).join("");
+        const body = Array.from(String(jqAlternative(row.body, "")).replace(/\s+/g, " ")).slice(0, 90).join("");
+        return `${eventId}\t${String(jqAlternative(row.replyCount, 0))}\t${String(jqAlternative(row.fromDisplayName, "?"))}: ${body}`;
+    });
+    return { code: 0, stdout: rows.length ? `${rows.join("\n")}\n` : "", stderr: "" };
+}
+function formatMessages(rows, cursor, own) {
+    return rows.filter((row) => String(jqAlternative(row.sk, "")) > cursor && !own(row)).map((row) => {
+        const sk = Array.from(String(jqAlternative(row.sk, ""))).slice(0, 16).join("").replace("T", " ");
+        const name = String(jqAlternative(row.fromDisplayName, jqAlternative(row.fromEmail, "?")));
+        const body = String(jqAlternative(row.body, "")).replace(/^\s+|\s+$/g, "");
+        return `${sk}Z ${name}: ${body}`;
+    }).join("\n");
+}
+async function poll(d) {
+    const ch = requireChannel(d);
+    if (typeof ch !== "string")
+        return ch;
+    const sid = sessionId(d);
+    ensureDir(d, sid);
+    const cursor = textFile(d, filePath(d, sid, "dm-bind.cursor"));
+    const rows = itemsFromHq(d, ch, 50);
+    const last = String(jqAlternative(rows.at(-1)?.sk, ""));
+    let own;
+    if (usesCliAuth(d)) {
+        const who = identity(d);
+        if ("code" in who)
+            return { code: 2, stdout: "", stderr: `${who.stderr}${fail("could not read the hq-cli identity — not polling").stderr}` };
+        const agent = String(jqAlternative(who.agentUid, ""));
+        const username = String(jqAlternative(who.username, ""));
+        const person = String(jqAlternative(who.personUid, ""));
+        const email = String(jqAlternative(who.email, ""));
+        own = (row) => {
+            if (agent || username) {
+                const sender = String(jqAlternative(row.senderMachineUid, jqAlternative(row.fromMachineUid, "")));
+                return sender === agent || sender === username;
+            }
+            if (person)
+                return String(jqAlternative(row.fromPersonUid, "")) === person;
+            if (email)
+                return String(jqAlternative(row.fromEmail, "")).toLowerCase() === email.toLowerCase();
+            return false;
+        };
+    }
+    else {
+        const me = selfEmail(d);
+        own = (row) => me !== "" && row.fromEmail === me;
+    }
+    const messages = formatMessages(rows, cursor, own);
+    if (last)
+        d.fs.writeFileSync(filePath(d, sid, "dm-bind.cursor"), `${last}\n`);
+    return messages.trim() ? { code: 0, stdout: `${messages}\n`, stderr: "" } : { code: 3, stdout: "", stderr: "" };
+}
+async function post(d, args) {
+    const ch = requireChannel(d);
+    if (typeof ch !== "string")
+        return ch;
+    let title = "", state = "", stdin = false, topic = "", newThread = false, under = "", allowLong = false;
+    const lines = [], nexts = [], asks = [], tos = [];
+    for (let i = 0; i < args.length;) {
+        const arg = args[i];
+        if (["--topic", "--under", "--to", "--title", "--state", "--line", "--next", "--ask"].includes(arg)) {
+            if (args[i + 1] === undefined) {
+                const sourceLines = { "--topic": 383, "--title": 388, "--state": 389, "--line": 390, "--next": 391, "--ask": 392 };
+                if (sourceLines[arg] !== undefined)
+                    return bundledShellUnboundValue(DM_BIND_ASSET, sourceLines[arg]);
+            }
+            const value = args[i + 1] ?? "";
+            if (arg === "--under" && !value)
+                return fail("post: --under needs a message id (see: threads)");
+            if (arg === "--to" && !value)
+                return fail("post: --to needs a member name");
+            if (arg === "--topic")
+                topic = value;
+            else if (arg === "--under")
+                under = value;
+            else if (arg === "--to")
+                tos.push(value);
+            else if (arg === "--title")
+                title = value;
+            else if (arg === "--state")
+                state = value;
+            else if (arg === "--line")
+                lines.push(value);
+            else if (arg === "--next")
+                nexts.push(value);
+            else
+                asks.push(value);
+            i += 2;
+        }
+        else if (arg === "--new-thread") {
+            newThread = true;
+            i += 1;
+        }
+        else if (arg === "--no-mention")
+            return fail("post: --no-mention was removed — every post @-mentions someone. Use --to <name> to address specific members.");
+        else if (arg === "--allow-long") {
+            allowLong = true;
+            i += 1;
+        }
+        else if (arg === "-") {
+            stdin = true;
+            i += 1;
+        }
+        else
+            return fail(`post: unknown arg ${arg}`);
+    }
+    if (!title)
+        return fail("post needs --title");
+    const errorLines = [];
+    if (!allowLong && !stdin) {
+        if (lines.length > 6)
+            errorLines.push(`hq-dm-bind: too many --line bullets (${lines.length}, limit 6). Put extra detail in workspace/reports/<name>.md and link it in one bullet. Use --allow-long to override.`);
+        if (nexts.length > 2)
+            errorLines.push(`hq-dm-bind: too many --next items (${nexts.length}, limit 2). Use --allow-long to override.`);
+        if (asks.length > 1)
+            errorLines.push(`hq-dm-bind: too many --ask items (${asks.length}, limit 1). Use --allow-long to override.`);
+        for (const [kind, values] of [["line", lines], ["next", nexts], ["ask", asks]])
+            for (const value of values) {
+                const length = Buffer.byteLength(value);
+                if (length > 140)
+                    errorLines.push(Buffer.concat([Buffer.from(`hq-dm-bind: --${kind} too long (${length} chars, limit 140): "`), Buffer.from(value).subarray(0, 60), Buffer.from('". Put the detail in workspace/reports/<name>.md and reference the path in one line. Use --allow-long to override.')]).toString("latin1"));
+            }
+        if (errorLines.length) {
+            const lines = errorLines.map((line) => Buffer.from(line, "latin1"));
+            return { code: 2, stdout: "", stderr: "", stderrBytes: Buffer.concat([...lines.flatMap((line, index) => index ? [Buffer.from("\n"), line] : [line]), Buffer.from("\n")]) };
+        }
+    }
+    let message = title + (state ? ` — ${state}` : "");
+    if (stdin)
+        message += `\n\n${(await d.readStdin()).replace(/\n+$/, "")}`;
+    else {
+        if (lines.length)
+            message += `\n${lines.map((line) => `\n• ${line}`).join("")}`;
+        if (nexts.length)
+            message += `\n${nexts.map((line) => `\nNext: ${line}`).join("")}`;
+        if (asks.length)
+            message += `\n${asks.map((line) => `\nNeed from you: ${line}`).join("")}`;
+    }
+    const sid = sessionId(d);
+    ensureDir(d, sid);
+    const fetched = await roster(d, sid, ch);
+    if (usesCliAuth(d) && fetched.names.length === 0 && fetched.stderr.startsWith("hq-dm-bind: hq-cli >= 5.137.0 is required")) {
+        return { code: 2, stdout: "", stderr: fetched.stderr + fail("could not read the channel roster — not posting an update that notifies nobody (check `hq whoami` and that node is on PATH, then retry)").stderr };
+    }
+    const mention = findMentions(d, sid, ch, tos);
+    if (mention.error)
+        return { ...mention.error, stderr: fetched.stderr + mention.error.stderr };
+    const mentionLine = mention.value ?? "";
+    if (!mentionLine)
+        return fail("could not read the channel roster — not posting an update that notifies nobody (check `hq whoami` and that node is on PATH, then retry)");
+    const shown = mentionLine.replace(/@"([^"]+)"/g, "@$1");
+    const names = mention.names;
+    const postedMessage = `${shown}\n\n${message}`;
+    const cliMessage = `${mentionLine}\n\n${message}`;
+    if (!allowLong && Buffer.byteLength(postedMessage) > 600)
+        return { code: 2, stdout: "", stderr: `hq-dm-bind: post body too long (${Buffer.byteLength(postedMessage)} chars, limit 600). Put the detail in workspace/reports/<name>.md and reference the path in one line. Use --allow-long to override.\n` };
+    const key = (topic || title).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+    let root = "";
+    if (under) {
+        const resolved = resolveRoot(d, ch, under);
+        if (typeof resolved !== "string")
+            return resolved;
+        root = resolved;
+        if (getTopicRoot(d, sid, key) !== root)
+            addTopicRoot(d, sid, key, root);
+    }
+    else if (!newThread)
+        root = getTopicRoot(d, sid, key);
+    let eventId = "";
+    if (usesCliAuth(d)) {
+        const versionError = requireCliVersion(d);
+        if (versionError)
+            return versionError;
+        const call = ["dm", ch, ...(root ? ["--thread", root] : []), cliMessage];
+        const sent = d.runHq(call, { ...d.env, HQ_ROOT: d.root });
+        if (sent.code !== 0)
+            return utilityError("hq-dm-bind: hq dm failed — nothing was sent\n", 1);
+        const readback = latestCliEventId(d, ch);
+        if (typeof readback !== "string")
+            return readback;
+        eventId = readback;
+        if (!eventId)
+            return utilityError("hq-dm-bind: post succeeded but its event id could not be read back\n", 1);
+    }
+    else {
+        const mentions = mentionsJson(d, sid, names);
+        if (!mentions.length)
+            return fail("no mention resolved to a channel member id — not posting an update that notifies nobody");
+        const payload = { body: postedMessage, mentions };
+        if (root)
+            payload.rootEventId = root;
+        try {
+            eventId = await sendHuman(d, ch, payload);
+        }
+        catch (error) {
+            return utilityError(`hq-dm-bind: ${error.message}\n`, 1);
+        }
+    }
+    if (!root) {
+        if (eventId)
+            addTopicRoot(d, sid, key, eventId);
+    }
+    const threadOutput = root ? `thread: reply under topic '${key}'\n` : `thread: new topic '${key}'${eventId ? ` (root ${eventId})` : ""}\n`;
+    d.fs.writeFileSync(filePath(d, sid, "dm-bind.cursor"), `${latestSk(d, ch)}\n`);
+    return { code: 0, stdout: `${threadOutput}posted to #${ch} (${Buffer.byteLength(postedMessage)} chars)\n`, stderr: fetched.stderr };
+}
+async function listen(d, args) {
+    let interval = 60, timeout = 1800;
+    for (let i = 0; i < args.length;) {
+        const arg = args[i];
+        if (arg !== "--interval" && arg !== "--timeout")
+            return fail(`listen: unknown arg ${arg}`);
+        if (args[i + 1] === undefined)
+            return bundledShellUnboundValue(DM_BIND_ASSET, arg === "--interval" ? 560 : 561);
+        const value = args[i + 1];
+        const n = Number(value);
+        if (!Number.isFinite(n))
+            return fail(`listen: ${arg.slice(2)} needs a value`);
+        if (arg === "--interval")
+            interval = n;
+        else
+            timeout = n;
+        i += 2;
+    }
+    const ch = requireChannel(d);
+    if (typeof ch !== "string")
+        return ch;
+    const deadline = Math.floor(d.now().getTime() / 1000) + timeout;
+    let output = `listening on #${ch} every ${interval}s (timeout ${timeout}s)\n`;
+    while (Math.floor(d.now().getTime() / 1000) < deadline) {
+        const result = await poll(d);
+        if (result.code === 0)
+            return { code: 0, stdout: `${output}${result.stdout}--- new message(s) on #${ch}; handle them, then re-run listen\n`, stderr: result.stderr };
+        if (result.code !== 3)
+            return { code: result.code, stdout: `${output}${result.stdout}`, stderr: result.stderr, ...(result.stderrBytes ? { stderrBytes: result.stderrBytes } : {}) };
+        await d.sleep(interval * 1000);
+    }
+    output += `no new messages on #${ch} within ${timeout}s\n`;
+    return { code: 3, stdout: output, stderr: "" };
+}
+export async function runDmBind(args, deps) {
+    if (!hasHqOnPath(deps))
+        return fail("missing dependency: hq");
+    const [command = "", ...rest] = args;
+    if (command === "bind")
+        return bind(deps, rest[0]);
+    if (command === "status")
+        return status(deps);
+    if (command === "unbind")
+        return unbind(deps);
+    if (command === "roster")
+        return cmdRoster(deps);
+    if (command === "threads")
+        return cmdThreads(deps);
+    if (command === "poll")
+        return poll(deps);
+    if (command === "post")
+        return post(deps, rest);
+    if (command === "listen")
+        return listen(deps, rest);
+    return { code: 2, stdout: DM_BIND_HELP, stderr: "" };
+}
+export function registerCoreDmBindNative(core) {
+    registerNativeUtility(core, {
+        name: "dm-bind", asset: DM_BIND_ASSET, root: "live", summary: "Bind this session to one HQ DM channel",
+        resolveRoot: (_cwd, hqRoot) => resolveLiveRoot({ hqRoot }),
+        run: (args, context) => runDmBind(args, createDmBindDeps(context.root, context.cwd, context.env, context.now)),
+    });
+}
+//# sourceMappingURL=core-dm-bind-native.js.map

package/dist/commands/core-eval-trigger-native.d.ts

@@ -0,0 +1,4 @@
+export { checkTriggerExpressions, evaluateTrigger } from "../utils/core-eval-trigger.js";
+export declare const EVAL_TRIGGER_ASSET = "core/scripts/eval-trigger.sh";
+export declare function runEvalTriggerFast(args: readonly string[], stdin: string, _cwd: string, _root: string | undefined): Promise<number>;
+//# sourceMappingURL=core-eval-trigger-native.d.ts.map