@indigoai-us/hq-cli 5.69.0 → 5.71.0

package/dist/commands/outposts.js

@@ -21,7 +21,7 @@
  * and status routes that exist. Renaming an Outpost is not a backend capability.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="ff8d1d83-feab-5f6f-bf48-e4fde1a8d449")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="839f8f76-584d-5ea8-b86e-a92a55c32a16")}catch(e){}}();
 import chalk from "chalk";
 import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
@@ -139,6 +139,63 @@ export async function execOutpost(token, command, outpostId) {
         query: outpostId ? { outpostId } : undefined,
     });
 }
+export async function stageExecInput(token, outpostId) {
+    return outpostRequest({
+        token,
+        path: "/outpost/exec",
+        method: "POST",
+        body: { mode: "stage" },
+        query: outpostId ? { outpostId } : undefined,
+    });
+}
+export async function submitExec(token, command, outpostId) {
+    return outpostRequest({
+        token,
+        path: "/outpost/exec",
+        method: "POST",
+        body: { mode: "submit", command },
+        query: outpostId ? { outpostId } : undefined,
+    });
+}
+export async function fetchExecResult(token, commandId, outpostId) {
+    return outpostRequest({
+        token,
+        path: "/outpost/exec",
+        method: "POST",
+        body: { mode: "result", commandId },
+        query: outpostId ? { outpostId } : undefined,
+    });
+}
+function shellQuote(part) {
+    return `'${part.replace(/'/g, `'\\''`)}'`;
+}
+/** Preserve a single command string; safely join argv when Commander split it. */
+export function joinCommandParts(commandParts) {
+    if (commandParts.length === 1)
+        return commandParts[0];
+    return commandParts.map(shellQuote).join(" ");
+}
+const EXEC_RESULT_INITIAL_POLL_MS = 500;
+const EXEC_RESULT_MAX_POLL_MS = 5_000;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForExecResult(token, commandId, outpostId) {
+    let delayMs = EXEC_RESULT_INITIAL_POLL_MS;
+    while (true) {
+        try {
+            const result = await fetchExecResult(token, commandId, outpostId);
+            if (result.done)
+                return result;
+        }
+        catch (err) {
+            if (!(err instanceof OutpostHttpError) || err.status !== 429)
+                throw err;
+        }
+        await sleep(delayMs);
+        delayMs = Math.min(delayMs * 2, EXEC_RESULT_MAX_POLL_MS);
+    }
+}
 /**
  * Prefix that best-effort `cd`s into the box's HQ checkout before running the
  * caller's command. `exec` runs over two transports with two different default
@@ -602,8 +659,8 @@ export function registerOutpostsCommand(program, selfDeployOverrides = {}) {
         .option("--json", "Emit raw JSON")
         .action(async function (commandParts, opts) {
         try {
-            const command = commandParts.join(" ").trim();
-            if (!command) {
+            const command = joinCommandParts(commandParts);
+            if (!command.trim()) {
                 console.error(chalk.red("No command given. Usage: hq outposts exec -- <command>"));
                 process.exit(1);
             }
@@ -669,6 +726,94 @@ export function registerOutpostsCommand(program, selfDeployOverrides = {}) {
             fail(err);
         }
     });
+    outposts
+        .command("exec-stage")
+        .description("Stage a file for an asynchronous Outpost command")
+        .requiredOption("--file <path>", "File to upload")
+        .option("--id <outpostId>", "Outpost id (defaults to your primary box)")
+        .option("--json", "Emit raw JSON")
+        .action(async function (opts) {
+        try {
+            const bytes = fs.readFileSync(opts.file);
+            const token = await ensureCognitoToken();
+            const staged = await stageExecInput(token, opts.id);
+            const upload = await fetch(staged.putUrl, {
+                method: "PUT",
+                headers: { "Content-Length": String(bytes.byteLength) },
+                body: bytes,
+            });
+            if (!upload.ok) {
+                throw new Error(`Could not upload exec input: HTTP ${upload.status} ${upload.statusText}`);
+            }
+            const output = { key: staged.key, getUrl: staged.getUrl };
+            if (opts.json) {
+                process.stdout.write(JSON.stringify(output) + "\n");
+            }
+            else {
+                printKeyValues(output);
+            }
+        }
+        catch (err) {
+            fail(err);
+        }
+    });
+    outposts
+        .command("exec-submit <command...>")
+        .description("Submit an asynchronous shell command to an Outpost")
+        .option("--id <outpostId>", "Outpost id (defaults to your primary box)")
+        .option("--json", "Emit raw JSON")
+        .action(async function (commandParts, opts) {
+        try {
+            const command = joinCommandParts(commandParts);
+            if (!command.trim()) {
+                console.error(chalk.red("No command given. Usage: hq outposts exec-submit -- <command>"));
+                process.exit(1);
+            }
+            const token = await ensureCognitoToken();
+            const submitted = await submitExec(token, command, opts.id);
+            const output = { commandId: submitted.commandId };
+            if (opts.json) {
+                process.stdout.write(JSON.stringify(output) + "\n");
+            }
+            else {
+                printKeyValues(output);
+            }
+        }
+        catch (err) {
+            fail(err);
+        }
+    });
+    outposts
+        .command("exec-result")
+        .description("Fetch the result of an asynchronous Outpost command")
+        .requiredOption("--command-id <commandId>", "Command id returned by exec-submit")
+        .option("--id <outpostId>", "Outpost id (defaults to your primary box)")
+        .option("--wait", "Poll until the command reaches a terminal state")
+        .option("--json", "Emit raw JSON")
+        .action(async function (opts) {
+        try {
+            const token = await ensureCognitoToken();
+            const result = opts.wait
+                ? await waitForExecResult(token, opts.commandId, opts.id)
+                : await fetchExecResult(token, opts.commandId, opts.id);
+            const output = {
+                done: result.done,
+                status: result.status,
+                exitCode: result.exitCode ?? null,
+                stdout: result.stdout ?? "",
+                stderr: result.stderr ?? "",
+            };
+            if (opts.json) {
+                process.stdout.write(JSON.stringify(output) + "\n");
+            }
+            else {
+                printKeyValues(output);
+            }
+        }
+        catch (err) {
+            fail(err);
+        }
+    });
     outposts
         .command("codex-enable")
         .description("Enable (or retry) Codex on an Outpost")
@@ -741,4 +886,4 @@ export function registerOutpostsCommand(program, selfDeployOverrides = {}) {
     });
 }
 //# sourceMappingURL=outposts.js.map
-//# debugId=ff8d1d83-feab-5f6f-bf48-e4fde1a8d449
+//# debugId=839f8f76-584d-5ea8-b86e-a92a55c32a16

package/package.json

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

package/src/commands/channels.ts

@@ -19,7 +19,10 @@ export function describeChannel(c: ChannelSummary): string {
       names.length > 0
         ? names.join(", ")
         : `${c.memberCount ?? "?"}-person group`;
-    return `${who}  ${chalk.dim("(group DM)")}`;
+    // Group DMs are unnamed, so their channel id is the only way to address them
+    // for reading (`hq dm channel <id>`). Surface it so it can be copied.
+    const readHint = chalk.dim(`— hq dm channel ${c.channelId}`);
+    return `${who}  ${chalk.dim("(group DM)")}  ${readHint}`;
   }
   const slug = c.slug ?? (c.name ? channelSlug(c.name) : "");
   const scopeTag = c.scope ? chalk.dim(`(${c.scope})`) : "";

package/src/commands/dm.test.ts

@@ -18,6 +18,7 @@ vi.mock("../utils/cognito-session.js", async (importOriginal) => {
 });
 
 import { Command } from "commander";
+import chalk from "chalk";
 import {
   detectRecipient,
   parseDuration,
@@ -29,8 +30,18 @@ import {
   channelSlug,
   parseChannelName,
   matchChannelsByName,
+  senderLabel,
+  formatRelativeTime,
+  isUnread,
+  unreadEventIds,
+  filterUnread,
+  firstLine,
+  buildThreadQuery,
+  formatInboxEvent,
+  formatThreadMessage,
   type ConnectionRequest,
   type ChannelSummary,
+  type DmInboxEvent,
 } from "./dm.js";
 
 describe("parseGroupRecipients", () => {
@@ -262,6 +273,127 @@ describe("buildConnectionActionBody", () => {
 // Action handlers (HTTP/auth mocked)
 // ---------------------------------------------------------------------------
 
+describe("senderLabel", () => {
+  it("prefers display name, then email, then uid", () => {
+    expect(
+      senderLabel({ fromDisplayName: "Jonathan", fromEmail: "j@x.com", fromPersonUid: "prs_1" }),
+    ).toBe("Jonathan");
+    expect(senderLabel({ fromEmail: "j@x.com", fromPersonUid: "prs_1" })).toBe("j@x.com");
+    expect(senderLabel({ fromPersonUid: "prs_1" })).toBe("prs_1");
+    expect(senderLabel({})).toBe("unknown");
+  });
+});
+
+describe("formatRelativeTime", () => {
+  const now = Date.parse("2026-07-16T12:00:00.000Z");
+  it("renders sub-minute as 'just now'", () => {
+    expect(formatRelativeTime("2026-07-16T11:59:30.000Z", now)).toBe("just now");
+  });
+  it("renders minutes, hours, and days", () => {
+    expect(formatRelativeTime("2026-07-16T11:57:00.000Z", now)).toBe("3m ago");
+    expect(formatRelativeTime("2026-07-16T10:00:00.000Z", now)).toBe("2h ago");
+    expect(formatRelativeTime("2026-07-11T12:00:00.000Z", now)).toBe("5d ago");
+  });
+  it("falls back to a date for anything older than a week", () => {
+    expect(formatRelativeTime("2026-06-01T09:00:00.000Z", now)).toBe("2026-06-01");
+  });
+  it("echoes an unparseable input", () => {
+    expect(formatRelativeTime("not-a-date", now)).toBe("not-a-date");
+  });
+});
+
+describe("isUnread / unreadEventIds / filterUnread", () => {
+  const events: DmInboxEvent[] = [
+    { eventId: "a", body: "x", createdAt: "2026-07-16T11:00:00.000Z" },
+    {
+      eventId: "b",
+      body: "y",
+      createdAt: "2026-07-16T11:30:00.000Z",
+      acknowledgedAt: "2026-07-16T11:31:00.000Z",
+    },
+  ];
+  it("treats a message with no acknowledgedAt as unread", () => {
+    expect(isUnread(events[0])).toBe(true);
+    expect(isUnread(events[1])).toBe(false);
+  });
+  it("collects unread event ids", () => {
+    expect(unreadEventIds(events)).toEqual(["a"]);
+  });
+  it("filters to unread only", () => {
+    expect(filterUnread(events).map((e) => e.eventId)).toEqual(["a"]);
+  });
+});
+
+describe("firstLine", () => {
+  it("collapses whitespace to a single trimmed line", () => {
+    expect(firstLine("  hello\n  world  \t there ")).toBe("hello world there");
+  });
+  it("truncates with an ellipsis past the cap", () => {
+    const out = firstLine("abcdefghij", 5);
+    expect(out).toBe("abcd…");
+    expect(out.length).toBe(5);
+  });
+});
+
+describe("buildThreadQuery", () => {
+  it("routes an email through withEmail (lowercased)", () => {
+    expect(buildThreadQuery("Jonathan@GetIndigo.ai")).toEqual({
+      withEmail: "jonathan@getindigo.ai",
+    });
+  });
+  it("routes a personUid / agentUid through withPersonUid", () => {
+    expect(buildThreadQuery("prs_123")).toEqual({ withPersonUid: "prs_123" });
+    expect(buildThreadQuery("agt_123")).toEqual({ withPersonUid: "agt_123" });
+  });
+  it("rejects a bare name", () => {
+    expect(() => buildThreadQuery("Jonathan")).toThrow(/Resolve a name first/);
+  });
+});
+
+describe("format helpers (rendering)", () => {
+  beforeEach(() => {
+    chalk.level = 0; // plain text so assertions read the rendered content
+  });
+  const now = Date.parse("2026-07-16T12:00:00.000Z");
+  it("marks an unread inbox row with a bullet and shows the sender + body", () => {
+    const row = formatInboxEvent(
+      {
+        eventId: "e1",
+        fromDisplayName: "Jonathan Bach",
+        fromEmail: "jonathan@getindigo.ai",
+        body: "grp_jb_agent is created",
+        createdAt: "2026-07-16T11:57:00.000Z",
+      },
+      now,
+    );
+    expect(row).toContain("●");
+    expect(row).toContain("Jonathan Bach");
+    expect(row).toContain("<jonathan@getindigo.ai>");
+    expect(row).toContain("3m ago");
+    expect(row).toContain("grp_jb_agent is created");
+  });
+  it("tags thread direction: outgoing as 'you', incoming by sender", () => {
+    const out = formatThreadMessage(
+      { eventId: "o", body: "hey", createdAt: "2026-07-16T11:00:00.000Z", direction: "out" },
+      now,
+    );
+    expect(out).toContain("→");
+    expect(out).toContain("you");
+    const inbound = formatThreadMessage(
+      {
+        eventId: "i",
+        fromDisplayName: "Jonathan",
+        body: "thanks",
+        createdAt: "2026-07-16T11:30:00.000Z",
+        direction: "in",
+      },
+      now,
+    );
+    expect(inbound).toContain("←");
+    expect(inbound).toContain("Jonathan");
+  });
+});
+
 function jsonResponse(status: number, body: unknown): Response {
   return new Response(JSON.stringify(body), {
     status,
@@ -480,4 +612,137 @@ describe("dm command actions", () => {
     expect(body).toEqual({ withEmail: "spammer@example.com" });
     expect(logged()).toMatch(/Blocked — spammer@example\.com\./);
   });
+
+  // ---- receive side: inbox / thread / channel ----
+
+  it("inbox: lists incoming messages from GET /v1/notify/inbox", async () => {
+    fetchSpy.mockResolvedValueOnce(
+      jsonResponse(200, {
+        events: [
+          {
+            eventId: "e1",
+            fromDisplayName: "Jonathan Bach",
+            fromEmail: "jonathan@getindigo.ai",
+            body: "grp_jb_agent is created",
+            createdAt: "2026-07-16T11:57:00.000Z",
+          },
+        ],
+      }),
+    );
+    await program.parseAsync(["dm", "inbox"], { from: "user" });
+    expect(String(fetchSpy.mock.calls[0][0])).toContain("/v1/notify/inbox");
+    expect(logged()).toContain("Jonathan Bach");
+    expect(logged()).toContain("grp_jb_agent is created");
+    expect(errSpy).not.toHaveBeenCalled();
+  });
+
+  it("inbox --unread --mark-read: acks only the unread ids", async () => {
+    fetchSpy
+      .mockResolvedValueOnce(
+        jsonResponse(200, {
+          events: [
+            { eventId: "u1", body: "new", createdAt: "2026-07-16T11:00:00.000Z" },
+            {
+              eventId: "r1",
+              body: "old",
+              createdAt: "2026-07-16T10:00:00.000Z",
+              acknowledgedAt: "2026-07-16T10:01:00.000Z",
+            },
+          ],
+        }),
+      )
+      .mockResolvedValueOnce(jsonResponse(200, { acknowledged: 1 }));
+    await program.parseAsync(["dm", "inbox", "--unread", "--mark-read"], {
+      from: "user",
+    });
+    const ackCall = fetchSpy.mock.calls.find((c) =>
+      String(c[0]).includes("/v1/notify/inbox/ack"),
+    );
+    expect(ackCall).toBeTruthy();
+    expect(JSON.parse((ackCall![1]?.body as string) ?? "{}")).toEqual({
+      eventIds: ["u1"],
+    });
+  });
+
+  it("thread <email>: reads via withEmail and acks incoming messages", async () => {
+    fetchSpy
+      .mockResolvedValueOnce(
+        jsonResponse(200, {
+          messages: [
+            {
+              eventId: "in1",
+              fromDisplayName: "Jonathan",
+              body: "thanks!",
+              createdAt: "2026-07-16T11:30:00.000Z",
+              direction: "in",
+            },
+            {
+              eventId: "out1",
+              body: "done",
+              createdAt: "2026-07-16T11:00:00.000Z",
+              direction: "out",
+            },
+          ],
+        }),
+      )
+      .mockResolvedValueOnce(jsonResponse(200, { acknowledged: 1 }));
+    await program.parseAsync(["dm", "thread", "jonathan@getindigo.ai"], {
+      from: "user",
+    });
+    expect(String(fetchSpy.mock.calls[0][0])).toContain("/v1/notify/thread");
+    expect(String(fetchSpy.mock.calls[0][0])).toContain("withEmail=");
+    const ackCall = fetchSpy.mock.calls.find((c) =>
+      String(c[0]).includes("/v1/notify/inbox/ack"),
+    );
+    expect(ackCall).toBeTruthy();
+    expect(JSON.parse((ackCall![1]?.body as string) ?? "{}")).toEqual({
+      eventIds: ["in1"],
+    });
+    expect(logged()).toContain("thanks!");
+  });
+
+  it("thread --no-ack: reads without marking anything read", async () => {
+    fetchSpy.mockResolvedValueOnce(
+      jsonResponse(200, {
+        messages: [
+          {
+            eventId: "in1",
+            body: "hi",
+            createdAt: "2026-07-16T11:30:00.000Z",
+            direction: "in",
+          },
+        ],
+      }),
+    );
+    await program.parseAsync(["dm", "thread", "prs_x", "--no-ack"], {
+      from: "user",
+    });
+    expect(
+      fetchSpy.mock.calls.some((c) => String(c[0]).includes("/inbox/ack")),
+    ).toBe(false);
+    expect(String(fetchSpy.mock.calls[0][0])).toContain("withPersonUid=prs_x");
+  });
+
+  it("channel <name>: resolves the channel then reads its messages", async () => {
+    fetchSpy
+      .mockResolvedValueOnce(jsonResponse(200, channelsPayload))
+      .mockResolvedValueOnce(
+        jsonResponse(200, {
+          messages: [
+            {
+              eventId: "m1",
+              fromDisplayName: "Stefan",
+              body: "ship it",
+              createdAt: "2026-07-16T11:00:00.000Z",
+            },
+          ],
+        }),
+      );
+    await program.parseAsync(["dm", "channel", "vyg-dev"], { from: "user" });
+    expect(String(fetchSpy.mock.calls[0][0])).toContain("/v1/notify/channels");
+    expect(String(fetchSpy.mock.calls[1][0])).toContain(
+      "/v1/notify/channels/chn_v/messages",
+    );
+    expect(logged()).toContain("ship it");
+  });
 });