test(runtime): complete invoke failure coverage

Author: aidandaly24

src/handlers/runtime/invoke/index.tsx

@@ -62,13 +62,10 @@ export const createInvokeRuntimeHandler = (core: Core, io: AppIO) =>
         try {
           await renderTuiAt(path, ctx, core, io);
         } catch (error) {
-          if (
-            error instanceof TypeError &&
+          throw error instanceof TypeError &&
             error.message === "interactive mode requires a TTY on stdin and stdout"
-          ) {
-            throw new UsageError(error.message);
-          }
-          throw error;
+            ? new UsageError(error.message)
+            : error;
         }
         return;
       }

src/handlers/runtime/invoke/invoke.test.tsx

@@ -320,6 +320,25 @@ describe("runtime invoke", () => {
     expect(core.runtime.calls).toEqual([]);
   });
 
+  test("classifies the TUI requirement as usage at the handler boundary", async () => {
+    const core = new TestCoreClient();
+    const output = captureIO();
+    const render = spyOn(tui, "renderTuiAt").mockRejectedValue(
+      new TypeError("interactive mode requires a TTY on stdin and stdout"),
+    );
+
+    try {
+      const code = await runWithExitCode(async () =>
+        runCommand(core, output.io, ["runtime", "invoke", "--id", RUNTIME_ID]),
+      );
+
+      expect(code).toBe(ExitCode.USAGE);
+      expect(core.runtime.calls).toEqual([]);
+    } finally {
+      render.mockRestore();
+    }
+  });
+
   test("handler deep-links id-only and qualified invokes with encoded path segments", async () => {
     const core = new TestCoreClient();
     const output = captureIO();

src/handlers/runtime/invoke/response.test.ts

@@ -2,7 +2,7 @@ import { afterEach, describe, expect, test } from "bun:test";
 import { rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { PassThrough } from "node:stream";
+import { PassThrough, Writable } from "node:stream";
 import type { RuntimeInvokeResponse } from "../types";
 import { writeRuntimeInvokeResponse } from "./response";
 
@@ -77,6 +77,25 @@ describe("Runtime invoke response output", () => {
     expect(stdout.bytes()).toEqual(Buffer.from([0, 255, 10, 1, 127]));
   });
 
+  test("sanitizes metadata output failures", async () => {
+    const stdout = capture();
+    const stderr = new Writable({
+      write(_chunk, _encoding, callback) {
+        callback(new Error("secret metadata sink failure"));
+      },
+    }) as unknown as NodeJS.WriteStream;
+
+    await expect(
+      writeRuntimeInvokeResponse(response(), {
+        stdout: stdout.stream,
+        stderr,
+      }),
+    ).rejects.toMatchObject({
+      message: "response stream failed",
+      reported: true,
+    });
+  });
+
   test("streams exact bytes to a file and leaves stdout empty", async () => {
     const file = join(tmpdir(), `runtime-invoke-output-${process.pid}-${files.length}`);
     files.push(file);