Merge branch 'worktree-gh_issues'

Author: igorcosta

src/commands/status.ts

@@ -89,7 +89,7 @@ function renderStatusUI(data: StatusData): Promise<void> {
             // Ensure we receive raw byte sequences (works even if readline keypress events are unavailable)
             readline.emitKeypressEvents(input);
             if (!wasRaw && typeof input.setRawMode === 'function') {
-                input.setRawMode(true);
+                try { input.setRawMode(true); } catch { /* TTY may be gone */ }
             }
             if (typeof input.setEncoding === 'function') {
                 input.setEncoding('utf8');
@@ -175,7 +175,7 @@ function renderStatusUI(data: StatusData): Promise<void> {
         const cleanup = () => {
             input.off('data', handler);
             if (isTTY && !wasRaw && typeof input.setRawMode === 'function') {
-                input.setRawMode(false);
+                try { input.setRawMode(false); } catch { /* TTY may be gone */ }
             }
             if (wasPaused && typeof input.pause === 'function') {
                 input.pause();

src/commands/sync.ts

@@ -112,7 +112,7 @@ function renderSyncUI(data: SyncData, ctx: SlashCommandContext): Promise<void> {
     if (isTTY) {
       readline.emitKeypressEvents(input);
       if (!wasRaw && typeof input.setRawMode === 'function') {
-        input.setRawMode(true);
+        try { input.setRawMode(true); } catch { /* TTY may be gone */ }
       }
       if (typeof input.setEncoding === 'function') {
         input.setEncoding('utf8');
@@ -198,7 +198,7 @@ function renderSyncUI(data: SyncData, ctx: SlashCommandContext): Promise<void> {
     const cleanup = () => {
       input.off('keypress', handler as any);
       if (isTTY && !wasRaw && typeof input.setRawMode === 'function') {
-        input.setRawMode(false);
+        try { input.setRawMode(false); } catch { /* TTY may be gone */ }
       }
       if (wasPaused && typeof input.pause === 'function') {
         input.pause();

src/feedback/FeedbackManager.ts

@@ -441,7 +441,7 @@ export class FeedbackManager {
       const stdin = process.stdin;
       const wasRaw = stdin.isRaw;
 
-      stdin.setRawMode(true);
+      try { stdin.setRawMode(true); } catch { /* TTY may be gone */ }
       stdin.resume();
       stdin.setEncoding('utf8');
 
@@ -452,7 +452,7 @@ export class FeedbackManager {
 
       const cleanup = () => {
         clearTimeout(timeout);
-        stdin.setRawMode(wasRaw ?? false);
+        try { stdin.setRawMode(wasRaw ?? false); } catch { /* TTY may be gone */ }
         stdin.removeListener('data', onData);
       };
 

src/import/importers/CursorImporter.ts

@@ -492,7 +492,13 @@ export class CursorImporter extends BaseImporter {
     messages: SessionMessage[];
   } | null> {
     // Lazy-load node:sqlite so the binary doesn't crash on runtimes that lack it (e.g. Bun)
-    const { DatabaseSync } = await import('node:sqlite');
+    let DatabaseSync: typeof import('node:sqlite').DatabaseSync;
+    try {
+      ({ DatabaseSync } = await import('node:sqlite'));
+    } catch {
+      // node:sqlite is unavailable on this runtime (e.g. Bun) — skip SQLite-based import
+      return null;
+    }
     const db = new DatabaseSync(dbPath, { readOnly: true } as Record<string, unknown>);
 
     try {

src/providers/errors.ts

@@ -269,6 +269,21 @@ function matchesAny(lower: string, patterns: readonly string[]): boolean {
   return patterns.some((p) => lower.includes(p));
 }
 
+/**
+ * Strip HTML tags from error bodies (e.g. nginx 502 Bad Gateway pages).
+ * Returns the original string if it doesn't look like HTML.
+ */
+function stripHtmlFromBody(body: string): string {
+  if (!/<[a-z/][\s\S]*>/i.test(body)) {
+    return body;
+  }
+  // Remove tags, collapse whitespace, trim
+  return body
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
 function makeError(
   code: ApiErrorCode,
   httpStatus: number,
@@ -277,8 +292,9 @@ function makeError(
   headers?: Headers,
 ): ApiError {
   const friendlyMessage = FRIENDLY_MESSAGES[code];
-  const message = rawBody
-    ? `${friendlyMessage}\n${rawBody}`
+  const displayBody = rawBody ? stripHtmlFromBody(rawBody) : '';
+  const message = displayBody
+    ? `${friendlyMessage}\n${displayBody}`
     : friendlyMessage;
 
   const retryAfterMs = parseRetryAfter(headers) ?? inferRetryAfterFromBody(code, rawBody);

src/reporting/AutoReportManager.ts

@@ -10,6 +10,8 @@ import crypto from 'node:crypto';
 import type { AutohandConfig } from '../types.js';
 import type { ErrorReport } from './types.js';
 import { AutoReportClient } from './AutoReportClient.js';
+import { ApiError } from '../providers/errors.js';
+import type { ApiErrorCode } from '../providers/errors.js';
 
 const isDebug = () => process.env.AUTOHAND_DEBUG === '1';
 
@@ -31,6 +33,33 @@ export class AutoReportManager {
     return this.enabled;
   }
 
+  /**
+   * API error codes that represent expected operational conditions, NOT bugs.
+   * These should never be auto-reported as GitHub issues.
+   */
+  private static readonly OPERATIONAL_API_ERROR_CODES: ReadonlySet<ApiErrorCode> = new Set([
+    'rate_limited',     // User hit rate limits — expected, handled by retry
+    'cancelled',        // User cancelled the request
+    'timeout',          // Provider too slow — expected for local inference
+    'network_error',    // Can't reach provider — user's network
+    'server_error',     // Provider is down — not our bug
+    'auth_failed',      // Bad API key — user config issue
+    'payment_required', // Account billing issue
+    'access_denied',    // API key lacks permissions
+    'model_not_found',  // Wrong model name — user config issue
+  ]);
+
+  /**
+   * Check if an error represents an expected operational condition
+   * that should NOT be auto-reported as a bug.
+   */
+  isOperationalError(error: Error): boolean {
+    if (error instanceof ApiError) {
+      return AutoReportManager.OPERATIONAL_API_ERROR_CODES.has(error.code);
+    }
+    return false;
+  }
+
   /**
    * Compute a simple hash from error name + message for in-session deduplication
    */
@@ -47,6 +76,14 @@ export class AutoReportManager {
     try {
       if (!this.enabled) return;
 
+      // Skip expected operational errors — they are not bugs
+      if (this.isOperationalError(error)) {
+        if (isDebug()) {
+          process.stderr.write(`[autohand:report] Skipping operational error: ${(error as ApiError).code}\n`);
+        }
+        return;
+      }
+
       const hash = this.computeHash(error);
       if (this.reportedHashes.has(hash)) {
         if (isDebug()) {

src/reporting/processErrorReporting.ts

@@ -141,12 +141,43 @@ function isIgnorableStdinReadError(err: unknown, _processRef: ProcessLike): bool
   return maybeError.code === 'EIO' && maybeError.syscall === 'read';
 }
 
+/**
+ * Filesystem errors that are expected operational conditions:
+ * - EACCES on mkdir: user running CLI in a directory they can't write to
+ * - EEXIST on mkdir: race condition when multiple processes create the same dir
+ */
+function isIgnorableFilesystemError(err: unknown): boolean {
+  if (!err || typeof err !== 'object') return false;
+  const maybeError = err as { code?: string; syscall?: string };
+  if (maybeError.syscall !== 'mkdir') return false;
+  return maybeError.code === 'EACCES' || maybeError.code === 'EEXIST';
+}
+
+/**
+ * Terminal/IO errors that are expected during shutdown or in non-standard terminals:
+ * - setRawMode errno: TTY is dead (bad file descriptor during component unmount)
+ * - Generator is executing: concurrent readline/shell operations (harmless race)
+ * - node:sqlite resolution: runtime doesn't support node:sqlite (e.g. Bun)
+ */
+function isIgnorableTerminalOrRuntimeError(err: unknown): boolean {
+  if (!err || typeof err !== 'object') return false;
+  const message = (err as Error).message ?? '';
+  if (/setRawMode.*errno/i.test(message)) return true;
+  if (message === 'Generator is executing') return true;
+  if (message.includes('node:sqlite')) return true;
+  return false;
+}
+
 function isIgnorableUnhandledRejection(reason: unknown, processRef: ProcessLike): boolean {
   if (reason && typeof reason === 'object' && (reason as { code?: string }).code === 'ERR_USE_AFTER_CLOSE') {
     return true;
   }
 
-  return isIgnorableStdinReadError(reason, processRef);
+  if (isIgnorableStdinReadError(reason, processRef)) return true;
+  if (isIgnorableFilesystemError(reason)) return true;
+  if (isIgnorableTerminalOrRuntimeError(reason)) return true;
+
+  return false;
 }
 
 function toReportableError(reason: unknown): Error {
@@ -198,7 +229,8 @@ export async function reportProcessError(reason: unknown, options: ProcessErrorC
   if (options.handler === 'unhandledRejection' && isIgnorableUnhandledRejection(reason, processRef)) {
     return;
   }
-  if (options.handler === 'uncaughtException' && isIgnorableStdinReadError(reason, processRef)) {
+  if (options.handler === 'uncaughtException' &&
+    (isIgnorableStdinReadError(reason, processRef) || isIgnorableTerminalOrRuntimeError(reason))) {
     return;
   }
 
@@ -240,6 +272,9 @@ export function installProcessErrorHandlers(options: InstallProcessErrorHandlers
     if (isIgnorableStdinReadError(error, processRef)) {
       return;
     }
+    if (isIgnorableTerminalOrRuntimeError(error)) {
+      return;
+    }
 
     captureLastError(error);
     logError(`${getLogPrefix(processRef)} Uncaught Exception:`, error);

tests/config/configParser.test.ts

@@ -229,4 +229,29 @@ describe('configParser – error handling (Issue #3)', () => {
     const result = await loadConfig(configPath);
     expect(result.provider).toBe('openrouter');
   });
+
+  // ─── EACCES / EEXIST handling ─────────────────────────────────────────────
+
+  it('throws a clear error when config dir is not writable (EACCES)', async () => {
+    // Create a read-only dir and point config at a subdir
+    const readonlyDir = path.join(testDir, 'readonly');
+    await fse.ensureDir(readonlyDir);
+    await fse.chmod(readonlyDir, 0o444);
+
+    const configPath = path.join(readonlyDir, 'subdir', 'config.json');
+    const loadConfig = await importLoadConfig();
+
+    let caughtError: Error | null = null;
+    try {
+      await loadConfig(configPath);
+    } catch (e) {
+      caughtError = e as Error;
+    }
+
+    // Restore permissions for cleanup
+    await fse.chmod(readonlyDir, 0o755);
+
+    expect(caughtError).not.toBeNull();
+    expect(caughtError!.message).toMatch(/permission denied|EACCES|Cannot create/i);
+  });
 });

tests/import/CursorImporter.sqlite-fallback.test.ts

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Regression test: node:sqlite unavailable on Bun (Issue #43)
+ * Verifies CursorImporter gracefully returns null when node:sqlite cannot load.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import os from 'node:os';
+import path from 'node:path';
+
+vi.mock('fs-extra', () => ({
+  default: {
+    pathExists: vi.fn().mockResolvedValue(false),
+    readFile: vi.fn(),
+    readdir: vi.fn().mockResolvedValue([]),
+    readJson: vi.fn(),
+    ensureDir: vi.fn().mockResolvedValue(undefined),
+    writeJson: vi.fn().mockResolvedValue(undefined),
+    writeFile: vi.fn().mockResolvedValue(undefined),
+    copy: vi.fn().mockResolvedValue(undefined),
+  },
+}));
+
+// Simulate node:sqlite being unavailable (e.g. Bun runtime)
+vi.mock('node:sqlite', () => {
+  throw new Error('Could not resolve: "node:sqlite". Maybe you need to "bun install"?');
+});
+
+import fse from 'fs-extra';
+import { CursorImporter } from '../../src/import/importers/CursorImporter.js';
+
+const HOME = os.homedir();
+const CURSOR_HOME = path.join(HOME, '.cursor');
+
+describe('CursorImporter – node:sqlite unavailable (Issue #43)', () => {
+  let importer: CursorImporter;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    importer = new CursorImporter();
+  });
+
+  it('should not crash when importing sessions without node:sqlite', async () => {
+    // Set up scan to detect sessions
+    const sessionsDir = path.join(CURSOR_HOME, 'User', 'workspaceStorage');
+    vi.mocked(fse.pathExists).mockImplementation(async (p: string) => {
+      const s = String(p);
+      if (s === CURSOR_HOME) return true;
+      if (s === sessionsDir) return true;
+      return false;
+    });
+    vi.mocked(fse.readdir).mockImplementation(async (p: string) => {
+      if (String(p) === sessionsDir) {
+        return [{ name: 'abc123', isDirectory: () => true }] as any;
+      }
+      return [];
+    });
+
+    // Import should complete without throwing
+    const result = await importer.import(['sessions']);
+
+    // Should have 0 imported sessions (since sqlite was unavailable)
+    expect(result.imported).toBeDefined();
+  });
+});

tests/providers/apiErrors.test.ts

@@ -391,6 +391,47 @@ describe('classifyApiError', () => {
     });
   });
 
+  // =========================================================================
+  // HTML stripping in error messages (Issue #48)
+  // =========================================================================
+  describe('HTML stripping in error bodies', () => {
+    it('strips HTML tags from 502 Bad Gateway response', () => {
+      const htmlBody = '<html>\r\n<head><title>502 Bad Gateway</title></head>\r\n<body>\r\n<center><h1>502 Bad Gateway</h1></center>\r\n<hr><center>nginx</center>\r\n</body>\r\n</html>\r\n';
+      const err = classifyApiError(502, htmlBody);
+      expect(err.code).toBe('server_error');
+      expect(err.message).not.toContain('<html>');
+      expect(err.message).not.toContain('<head>');
+      expect(err.message).not.toContain('</h1>');
+      expect(err.message).toContain('502 Bad Gateway');
+    });
+
+    it('strips HTML from 503 Service Unavailable response', () => {
+      const htmlBody = '<html><body><h1>503 Service Temporarily Unavailable</h1></body></html>';
+      const err = classifyApiError(503, htmlBody);
+      expect(err.message).not.toContain('<html>');
+      expect(err.message).toContain('503 Service Temporarily Unavailable');
+    });
+
+    it('preserves JSON error bodies as-is', () => {
+      const jsonBody = '{"error":"model requires more system memory (9.9 GiB) than is available (3.7 GiB)"}';
+      const err = classifyApiError(500, jsonBody);
+      expect(err.message).toContain('model requires more system memory');
+    });
+
+    it('preserves plain text error bodies as-is', () => {
+      const textBody = 'Rate limit exceeded for model gpt-4o';
+      const err = classifyApiError(429, textBody);
+      expect(err.message).toContain('Rate limit exceeded for model gpt-4o');
+    });
+
+    it('preserves rawDetail with original HTML for debugging', () => {
+      const htmlBody = '<html><body>502 Bad Gateway</body></html>';
+      const err = classifyApiError(502, htmlBody);
+      // rawDetail should still have the original for debugging
+      expect(err.rawDetail).toBe(htmlBody);
+    });
+  });
+
   // =========================================================================
   // FRIENDLY_MESSAGES
   // =========================================================================