fix(feedback): bug bash fixes — wizard exit, dir error, tilde paths

Three issues from bug bash:

- 2.5: Esc/Ctrl+C in the wizard didn't terminate the process. The
  onExit callback unmounted the screen but Ink's stdin raw-mode
  listeners kept Node alive. Fix: await render()'s waitUntilExit()
  and call process.exit(0) once the wizard unmounts. Matches
  invoke/command.tsx's pattern.

- 3.2: Pointing --screenshot at a directory ("/tmp") produced
  "Screenshot must be one of: .png, .jpg, .jpeg" because we extension-
  checked first. Fix: stat the path first; surface a directory-specific
  error before the extension check.

- 3.6: Quoted paths starting with "~/" (e.g. ~/Desktop/foo.png) hit
  ENOENT because Node's fs APIs don't expand tildes — only the shell
  does, and quoting suppresses that. Fix: expand a leading "~" or
  "~/..." to os.homedir() before stat/read.

Added unit tests for both new validator branches.

Author: tejaskash

src/cli/commands/feedback/__tests__/command.test.ts

@@ -24,7 +24,11 @@ vi.mock('../../../tui/screens/feedback', () => ({
 vi.mock('ink', () => ({
   render: (...args: unknown[]) => {
     mockRender(...args);
-    return { clear: vi.fn(), unmount: vi.fn() };
+    return {
+      clear: vi.fn(),
+      unmount: vi.fn(),
+      waitUntilExit: () => Promise.resolve(),
+    };
   },
   Text: 'Text',
   Box: 'Box',
@@ -146,11 +150,14 @@ describe('registerFeedback', () => {
     expect(mockHandleFeedback).not.toHaveBeenCalled();
   });
 
-  it('hands off to the TUI when no message argument is provided', async () => {
-    await program.parseAsync(['feedback'], { from: 'user' });
+  it('hands off to the TUI when no message argument is provided, then exits cleanly', async () => {
+    await expect(program.parseAsync(['feedback'], { from: 'user' })).rejects.toThrow('process.exit');
 
     expect(mockRequireTTY).toHaveBeenCalled();
     expect(mockRender).toHaveBeenCalled();
     expect(mockHandleFeedback).not.toHaveBeenCalled();
+    // After the wizard unmounts we must terminate the Node process; otherwise
+    // Ink's stdin raw-mode listeners keep the process alive.
+    expect(mockExit).toHaveBeenCalledWith(0);
   });
 });

src/cli/commands/feedback/command.tsx

@@ -24,7 +24,7 @@ export const registerFeedback = (program: Command) => {
           return;
         }
         requireTTY();
-        const { clear, unmount } = render(
+        const { clear, unmount, waitUntilExit } = render(
           <FeedbackScreen
             initialScreenshot={options.screenshot}
             onExit={() => {
@@ -33,7 +33,10 @@ export const registerFeedback = (program: Command) => {
             }}
           />
         );
-        return;
+        // Wait for the wizard to unmount, then exit. Without this Node sticks
+        // around because of Ink's stdin raw-mode listeners.
+        await waitUntilExit();
+        process.exit(0);
       }
 
       const has_screenshot = !!options.screenshot;

src/cli/operations/feedback/__tests__/submit-feedback.test.ts

@@ -147,6 +147,33 @@ describe('submitFeedback', () => {
     expect(fetchMock).not.toHaveBeenCalled();
   });
 
+  it('rejects a directory with a directory-specific error, not the extension error', async () => {
+    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'feedback-test-'));
+    await expect(submitFeedback({ message: 'msg', screenshot: { path: tmp } })).rejects.toThrow(
+      /is a directory, not a file/
+    );
+    expect(fetchMock).not.toHaveBeenCalled();
+    await fs.rm(tmp, { recursive: true, force: true });
+  });
+
+  it('expands a leading tilde so quoted paths like "~/file.png" resolve', async () => {
+    // Drop a real file in $HOME so tilde-expansion has somewhere to land
+    const fileName = `feedback-tilde-${Date.now()}.png`;
+    const realPath = path.join(os.homedir(), fileName);
+    await fs.writeFile(realPath, Buffer.from([0x89, 0x50, 0x4e, 0x47]));
+
+    fetchMock
+      .mockResolvedValueOnce(new Response('https://s3.example/key?sig=x', { status: 200 }))
+      .mockResolvedValueOnce(emptyOk(200))
+      .mockResolvedValueOnce(jsonResponse(successResponse));
+
+    const result = await submitFeedback({ message: 'tilde', screenshot: { path: `~/${fileName}` } });
+    expect(result.id).toBe('submission-123');
+    expect(fetchMock).toHaveBeenCalledTimes(3);
+
+    await fs.rm(realPath, { force: true });
+  });
+
   it('maps Aperture 412 responses to a missing-headers error', async () => {
     fetchMock.mockResolvedValueOnce(new Response('missing headers', { status: 412 }));
 

src/cli/operations/feedback/submit-feedback.ts

@@ -11,6 +11,7 @@ import {
 import type { FeedbackSubmissionResult, SubmitFeedbackInput } from './types';
 import { createHash } from 'node:crypto';
 import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
 import * as path from 'node:path';
 
 export class FeedbackValidationError extends Error {
@@ -73,7 +74,36 @@ interface LoadedScreenshot {
   size: number;
 }
 
-async function loadAndValidateScreenshot(filePath: string): Promise<LoadedScreenshot> {
+/**
+ * Expand a leading `~` or `~/...` to the user's home directory. Node's fs APIs
+ * don't expand tildes — the shell normally does — so users who quote a path
+ * like `"~/Desktop/foo.png"` to preserve spaces hit ENOENT. This handles that.
+ */
+function expandTilde(filePath: string): string {
+  if (filePath === '~') return os.homedir();
+  if (filePath.startsWith('~/')) return path.join(os.homedir(), filePath.slice(2));
+  return filePath;
+}
+
+async function loadAndValidateScreenshot(rawFilePath: string): Promise<LoadedScreenshot> {
+  const filePath = expandTilde(rawFilePath);
+
+  // Stat the path first so we can give a precise error for directories or
+  // missing files, rather than letting the extension check mask them.
+  let stat: Awaited<ReturnType<typeof fs.stat>>;
+  try {
+    stat = await fs.stat(filePath);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new FeedbackValidationError(`Could not read screenshot at ${filePath}: ${reason}`);
+  }
+  if (stat.isDirectory()) {
+    throw new FeedbackValidationError(`Screenshot path is a directory, not a file: ${filePath}`);
+  }
+  if (!stat.isFile()) {
+    throw new FeedbackValidationError(`Screenshot path is not a regular file: ${filePath}`);
+  }
+
   const ext = path.extname(filePath).toLowerCase();
   if (!ALLOWED_SCREENSHOT_EXTENSIONS.includes(ext as (typeof ALLOWED_SCREENSHOT_EXTENSIONS)[number])) {
     throw new FeedbackValidationError(`Screenshot must be one of: ${ALLOWED_SCREENSHOT_EXTENSIONS.join(', ')}.`);