@indigoai-us/hq-cli 5.70.0 → 5.72.0

package/src/commands/outposts.test.ts

@@ -50,9 +50,18 @@ vi.mock("node:child_process", async (importOriginal) => {
   return { ...original, spawnSync: vi.fn() };
 });
 
-import { spawnSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
-import { registerOutpostsCommand, withRemoteHqDir } from "./outposts.js";
+import {
+  fetchExecResult,
+  joinCommandParts,
+  registerOutpostsCommand,
+  stageExecInput,
+  submitExec,
+  withRemoteHqDir,
+} from "./outposts.js";
 
 const mockSpawnSync = vi.mocked(spawnSync);
 
@@ -299,7 +308,7 @@ describe("hq outposts exec", () => {
     expect(init?.method).toBe("POST");
     // The command is wrapped so it runs from the box's HQ folder.
     expect(JSON.parse(init?.body as string)).toEqual({
-      command: withRemoteHqDir("echo hello world"),
+      command: withRemoteHqDir("'echo' 'hello' 'world'"),
     });
     const printed = stdoutSpy.mock.calls.map((c) => String(c[0])).join("");
     expect(printed).toContain("hello world\n");
@@ -431,7 +440,7 @@ describe("hq outposts exec — Lightsail SSH fallback", () => {
     const args = mockSpawnSync.mock.calls[0][1] as string[];
     expect(mockSpawnSync.mock.calls[0][0]).toBe("ssh");
     expect(args).toContain("ec2-user@52.2.2.2");
-    expect(args[args.length - 1]).toBe(withRemoteHqDir("uname -a"));
+    expect(args[args.length - 1]).toBe(withRemoteHqDir("'uname' '-a'"));
     expect(args).toContain("BatchMode=yes");
     const printed = stdoutSpy.mock.calls.map((c) => String(c[0])).join("");
     expect(printed).toContain("lightsail-out\n");
@@ -489,3 +498,242 @@ describe("hq outposts exec — Lightsail SSH fallback", () => {
     expect(mockSpawnSync).not.toHaveBeenCalled();
   });
 });
+
+describe("hq outposts asynchronous exec", () => {
+  it("sends the stage, submit, and result mode request bodies", async () => {
+    fetchSpy
+      .mockResolvedValueOnce(
+        jsonResponse(200, {
+          ok: true,
+          userId: "u1",
+          outpostId: "2",
+          key: "input-key",
+          putUrl: "https://upload.invalid/put",
+          getUrl: "https://download.invalid/get",
+          expiresInSeconds: 300,
+        }),
+      )
+      .mockResolvedValueOnce(
+        jsonResponse(200, {
+          ok: true,
+          userId: "u1",
+          outpostId: "2",
+          instanceId: "i-2",
+          commandId: "cmd-1",
+          outputPrefix: "output-prefix",
+        }),
+      )
+      .mockResolvedValueOnce(
+        jsonResponse(200, {
+          ok: true,
+          userId: "u1",
+          outpostId: "2",
+          status: "InProgress",
+          done: false,
+        }),
+      );
+
+    await stageExecInput("test-token", "2");
+    await submitExec("test-token", "cd /tmp && run-worker", "2");
+    await fetchExecResult("test-token", "cmd-1", "2");
+
+    expect(fetchSpy.mock.calls.map(([url]) => String(url))).toEqual([
+      expect.stringContaining("/outpost/exec?outpostId=2"),
+      expect.stringContaining("/outpost/exec?outpostId=2"),
+      expect.stringContaining("/outpost/exec?outpostId=2"),
+    ]);
+    expect(fetchSpy.mock.calls.map(([, init]) => JSON.parse(init?.body as string))).toEqual([
+      { mode: "stage" },
+      { mode: "submit", command: "cd /tmp && run-worker" },
+      { mode: "result", commandId: "cmd-1" },
+    ]);
+  });
+
+  it("exec-stage PUTs the exact file bytes and prints only key + getUrl JSON", async () => {
+    const stdoutSpy = vi
+      .spyOn(process.stdout, "write")
+      .mockImplementation(() => true);
+    const file = path.join(process.cwd(), "package.json");
+    const expectedBytes = fs.readFileSync(file);
+    fetchSpy
+      .mockResolvedValueOnce(
+        jsonResponse(200, {
+          ok: true,
+          userId: "u1",
+          outpostId: "2",
+          key: "input-key",
+          putUrl: "https://upload.invalid/put",
+          getUrl: "https://download.invalid/get",
+          expiresInSeconds: 300,
+        }),
+      )
+      .mockResolvedValueOnce(new Response(null, { status: 200 }));
+
+    await run(["outposts", "exec-stage", "--id", "2", "--file", file, "--json"]);
+
+    expect(fetchSpy).toHaveBeenCalledTimes(2);
+    const [uploadUrl, uploadInit] = fetchSpy.mock.calls[1];
+    expect(String(uploadUrl)).toBe("https://upload.invalid/put");
+    expect(uploadInit?.method).toBe("PUT");
+    expect(uploadInit?.headers).toEqual({
+      "Content-Length": String(expectedBytes.byteLength),
+    });
+    expect(Buffer.from(uploadInit?.body as Uint8Array)).toEqual(expectedBytes);
+    const printed = stdoutSpy.mock.calls.map((call) => String(call[0])).join("");
+    expect(JSON.parse(printed)).toEqual({
+      key: "input-key",
+      getUrl: "https://download.invalid/get",
+    });
+  });
+
+  it("exec-stage exits non-zero when the presigned upload fails", async () => {
+    fetchSpy
+      .mockResolvedValueOnce(
+        jsonResponse(200, {
+          ok: true,
+          userId: "u1",
+          outpostId: "primary",
+          key: "input-key",
+          putUrl: "https://upload.invalid/put",
+          getUrl: "https://download.invalid/get",
+          expiresInSeconds: 300,
+        }),
+      )
+      .mockResolvedValueOnce(new Response(null, { status: 503 }));
+
+    await expect(
+      run([
+        "outposts",
+        "exec-stage",
+        "--file",
+        path.join(process.cwd(), "package.json"),
+        "--json",
+      ]),
+    ).rejects.toThrow("process.exit(1)");
+  });
+
+  it("exec-submit shell-quotes multiple argv parts without adding the HQ-directory wrapper", async () => {
+    const stdoutSpy = vi
+      .spyOn(process.stdout, "write")
+      .mockImplementation(() => true);
+    const script = 'printf "%s\\n" "$0" "$1" "$2"';
+    fetchSpy.mockResolvedValueOnce(
+      jsonResponse(200, {
+        ok: true,
+        userId: "u1",
+        outpostId: "primary",
+        instanceId: "i-1",
+        commandId: "cmd-submit",
+        outputPrefix: "output-prefix",
+      }),
+    );
+
+    await run([
+      "outposts",
+      "exec-submit",
+      "--json",
+      "--",
+      "bash",
+      "-c",
+      script,
+      "marker",
+      "a b",
+      "quote's",
+    ]);
+
+    const body = JSON.parse(fetchSpy.mock.calls[0][1]?.body as string);
+    expect(body).toEqual({
+      mode: "submit",
+      command: joinCommandParts([
+        "bash",
+        "-c",
+        script,
+        "marker",
+        "a b",
+        "quote's",
+      ]),
+    });
+    expect(body.command).not.toContain("cd ~ec2-user/hq");
+    expect(JSON.parse(String(stdoutSpy.mock.calls[0][0]))).toEqual({
+      commandId: "cmd-submit",
+    });
+  });
+
+  it("preserves one command part verbatim and round-trips quoted bash argv", () => {
+    const single = "  printf 'already formed'  ";
+    expect(joinCommandParts([single])).toBe(single);
+
+    const script = 'printf "%s\\n" "$0" "$1" "$2"';
+    const command = joinCommandParts([
+      "bash",
+      "-c",
+      script,
+      "marker",
+      "a b",
+      "quote's",
+    ]);
+    expect(execFileSync("bash", ["-c", command], { encoding: "utf8" })).toBe(
+      "marker\na b\nquote's\n",
+    );
+  });
+
+  it("exec-result --wait retries a 429, polls until done, and prints the result contract", async () => {
+    vi.useFakeTimers();
+    try {
+      const stdoutSpy = vi
+        .spyOn(process.stdout, "write")
+        .mockImplementation(() => true);
+      fetchSpy
+        .mockResolvedValueOnce(
+          jsonResponse(429, { error: true, step: "rate", message: "slow down" }),
+        )
+        .mockResolvedValueOnce(
+          jsonResponse(200, {
+            ok: true,
+            userId: "u1",
+            outpostId: "2",
+            status: "InProgress",
+            done: false,
+          }),
+        )
+        .mockResolvedValueOnce(
+          jsonResponse(200, {
+            ok: true,
+            userId: "u1",
+            outpostId: "2",
+            status: "Success",
+            done: true,
+            exitCode: 0,
+            stdout: "finished\n",
+            stderr: "",
+            truncated: false,
+          }),
+        );
+
+      const pending = run([
+        "outposts",
+        "exec-result",
+        "--id",
+        "2",
+        "--command-id",
+        "cmd-1",
+        "--wait",
+        "--json",
+      ]);
+      await vi.advanceTimersByTimeAsync(500);
+      await vi.advanceTimersByTimeAsync(1_000);
+      await pending;
+
+      expect(fetchSpy).toHaveBeenCalledTimes(3);
+      expect(JSON.parse(String(stdoutSpy.mock.calls[0][0]))).toEqual({
+        done: true,
+        status: "Success",
+        exitCode: 0,
+        stdout: "finished\n",
+        stderr: "",
+      });
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});