@indigoai-us/hq-cli 5.77.4 → 5.77.5

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [5.77.5]
+
+### Added
+
+- **Cross-platform meeting-bot invites.** Run
+  `hq meetings invite <meeting-url>` to schedule the meeting bot from any
+  terminal. Add `--company <slug-or-uid>` to route the transcript to a company
+  vault; omitting it keeps the invite in your personal vault. (#252)
+
+### Fixed
+
+- High-security secret refusals now clearly direct callers to `hq secrets
+  sandbox` or the HQ secret proxy, including sandbox-only denials and
+  `--script` attempts. (#253)
+
 ## [5.77.4]
 
 ### Fixed

package/dist/commands/meetings.js

@@ -208,6 +208,43 @@ export function registerMeetingsCommand(program) {
             process.exit(1);
         }
     });
+    // ── hq meetings invite <meeting-url> ──────────────────────────────
+    meetings
+        .command("invite <meetingUrl>")
+        .description("Invite the meeting bot to a Google Meet, Zoom, or Teams URL")
+        .action(async (meetingUrl) => {
+        try {
+            const token = await ensureCognitoToken();
+            const companySlug = meetings.opts().company;
+            const query = {};
+            if (companySlug)
+                query.companyId = await getCompanyUid(token, companySlug);
+            const res = await vaultApiFetch({
+                token,
+                method: "POST",
+                path: "/v1/bot/invite",
+                query,
+                body: { meetingUrl },
+            });
+            if (!res.ok)
+                await handleApiError(res);
+            const data = (await res.json());
+            if (meetings.opts().json) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            console.log(chalk.green(`\n✓ Meeting bot invited to ${chalk.cyan(data.meetingUrl ?? meetingUrl)}.`));
+            if (data.botId)
+                console.log(chalk.dim(`  Bot: ${data.botId}`));
+            if (data.status)
+                console.log(chalk.dim(`  Status: ${data.status}`));
+            console.log();
+        }
+        catch (err) {
+            console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
     // ── hq meetings get <id> ──────────────────────────────────────────
     meetings
         .command("get <meetingId>")

package/dist/commands/secrets.js

@@ -131,6 +131,12 @@ function promptSecretInteractively() {
 // server (the legacy per-key GET path had no such cap).
 const MAX_BATCH_NAMES = 100;
 const SECRET_LOAD_TIMEOUT_MS = 30_000;
+function highSecuritySandboxOnlyMessage(secretName) {
+    const sandboxExample = secretName
+        ? `hq secrets sandbox --only ${secretName} -- <command>`
+        : "hq secrets sandbox --only <secret> -- <command>";
+    return `High-security secrets can run only in the sandbox (use \`${sandboxExample}\`) or through the HQ secret proxy. Local injection and script locks (\`--script\`) are not supported.`;
+}
 function parseSecretAclPrincipal(principal) {
     const p = principal.trim();
     if (p === "@all") {
@@ -435,10 +441,13 @@ export async function loadRevealedSecrets(token, companyUid, keys, usage) {
             if (!res.ok) {
                 const body = (await res.json().catch(() => ({})));
                 const message = extractApiMessage(body, res.statusText);
-                // High-security ("nuclear") refusal surfaced at the batch level (rather
-                // than per-name): point the caller at the proxy and never leak plaintext.
-                if (body.code === "high_security_denied" || body.highSecurity === true) {
-                    throw new Error("A requested secret is high-security and cannot be injected locally — it can only be used through the HQ secret proxy, which keeps the plaintext server-side.");
+                // High-security refusal surfaced at the batch level (rather than
+                // per-name): point the caller at the sandbox/proxy and never leak
+                // plaintext. A local script attestation is not an override.
+                if (body.code === "high_security_denied" ||
+                    body.code === "high_security_sandbox_only" ||
+                    body.highSecurity === true) {
+                    throw new Error(highSecuritySandboxOnlyMessage());
                 }
                 if (res.status >= 400 &&
                     res.status < 500 &&
@@ -508,14 +517,13 @@ export async function loadRevealedSecrets(token, companyUid, keys, usage) {
                     continue;
                 removeCacheEntry(companyUid, key);
                 const err = errorsByName.get(key);
-                // High-security ("nuclear") secret: the server refuses to vend it on the
-                // local-injection (batch-load) path — per-name code `high_security_denied`,
-                // no plaintext returned. Every caller of loadRevealedSecrets injects or
-                // prints the plaintext locally (`secrets get --reveal`, `secrets exec`,
-                // `secrets env`), so a high-security secret can NEVER be used here. Surface
-                // a clear, actionable error pointing at the proxy instead of a raw failure.
-                if (err?.code === "high_security_denied") {
-                    firstFailure ??= new Error(`Secret '${key}' is high-security and cannot be injected locally — it can only be used through the HQ secret proxy, which keeps the plaintext server-side.`);
+                // Every caller of loadRevealedSecrets injects or prints the plaintext
+                // locally (`secrets get --reveal`, `secrets exec`, `secrets env`). Both
+                // high-security denial shapes therefore receive the same explicit
+                // sandbox/proxy guidance, even if the caller supplied `--script`.
+                if (err?.code === "high_security_denied" ||
+                    err?.code === "high_security_sandbox_only") {
+                    firstFailure ??= new Error(highSecuritySandboxOnlyMessage(key));
                     continue;
                 }
                 const reason = err?.code === "not_found"
@@ -655,7 +663,7 @@ export function registerSecretsCommand(program) {
             removeCacheEntry(companyUid, name);
             console.log(chalk.green(formatSecretSaved(name, scopeLabel)));
             if (opts.highSecurity) {
-                console.log(chalk.dim(`  High-security: destination pinned to ${destinations?.[0]}. This value can never be revealed or injected locally — only used through the HQ secret proxy.`));
+                console.log(chalk.dim(`  High-security: destination pinned to ${destinations?.[0]}. This value can run only in the sandbox (hq secrets sandbox) or through the HQ secret proxy; local injection and script locks are unsupported.`));
             }
         }
         catch (err) {
@@ -677,13 +685,11 @@ export function registerSecretsCommand(program) {
             });
             if (!res.ok) {
                 const body = (await res.json().catch(() => ({})));
-                // High-security ("nuclear") secret: the server refuses to reveal it on
-                // the local-injection path (403, no plaintext). Surface a clear,
-                // actionable error pointing the user at the proxy rather than a raw
-                // 4xx — the value can ONLY be used through the server-side proxy.
+                // High-security secrets cannot be revealed locally. Surface the
+                // hosted execution path rather than a raw 4xx; `--script` never
+                // overrides this boundary.
                 if (res.status === 403 && body.highSecurity === true) {
-                    console.error(chalk.red(`Secret '${name}' is high-security and cannot be revealed locally.`));
-                    console.error(chalk.dim("  It can only be used through the HQ secret proxy, which keeps the plaintext server-side."));
+                    console.error(chalk.red(highSecuritySandboxOnlyMessage(name)));
                     process.exit(1);
                 }
                 console.error(chalk.red(`Failed to get secret: ${extractApiMessage(body, res.statusText)}`));

package/package.json

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

package/src/commands/meetings.test.ts

@@ -32,6 +32,7 @@ vi.mock("../utils/vault-api.js", async (importOriginal) => {
 });
 
 import { registerMeetingsCommand } from "./meetings.js";
+import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { getCompanyUid, vaultApiFetch } from "../utils/vault-api.js";
 
 let logSpy: MockInstance<typeof console.log>;
@@ -145,6 +146,61 @@ describe("meetings get — short id resolution", () => {
   });
 });
 
+describe("meetings invite", () => {
+  it("authenticates and posts the meeting URL with the optional company routing", async () => {
+    const meetingUrl = "https://meet.google.com/abc-defg-hij";
+    vi.mocked(vaultApiFetch).mockResolvedValueOnce(
+      jsonRes({
+        botId: "bot_123",
+        meetingUrl,
+        platform: "google_meet",
+        status: "scheduled",
+      }),
+    );
+
+    const program = buildProgram();
+    await program.parseAsync([
+      "node",
+      "hq",
+      "meetings",
+      "--company",
+      "indigo",
+      "invite",
+      meetingUrl,
+    ]);
+
+    expect(ensureCognitoToken).toHaveBeenCalledOnce();
+    expect(getCompanyUid).toHaveBeenCalledWith("test-token", "indigo");
+    expect(vaultApiFetch).toHaveBeenCalledWith({
+      token: "test-token",
+      method: "POST",
+      path: "/v1/bot/invite",
+      query: { companyId: "cmp_indigo" },
+      body: { meetingUrl },
+    });
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Meeting bot invited"));
+  });
+
+  it("omits company routing so the backend uses the caller's personal vault", async () => {
+    const meetingUrl = "https://zoom.us/j/123456789";
+    vi.mocked(vaultApiFetch).mockResolvedValueOnce(
+      jsonRes({ botId: "bot_123", meetingUrl, status: "scheduled" }),
+    );
+
+    const program = buildProgram();
+    await program.parseAsync(["node", "hq", "meetings", "invite", meetingUrl]);
+
+    expect(getCompanyUid).not.toHaveBeenCalled();
+    expect(vaultApiFetch).toHaveBeenCalledWith({
+      token: "test-token",
+      method: "POST",
+      path: "/v1/bot/invite",
+      query: {},
+      body: { meetingUrl },
+    });
+  });
+});
+
 describe("meetings set-company", () => {
   it("POSTs the resolved company id and applies to the recurring series by default", async () => {
     vi.mocked(vaultApiFetch).mockResolvedValueOnce(

package/src/commands/meetings.ts

@@ -101,6 +101,13 @@ interface MeetingDocument {
   notes: MeetingNotes | null;
 }
 
+interface MeetingBotInviteResponse {
+  botId?: string;
+  meetingUrl?: string;
+  platform?: string;
+  status?: string;
+}
+
 function formatDuration(seconds: number): string {
   const h = Math.floor(seconds / 3600);
   const m = Math.floor((seconds % 3600) / 60);
@@ -344,6 +351,43 @@ export function registerMeetingsCommand(program: Command): void {
       }
     });
 
+  // ── hq meetings invite <meeting-url> ──────────────────────────────
+
+  meetings
+    .command("invite <meetingUrl>")
+    .description("Invite the meeting bot to a Google Meet, Zoom, or Teams URL")
+    .action(async (meetingUrl: string) => {
+      try {
+        const token = await ensureCognitoToken();
+        const companySlug = meetings.opts().company as string | undefined;
+        const query: Record<string, string> = {};
+        if (companySlug) query.companyId = await getCompanyUid(token, companySlug);
+
+        const res = await vaultApiFetch({
+          token,
+          method: "POST",
+          path: "/v1/bot/invite",
+          query,
+          body: { meetingUrl },
+        });
+        if (!res.ok) await handleApiError(res);
+        const data = (await res.json()) as MeetingBotInviteResponse;
+
+        if (meetings.opts().json) {
+          console.log(JSON.stringify(data, null, 2));
+          return;
+        }
+
+        console.log(chalk.green(`\n✓ Meeting bot invited to ${chalk.cyan(data.meetingUrl ?? meetingUrl)}.`));
+        if (data.botId) console.log(chalk.dim(`  Bot: ${data.botId}`));
+        if (data.status) console.log(chalk.dim(`  Status: ${data.status}`));
+        console.log();
+      } catch (err) {
+        console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+
   // ── hq meetings get <id> ──────────────────────────────────────────
 
   meetings

package/src/commands/secrets.test.ts

@@ -138,6 +138,29 @@ describe("secrets sandbox", () => {
     expect(channel).toBe("sandbox");
   });
 
+  it("runs a high-security secret in the sandbox without a local script attestation", async () => {
+    const program = buildProgram();
+    await program.parseAsync([
+      "node",
+      "hq",
+      "secrets",
+      "sandbox",
+      "--only",
+      "HIGH_SECURITY_KEY",
+      "--",
+      "env",
+    ]);
+
+    expect(startJobSpy).toHaveBeenCalledWith("test-token", {
+      companyUid: "prs_alice",
+      secretNames: ["HIGH_SECURITY_KEY"],
+      command: "env",
+    });
+    expect(vaultApiFetch).not.toHaveBeenCalledWith(
+      expect.objectContaining({ path: expect.stringContaining("/load") }),
+    );
+  });
+
   it("parses --company, --only, and joins args after -- into a command", async () => {
     const program = buildProgram();
     await program.parseAsync([
@@ -534,9 +557,9 @@ describe("secrets exists (HQ-4H HEAD probe)", () => {
 
 // US-003 (secrets-server-proxy): the CLI surfaces the SERVER's refusal of a
 // high-security ("nuclear") secret on the local-injection path as a clear,
-// actionable error pointing at the proxy — and never prints the value. The
-// server-side deny is the real control (it returns 403 + highSecurity:true and
-// NO plaintext); these tests assert the CLI's surfacing behavior.
+// actionable sandbox/proxy error — and never prints the value. The server-side
+// deny is the real control (it returns 403 + highSecurity:true and NO
+// plaintext); these tests assert the CLI's surfacing behavior.
 describe("US-003 — CLI refuses high-security secrets on local injection", () => {
   // The server's 403 refusal shape for a high-security secret.
   function highSecurityDenied(): Response {
@@ -550,6 +573,20 @@ describe("US-003 — CLI refuses high-security secrets on local injection", () =
     );
   }
 
+  function highSecuritySandboxOnly(): Response {
+    return jsonRes({
+      secrets: [],
+      errors: [
+        {
+          name: "ANTHROPIC_API_KEY",
+          code: "high_security_sandbox_only",
+          message:
+            "High-security-tier secrets can run only in the sandbox (`hq secrets sandbox`) or through the secret proxy. Local injection and script locks (`--script`) are not supported.",
+        },
+      ],
+    });
+  }
+
   let exitSpy: MockInstance<typeof process.exit>;
   beforeEach(() => {
     exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {
@@ -576,17 +613,22 @@ describe("US-003 — CLI refuses high-security secrets on local injection", () =
     const exitCode = exitSpy.mock.calls[0]?.[0] as number | undefined;
 
     expect(exitCode).toBe(1);
-    // A clear, actionable error mentioning high-security + the proxy.
+    // A clear, actionable error names the sandbox/proxy boundary and rules
+    // out script-lock bypasses.
     const errText = errSpy.mock.calls.flat().join(" ");
     expect(errText).toMatch(/high-security/i);
+    expect(errText).toMatch(/hq secrets sandbox/i);
     expect(errText).toMatch(/proxy/i);
+    expect(errText).toMatch(/--script/);
     // The value is NEVER printed — no "Value:" line carrying plaintext.
     const logText = logSpy.mock.calls.flat().join(" ");
     expect(logText).not.toMatch(/sk-ant/i);
   });
 
-  it("E2E: `secrets exec --only <name> -- env` is denied — proxy-pointing error, command not run", async () => {
-    vi.mocked(vaultApiFetch).mockResolvedValueOnce(highSecurityDenied());
+  it("E2E: `secrets exec --script <path>` is denied — sandbox guidance, command not run", async () => {
+    vi.mocked(vaultApiFetch).mockResolvedValueOnce(highSecuritySandboxOnly());
+    const scriptPath = join(tempDir, "deploy.sh");
+    writeFileSync(scriptPath, "#!/usr/bin/env bash\necho deploy\n");
 
     const program = buildProgram();
     try {
@@ -597,6 +639,10 @@ describe("US-003 — CLI refuses high-security secrets on local injection", () =
         "exec",
         "--only",
         "ANTHROPIC_API_KEY",
+        "--script",
+        scriptPath,
+        "--script-id",
+        "script.deploy",
         "--",
         "env",
       ]);
@@ -608,7 +654,10 @@ describe("US-003 — CLI refuses high-security secrets on local injection", () =
     expect(exitCode).toBe(1);
     const errText = errSpy.mock.calls.flat().join(" ");
     expect(errText).toMatch(/high-security/i);
+    expect(errText).toMatch(/hq secrets sandbox/i);
     expect(errText).toMatch(/proxy/i);
+    expect(errText).toMatch(/--script/);
+    expect(spawn).not.toHaveBeenCalled();
   });
 });
 

package/src/commands/secrets.ts

@@ -212,6 +212,13 @@ export interface SecretLoadResponse {
   errors: Array<{ name: string; code: string; message?: string }>;
 }
 
+function highSecuritySandboxOnlyMessage(secretName?: string): string {
+  const sandboxExample = secretName
+    ? `hq secrets sandbox --only ${secretName} -- <command>`
+    : "hq secrets sandbox --only <secret> -- <command>";
+  return `High-security secrets can run only in the sandbox (use \`${sandboxExample}\`) or through the HQ secret proxy. Local injection and script locks (\`--script\`) are not supported.`;
+}
+
 interface SecretGetResponse {
   secret: {
     name: string;
@@ -669,12 +676,15 @@ export async function loadRevealedSecrets(
       if (!res.ok) {
         const body = (await res.json().catch(() => ({}))) as Record<string, unknown>;
         const message = extractApiMessage(body, res.statusText);
-        // High-security ("nuclear") refusal surfaced at the batch level (rather
-        // than per-name): point the caller at the proxy and never leak plaintext.
-        if (body.code === "high_security_denied" || body.highSecurity === true) {
-          throw new Error(
-            "A requested secret is high-security and cannot be injected locally — it can only be used through the HQ secret proxy, which keeps the plaintext server-side.",
-          );
+        // High-security refusal surfaced at the batch level (rather than
+        // per-name): point the caller at the sandbox/proxy and never leak
+        // plaintext. A local script attestation is not an override.
+        if (
+          body.code === "high_security_denied" ||
+          body.code === "high_security_sandbox_only" ||
+          body.highSecurity === true
+        ) {
+          throw new Error(highSecuritySandboxOnlyMessage());
         }
         if (
           res.status >= 400 &&
@@ -752,16 +762,15 @@ export async function loadRevealedSecrets(
         if (resolved.has(key)) continue;
         removeCacheEntry(companyUid, key);
         const err = errorsByName.get(key);
-        // High-security ("nuclear") secret: the server refuses to vend it on the
-        // local-injection (batch-load) path — per-name code `high_security_denied`,
-        // no plaintext returned. Every caller of loadRevealedSecrets injects or
-        // prints the plaintext locally (`secrets get --reveal`, `secrets exec`,
-        // `secrets env`), so a high-security secret can NEVER be used here. Surface
-        // a clear, actionable error pointing at the proxy instead of a raw failure.
-        if (err?.code === "high_security_denied") {
-          firstFailure ??= new Error(
-            `Secret '${key}' is high-security and cannot be injected locally — it can only be used through the HQ secret proxy, which keeps the plaintext server-side.`,
-          );
+        // Every caller of loadRevealedSecrets injects or prints the plaintext
+        // locally (`secrets get --reveal`, `secrets exec`, `secrets env`). Both
+        // high-security denial shapes therefore receive the same explicit
+        // sandbox/proxy guidance, even if the caller supplied `--script`.
+        if (
+          err?.code === "high_security_denied" ||
+          err?.code === "high_security_sandbox_only"
+        ) {
+          firstFailure ??= new Error(highSecuritySandboxOnlyMessage(key));
           continue;
         }
         const reason =
@@ -947,7 +956,7 @@ export function registerSecretsCommand(program: Command): void {
         if (opts.highSecurity) {
           console.log(
             chalk.dim(
-              `  High-security: destination pinned to ${destinations?.[0]}. This value can never be revealed or injected locally — only used through the HQ secret proxy.`,
+              `  High-security: destination pinned to ${destinations?.[0]}. This value can run only in the sandbox (hq secrets sandbox) or through the HQ secret proxy; local injection and script locks are unsupported.`,
             ),
           );
         }
@@ -979,21 +988,11 @@ export function registerSecretsCommand(program: Command): void {
 
         if (!res.ok) {
           const body = (await res.json().catch(() => ({}))) as Record<string, unknown>;
-          // High-security ("nuclear") secret: the server refuses to reveal it on
-          // the local-injection path (403, no plaintext). Surface a clear,
-          // actionable error pointing the user at the proxy rather than a raw
-          // 4xx — the value can ONLY be used through the server-side proxy.
+          // High-security secrets cannot be revealed locally. Surface the
+          // hosted execution path rather than a raw 4xx; `--script` never
+          // overrides this boundary.
           if (res.status === 403 && body.highSecurity === true) {
-            console.error(
-              chalk.red(
-                `Secret '${name}' is high-security and cannot be revealed locally.`,
-              ),
-            );
-            console.error(
-              chalk.dim(
-                "  It can only be used through the HQ secret proxy, which keeps the plaintext server-side.",
-              ),
-            );
+            console.error(chalk.red(highSecuritySandboxOnlyMessage(name)));
             process.exit(1);
           }
           console.error(