autohand-cli 0.8.3 → 0.9.1

package/dist/{chunk-OHUZKDGX.js → chunk-P4FUTSVK.js}

@@ -1,13 +1,13 @@
 import {
   showConfirm
-} from "./chunk-YZXUDM5X.js";
+} from "./chunk-NZ3ZWLUW.js";
 import {
   AUTOHAND_PATHS,
   PROJECT_DIR_NAME
-} from "./chunk-EGFT4PGW.js";
+} from "./chunk-SHRLFX6F.js";
 import {
   t
-} from "./chunk-APIXPPMT.js";
+} from "./chunk-LEZEWKPA.js";
 
 // src/skills/communityInstaller.ts
 import crypto from "crypto";

package/dist/chunk-P6SLT2F4.cjs

@@ -0,0 +1,139 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkKASXKDF2cjs = require('./chunk-KASXKDF2.cjs');
+
+// src/permissions/localProjectPermissions.ts
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var LOCAL_SETTINGS_FILE = "settings.local.json";
+function normalizePermissionSettings(settings) {
+  if (!settings) {
+    return settings;
+  }
+  const allowList = _nullishCoalesce(_nullishCoalesce(settings.allowList, () => ( settings.whitelist)), () => ( []));
+  const denyList = _nullishCoalesce(_nullishCoalesce(settings.denyList, () => ( settings.blacklist)), () => ( []));
+  return {
+    ...settings,
+    allowList,
+    denyList,
+    whitelist: void 0,
+    blacklist: void 0
+  };
+}
+function getLocalSettingsPath(workspaceRoot) {
+  return _path2.default.join(workspaceRoot, _chunkKASXKDF2cjs.PROJECT_DIR_NAME, LOCAL_SETTINGS_FILE);
+}
+async function loadLocalProjectSettings(workspaceRoot) {
+  const settingsPath = getLocalSettingsPath(workspaceRoot);
+  try {
+    if (await _fsextra2.default.pathExists(settingsPath)) {
+      const content = await _fsextra2.default.readFile(settingsPath, "utf8");
+      const parsed = JSON.parse(content);
+      return {
+        ...parsed,
+        permissions: normalizePermissionSettings(parsed.permissions)
+      };
+    }
+  } catch (error) {
+    console.error(`Warning: Failed to parse local settings at ${settingsPath}:`, error.message);
+  }
+  return null;
+}
+async function saveLocalProjectSettings(workspaceRoot, settings) {
+  const settingsPath = getLocalSettingsPath(workspaceRoot);
+  const dir = _path2.default.dirname(settingsPath);
+  await _fsextra2.default.ensureDir(dir);
+  const toSave = {
+    ...settings,
+    version: 1
+  };
+  await _fsextra2.default.writeJson(settingsPath, toSave, { spaces: 2 });
+}
+async function addToLocalAllowList(workspaceRoot, pattern) {
+  const current = await loadLocalProjectSettings(workspaceRoot) || {};
+  const permissions = normalizePermissionSettings(current.permissions) || {};
+  const allowList = permissions.allowList || [];
+  if (!allowList.includes(pattern)) {
+    allowList.push(pattern);
+    await saveLocalProjectSettings(workspaceRoot, {
+      ...current,
+      permissions: {
+        ...permissions,
+        allowList
+      }
+    });
+  }
+}
+async function addToLocalDenyList(workspaceRoot, pattern) {
+  const current = await loadLocalProjectSettings(workspaceRoot) || {};
+  const permissions = normalizePermissionSettings(current.permissions) || {};
+  const denyList = permissions.denyList || [];
+  if (!denyList.includes(pattern)) {
+    denyList.push(pattern);
+    await saveLocalProjectSettings(workspaceRoot, {
+      ...current,
+      permissions: {
+        ...permissions,
+        denyList
+      }
+    });
+  }
+}
+function mergePermissions(globalSettings, localSettings) {
+  const normalizedGlobal = _nullishCoalesce(normalizePermissionSettings(globalSettings), () => ( {}));
+  const normalizedLocal = normalizePermissionSettings(localSettings);
+  if (!normalizedLocal) {
+    return normalizedGlobal;
+  }
+  return {
+    // Global settings as base
+    ...normalizedGlobal,
+    // Local mode overrides global if set
+    mode: normalizedLocal.mode || normalizedGlobal.mode,
+    allowList: [
+      ...normalizedGlobal.allowList || [],
+      ...normalizedLocal.allowList || []
+    ].filter((v, i, a) => a.indexOf(v) === i),
+    denyList: [
+      ...normalizedGlobal.denyList || [],
+      ...normalizedLocal.denyList || []
+    ].filter((v, i, a) => a.indexOf(v) === i),
+    // Merge rules (local rules checked first)
+    rules: [
+      ...normalizedLocal.rules || [],
+      ...normalizedGlobal.rules || []
+    ],
+    // Use local rememberSession if set, otherwise global
+    rememberSession: _nullishCoalesce(normalizedLocal.rememberSession, () => ( normalizedGlobal.rememberSession)),
+    allowPatterns: [
+      ...normalizedGlobal.allowPatterns || [],
+      ...normalizedLocal.allowPatterns || []
+    ],
+    denyPatterns: [
+      ...normalizedGlobal.denyPatterns || [],
+      ...normalizedLocal.denyPatterns || []
+    ],
+    availableTools: [
+      ...normalizedGlobal.availableTools || [],
+      ...normalizedLocal.availableTools || []
+    ],
+    excludedTools: [
+      ...normalizedGlobal.excludedTools || [],
+      ...normalizedLocal.excludedTools || []
+    ],
+    allPathsAllowed: _nullishCoalesce(normalizedLocal.allPathsAllowed, () => ( normalizedGlobal.allPathsAllowed)),
+    allUrlsAllowed: _nullishCoalesce(normalizedLocal.allUrlsAllowed, () => ( normalizedGlobal.allUrlsAllowed))
+  };
+}
+
+
+
+
+
+
+exports.loadLocalProjectSettings = loadLocalProjectSettings; exports.addToLocalAllowList = addToLocalAllowList; exports.addToLocalDenyList = addToLocalDenyList; exports.mergePermissions = mergePermissions;
+/**
+ * Local Project Permissions
+ * Handles per-project permission settings stored in .autohand/settings.local.json
+ * @license Apache-2.0
+ */

package/dist/{chunk-TNZRZQ7Q.js → chunk-PB7W7R72.js}

@@ -1,12 +1,3 @@
-import {
-  t
-} from "./chunk-APIXPPMT.js";
-
-// src/commands/add-dir.ts
-import chalk2 from "chalk";
-import fs2 from "fs-extra";
-import path2 from "path";
-
 // src/startup/workspaceSafety.ts
 import os from "os";
 import path from "path";
@@ -65,9 +56,9 @@ function normalizePath(inputPath) {
   }
   return normalized;
 }
-function pathsEqual(path1, path22) {
+function pathsEqual(path1, path2) {
   const normalized1 = normalizePath(path1);
-  const normalized2 = normalizePath(path22);
+  const normalized2 = normalizePath(path2);
   if (process.platform === "darwin" || process.platform === "win32") {
     return normalized1.toLowerCase() === normalized2.toLowerCase();
   }
@@ -260,73 +251,7 @@ function printDangerousWorkspaceWarning(workspacePath, result) {
   console.log();
 }
 
-// src/commands/add-dir.ts
-async function addDir(ctx, args) {
-  const dirPath = args.join(" ").trim();
-  if (!dirPath) {
-    console.log();
-    console.log(chalk2.bold.cyan("Workspace Directories"));
-    console.log(chalk2.gray("\u2500".repeat(50)));
-    console.log();
-    console.log(chalk2.bold("Primary Workspace:"));
-    console.log(chalk2.cyan(`  ${ctx.workspaceRoot}`));
-    console.log();
-    if (ctx.additionalDirs.length > 0) {
-      console.log(chalk2.bold("Additional Directories:"));
-      ctx.additionalDirs.forEach((dir, index) => {
-        console.log(chalk2.green(`  ${index + 1}. ${dir}`));
-      });
-    } else {
-      console.log(chalk2.gray("No additional directories configured."));
-    }
-    console.log();
-    console.log(chalk2.gray("Usage: /add-dir <path> to add a new directory"));
-    console.log();
-    return null;
-  }
-  const resolvedPath = path2.resolve(dirPath);
-  if (!await fs2.pathExists(resolvedPath)) {
-    console.log(chalk2.red(t("commands.addDir.notFound", { path: dirPath })));
-    return null;
-  }
-  const stats = await fs2.stat(resolvedPath);
-  if (!stats.isDirectory()) {
-    console.log(chalk2.red(`Error: Path is not a directory: ${dirPath}`));
-    return null;
-  }
-  const safetyResult = checkWorkspaceSafety(resolvedPath);
-  if (!safetyResult.safe) {
-    console.log(chalk2.red(`Error: Unsafe directory: ${dirPath}`));
-    console.log(chalk2.yellow(`  ${safetyResult.reason}`));
-    return null;
-  }
-  if (resolvedPath === ctx.workspaceRoot) {
-    console.log(chalk2.yellow(`Directory is already the primary workspace: ${resolvedPath}`));
-    return null;
-  }
-  if (ctx.additionalDirs.includes(resolvedPath)) {
-    console.log(chalk2.yellow(t("commands.addDir.alreadyAdded", { path: resolvedPath })));
-    return null;
-  }
-  ctx.addAdditionalDir(resolvedPath);
-  console.log(chalk2.green(t("commands.addDir.added", { path: resolvedPath })));
-  console.log(chalk2.gray("You can now read, write, and modify files in this directory."));
-  return null;
-}
-var metadata = {
-  command: "/add-dir",
-  description: t("commands.addDir.description"),
-  implemented: true
-};
-
 export {
   checkWorkspaceSafety,
-  printDangerousWorkspaceWarning,
-  addDir,
-  metadata
+  printDangerousWorkspaceWarning
 };
-/**
- * @license
- * Copyright 2025 Autohand AI LLC
- * SPDX-License-Identifier: Apache-2.0
- */

package/dist/chunk-PCM3N3CL.cjs

@@ -0,0 +1,37 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/commands/yolo.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+async function toggleYolo(ctx) {
+  if (!ctx.setYoloMode) {
+    return "YOLO mode toggle not available in this context.";
+  }
+  const isActive = ctx.permissionManager.getMode() === "unrestricted";
+  if (isActive) {
+    ctx.setYoloMode(void 0);
+    console.log();
+    console.log(_chalk2.default.cyan("YOLO mode deactivated. Returning to interactive approval."));
+    console.log();
+  } else {
+    ctx.setYoloMode("allow:*");
+    console.log();
+    console.log(_chalk2.default.yellow.bold("\u{1F680} YOLO MODE ACTIVATED"));
+    console.log(_chalk2.default.gray("You only live once! All actions will be auto-approved."));
+    console.log(_chalk2.default.gray("Security blacklist still applies for sensitive files."));
+    console.log();
+  }
+  return null;
+}
+var metadata = {
+  command: "/yolo",
+  description: "Toggle YOLO mode \u2014 auto-approve all actions",
+  implemented: true
+};
+
+
+
+
+exports.toggleYolo = toggleYolo; exports.metadata = metadata;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-2AA5MFES.js → chunk-PGFLPURU.js}

@@ -1,15 +1,16 @@
 import {
   AUTOHAND_PATHS
-} from "./chunk-EGFT4PGW.js";
+} from "./chunk-SHRLFX6F.js";
 
 // src/session/SessionManager.ts
 import fs from "fs-extra";
 import path from "path";
 import crypto from "crypto";
 var SessionManager = class {
+  sessionsDir;
+  currentSession = null;
+  index = null;
   constructor(baseDir) {
-    this.currentSession = null;
-    this.index = null;
     this.sessionsDir = baseDir ?? AUTOHAND_PATHS.sessions;
   }
   async initialize() {
@@ -138,9 +139,11 @@ var SessionManager = class {
   }
 };
 var Session = class {
+  sessionDir;
+  metadata;
+  messages = [];
+  state = null;
   constructor(sessionDir, metadata) {
-    this.messages = [];
-    this.state = null;
     this.sessionDir = sessionDir;
     this.metadata = metadata;
   }

package/dist/{chunk-DJDE4DTT.cjs → chunk-PIXQ2AVM.cjs}

@@ -1,9 +1,9 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-var _chunkZYQMLKOKcjs = require('./chunk-ZYQMLKOK.cjs');
+var _chunkCK4HAHVYcjs = require('./chunk-CK4HAHVY.cjs');
 
 
-var _chunk7BTSG4MEcjs = require('./chunk-7BTSG4ME.cjs');
+var _chunkSY2P3Z5Wcjs = require('./chunk-SY2P3Z5W.cjs');
 
 // src/commands/ide.ts
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
@@ -398,24 +398,24 @@ function groupByIDE(detected) {
 }
 async function ide(ctx) {
   console.log(_chalk2.default.bold.cyan(`
-${_chunk7BTSG4MEcjs.t.call(void 0, "commands.ide.title")}`));
-  console.log(_chalk2.default.gray(_chunk7BTSG4MEcjs.t.call(void 0, "commands.ide.connectDescription")));
+${_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.ide.title")}`));
+  console.log(_chalk2.default.gray(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.ide.connectDescription")));
   console.log();
   const detected = await detectRunningIDEs(ctx.workspaceRoot);
   const { matching, nonMatching } = groupByIDE(detected);
   if (detected.length === 0) {
-    console.log(_chalk2.default.yellow(_chunk7BTSG4MEcjs.t.call(void 0, "commands.ide.noIdesDetected")));
+    console.log(_chalk2.default.yellow(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.ide.noIdesDetected")));
     console.log();
     printExtensionSuggestions(detected);
     return null;
   }
   if (matching.length === 0) {
-    console.log(_chalk2.default.yellow(_chunk7BTSG4MEcjs.t.call(void 0, "commands.ide.noMatchingIdes")));
+    console.log(_chalk2.default.yellow(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.ide.noMatchingIdes")));
     console.log();
     if (nonMatching.size > 0) {
       console.log(
         _chalk2.default.gray(
-          _chunk7BTSG4MEcjs.t.call(void 0, "commands.ide.otherNotMatching", { count: String(nonMatching.size) })
+          _chunkSY2P3Z5Wcjs.t.call(void 0, "commands.ide.otherNotMatching", { count: String(nonMatching.size) })
         )
       );
       console.log();
@@ -426,21 +426,27 @@ ${_chunk7BTSG4MEcjs.t.call(void 0, "commands.ide.title")}`));
   }
   console.log(
     _chalk2.default.green(
-      _chunk7BTSG4MEcjs.t.call(void 0, "commands.ide.foundMatching", { count: String(matching.length) })
+      _chunkSY2P3Z5Wcjs.t.call(void 0, "commands.ide.foundMatching", { count: String(matching.length) })
     )
   );
   console.log();
   const options = matching.map((ide2) => ({
-    label: `${ide2.displayName}: ${_nullishCoalesce(ide2.workspacePath, () => ( _chunk7BTSG4MEcjs.t.call(void 0, "common.unknown")))}`,
+    label: `${ide2.displayName}: ${_nullishCoalesce(ide2.workspacePath, () => ( _chunkSY2P3Z5Wcjs.t.call(void 0, "common.unknown")))}`,
     value: ide2.kind
   }));
-  const result = await _chunkZYQMLKOKcjs.showModal.call(void 0, {
-    title: _chunk7BTSG4MEcjs.t.call(void 0, "commands.ide.selectPrompt"),
-    options
-  });
+  await _optionalChain([ctx, 'access', _4 => _4.onBeforeModal, 'optionalCall', _5 => _5()]);
+  let result;
+  try {
+    result = await _chunkCK4HAHVYcjs.showModal.call(void 0, {
+      title: _chunkSY2P3Z5Wcjs.t.call(void 0, "commands.ide.selectPrompt"),
+      options
+    });
+  } finally {
+    await _optionalChain([ctx, 'access', _6 => _6.onAfterModal, 'optionalCall', _7 => _7()]);
+  }
   if (!result) {
     console.log(_chalk2.default.gray(`
-${_chunk7BTSG4MEcjs.t.call(void 0, "common.cancelled")}`));
+${_chunkSY2P3Z5Wcjs.t.call(void 0, "common.cancelled")}`));
     return null;
   }
   const selected = matching.find((d) => d.kind === result.value);
@@ -448,7 +454,7 @@ ${_chunk7BTSG4MEcjs.t.call(void 0, "common.cancelled")}`));
     console.log(
       _chalk2.default.green(
         `
-\u2713 ${_chunk7BTSG4MEcjs.t.call(void 0, "commands.ide.connected", { ide: selected.displayName })}`
+\u2713 ${_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.ide.connected", { ide: selected.displayName })}`
       )
     );
   }
@@ -456,7 +462,7 @@ ${_chunk7BTSG4MEcjs.t.call(void 0, "common.cancelled")}`));
     console.log();
     console.log(
       _chalk2.default.gray(
-        _chunk7BTSG4MEcjs.t.call(void 0, "commands.ide.otherNotMatching", { count: String(nonMatching.size) })
+        _chunkSY2P3Z5Wcjs.t.call(void 0, "commands.ide.otherNotMatching", { count: String(nonMatching.size) })
       )
     );
     console.log();
@@ -467,7 +473,7 @@ ${_chunk7BTSG4MEcjs.t.call(void 0, "common.cancelled")}`));
 }
 function printNonMatchingIDEs(ides) {
   for (const ide2 of ides) {
-    const wsPath = _nullishCoalesce(ide2.workspacePath, () => ( _chunk7BTSG4MEcjs.t.call(void 0, "common.unknown")));
+    const wsPath = _nullishCoalesce(ide2.workspacePath, () => ( _chunkSY2P3Z5Wcjs.t.call(void 0, "common.unknown")));
     console.log(_chalk2.default.gray(`  \u2022 ${ide2.displayName}: ${wsPath}`));
   }
   console.log();
@@ -475,7 +481,7 @@ function printNonMatchingIDEs(ides) {
 function printExtensionSuggestions(detected) {
   const suggestions = getExtensionSuggestions(detected);
   if (suggestions.length === 0) return;
-  console.log(_chalk2.default.dim(`\u{1F4A1} ${_chunk7BTSG4MEcjs.t.call(void 0, "commands.ide.extensionHint")}`));
+  console.log(_chalk2.default.dim(`\u{1F4A1} ${_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.ide.extensionHint")}`));
   for (const suggestion of suggestions) {
     const link = _terminallink2.default.call(void 0, suggestion.url, suggestion.url);
     console.log(_chalk2.default.dim(`  \u2022 ${suggestion.displayName}: ${link}`));
@@ -484,7 +490,7 @@ function printExtensionSuggestions(detected) {
 }
 var metadata = {
   command: "/ide",
-  description: _chunk7BTSG4MEcjs.t.call(void 0, "commands.ide.description"),
+  description: _chunkSY2P3Z5Wcjs.t.call(void 0, "commands.ide.description"),
   implemented: true
 };
 

package/dist/chunk-PNIAIOMZ.cjs

@@ -0,0 +1,229 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkM7B7RRBKcjs = require('./chunk-M7B7RRBK.cjs');
+
+
+var _chunkAQ5PVHOCcjs = require('./chunk-AQ5PVHOC.cjs');
+
+
+var _chunkX5P6QQOBcjs = require('./chunk-X5P6QQOB.cjs');
+
+// src/reporting/processErrorReporting.ts
+var DEFAULT_API_BASE_URL = "https://api.autohand.ai";
+var DEFAULT_REPORT_TIMEOUT_MS = 6500;
+var installedProcesses = /* @__PURE__ */ new WeakSet();
+var managerCache = /* @__PURE__ */ new Map();
+function getArgValue(argv, flag) {
+  if (!argv) {
+    return void 0;
+  }
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === flag) {
+      return argv[i + 1];
+    }
+    if (token.startsWith(`${flag}=`)) {
+      return token.slice(flag.length + 1);
+    }
+  }
+  return void 0;
+}
+function resolveConfigPath(processRef, explicitPath) {
+  return _nullishCoalesce(_nullishCoalesce(explicitPath, () => ( getArgValue(processRef.argv, "--config"))), () => ( processRef.env.AUTOHAND_CONFIG));
+}
+function detectClientName(processRef) {
+  const envClientName = processRef.env.AUTOHAND_CLIENT_NAME;
+  if (envClientName) {
+    return envClientName;
+  }
+  const mode = getArgValue(processRef.argv, "--mode");
+  if (mode === "acp" || mode === "rpc") {
+    return mode;
+  }
+  return "cli";
+}
+function getLogPrefix(processRef) {
+  return detectClientName(processRef) === "acp" ? "[ACP]" : "[DEBUG]";
+}
+function captureLastError(reason) {
+  globalThis.__autohandLastError = reason;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function buildFallbackConfig(configPath, processRef) {
+  return {
+    provider: "openrouter",
+    api: {
+      baseUrl: processRef.env.AUTOHAND_API_URL || DEFAULT_API_BASE_URL,
+      companySecret: processRef.env.AUTOHAND_SECRET || ""
+    },
+    autoReport: {
+      enabled: true
+    },
+    telemetry: {
+      enabled: false
+    },
+    configPath: _nullishCoalesce(configPath, () => ( "process-error-fallback")),
+    isNewConfig: false
+  };
+}
+async function getAutoReportManager(processRef, explicitConfigPath) {
+  const configPath = resolveConfigPath(processRef, explicitConfigPath);
+  const cacheKey = _nullishCoalesce(configPath, () => ( "__default__"));
+  const cached = managerCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const managerPromise = (async () => {
+    let config;
+    try {
+      config = await _chunkX5P6QQOBcjs.loadConfig.call(void 0, configPath);
+    } catch (e) {
+      config = buildFallbackConfig(configPath, processRef);
+    }
+    return new (0, _chunkM7B7RRBKcjs.AutoReportManager)(config, _chunkAQ5PVHOCcjs.package_default.version);
+  })();
+  managerCache.set(cacheKey, managerPromise);
+  return managerPromise;
+}
+function isIgnorableStdinReadError(err, _processRef) {
+  if (!err || typeof err !== "object") {
+    return false;
+  }
+  const maybeError = err;
+  return maybeError.code === "EIO" && maybeError.syscall === "read";
+}
+function isIgnorableFilesystemError(err) {
+  if (!err || typeof err !== "object") return false;
+  const maybeError = err;
+  if (maybeError.syscall !== "mkdir") return false;
+  return maybeError.code === "EACCES" || maybeError.code === "EEXIST";
+}
+function isIgnorableTerminalOrRuntimeError(err) {
+  if (!err || typeof err !== "object") return false;
+  const message = _nullishCoalesce(err.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, processRef) {
+  if (reason && typeof reason === "object" && reason.code === "ERR_USE_AFTER_CLOSE") {
+    return true;
+  }
+  if (isIgnorableStdinReadError(reason, processRef)) return true;
+  if (isIgnorableFilesystemError(reason)) return true;
+  if (isIgnorableTerminalOrRuntimeError(reason)) return true;
+  return false;
+}
+function toReportableError(reason) {
+  if (reason instanceof Error) {
+    return reason;
+  }
+  const fallbackName = "NonErrorProcessFault";
+  if (reason && typeof reason === "object") {
+    const maybeErrorLike = reason;
+    const message = typeof maybeErrorLike.message === "string" ? maybeErrorLike.message : safeSerialize(reason);
+    const error2 = new Error(message);
+    error2.name = typeof maybeErrorLike.name === "string" ? maybeErrorLike.name : fallbackName;
+    return error2;
+  }
+  const error = new Error(typeof reason === "string" ? reason : String(reason));
+  error.name = fallbackName;
+  return error;
+}
+function safeSerialize(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (e2) {
+    return String(value);
+  }
+}
+function describeReasonType(reason) {
+  if (reason === null) {
+    return "null";
+  }
+  if (Array.isArray(reason)) {
+    return "array";
+  }
+  return typeof reason;
+}
+async function reportProcessError(reason, options) {
+  const processRef = _nullishCoalesce(options.processRef, () => ( process));
+  if (options.handler === "unhandledRejection" && isIgnorableUnhandledRejection(reason, processRef)) {
+    return;
+  }
+  if (options.handler === "uncaughtException" && (isIgnorableStdinReadError(reason, processRef) || isIgnorableTerminalOrRuntimeError(reason))) {
+    return;
+  }
+  captureLastError(reason);
+  const error = toReportableError(reason);
+  const manager = await getAutoReportManager(processRef, options.configPath);
+  const reportPromise = manager.reportError(error, {
+    context: {
+      source: "process",
+      handler: options.handler,
+      clientName: detectClientName(processRef),
+      fatal: options.handler === "uncaughtException",
+      rawType: describeReasonType(reason),
+      ..._nullishCoalesce(options.extraContext, () => ( {}))
+    }
+  });
+  await Promise.race([
+    reportPromise,
+    sleep(_nullishCoalesce(options.reportTimeoutMs, () => ( DEFAULT_REPORT_TIMEOUT_MS)))
+  ]);
+}
+function installProcessErrorHandlers(options = {}) {
+  const processRef = _nullishCoalesce(options.processRef, () => ( process));
+  if (installedProcesses.has(processRef)) {
+    return;
+  }
+  installedProcesses.add(processRef);
+  const logError = _nullishCoalesce(options.logError, () => ( console.error.bind(console)));
+  const exit = _nullishCoalesce(options.exit, () => ( ((code) => {
+    processRef.exit(code);
+  })));
+  processRef.on("uncaughtException", (error) => {
+    if (isIgnorableStdinReadError(error, processRef)) {
+      return;
+    }
+    if (isIgnorableTerminalOrRuntimeError(error)) {
+      return;
+    }
+    captureLastError(error);
+    logError(`${getLogPrefix(processRef)} Uncaught Exception:`, error);
+    void (async () => {
+      await reportProcessError(error, {
+        handler: "uncaughtException",
+        processRef,
+        configPath: options.configPath,
+        reportTimeoutMs: options.reportTimeoutMs
+      });
+      exit(1);
+    })();
+  });
+  processRef.on("unhandledRejection", (reason, promise) => {
+    if (isIgnorableUnhandledRejection(reason, processRef)) {
+      return;
+    }
+    captureLastError(reason);
+    logError(`${getLogPrefix(processRef)} Unhandled Rejection at:`, promise, "reason:", reason);
+    void reportProcessError(reason, {
+      handler: "unhandledRejection",
+      processRef,
+      configPath: options.configPath,
+      reportTimeoutMs: options.reportTimeoutMs
+    });
+  });
+}
+
+
+
+exports.installProcessErrorHandlers = installProcessErrorHandlers;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */