autohand-cli 0.8.3 → 0.9.1

package/dist/chunk-M7B7RRBK.cjs

@@ -0,0 +1,1034 @@
+"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 _class; var _class2; var _class3;
+
+var _chunkAQ5PVHOCcjs = require('./chunk-AQ5PVHOC.cjs');
+
+
+var _chunk3OF56EMAcjs = require('./chunk-3OF56EMA.cjs');
+
+
+var _chunk2VHB43IXcjs = require('./chunk-2VHB43IX.cjs');
+
+
+
+var _chunkKASXKDF2cjs = require('./chunk-KASXKDF2.cjs');
+
+// src/utils/sessionWorktree.ts
+var _child_process = require('child_process');
+var _fs = require('fs');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
+function runGit(cwd, args) {
+  const result = _child_process.spawnSync.call(void 0, "git", args, {
+    cwd,
+    encoding: "utf8"
+  });
+  return {
+    stdout: _nullishCoalesce(result.stdout, () => ( "")),
+    stderr: _nullishCoalesce(result.stderr, () => ( "")),
+    status: result.status
+  };
+}
+function ensureGitRepo(cwd) {
+  const result = runGit(cwd, ["rev-parse", "--show-toplevel"]);
+  if (result.status !== 0) {
+    const details = result.stderr.trim() || result.stdout.trim() || "unknown error";
+    throw new Error(`--worktree requires a git repository (git rev-parse failed: ${details})`);
+  }
+  return result.stdout.trim();
+}
+function sanitizeName(input) {
+  const trimmed = input.trim();
+  const normalized = trimmed.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+  return normalized || "autohand-worktree";
+}
+function buildAutoBranchName(mode) {
+  const ts = Date.now().toString(36);
+  const rand = _crypto2.default.randomBytes(3).toString("hex");
+  return sanitizeName(`autohand-${_nullishCoalesce(mode, () => ( "cli"))}-${ts}-${rand}`);
+}
+function branchExists(repoRoot, branchName) {
+  const result = runGit(repoRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`]);
+  return result.status === 0;
+}
+function findAvailablePath(basePath) {
+  if (!_fs.existsSync.call(void 0, basePath)) {
+    return basePath;
+  }
+  for (let i = 2; i < 1e3; i++) {
+    const candidate = `${basePath}-${i}`;
+    if (!_fs.existsSync.call(void 0, candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Unable to find available worktree path near ${basePath}`);
+}
+function isSessionWorktreeEnabled(worktree) {
+  return worktree !== void 0 && worktree !== false;
+}
+function prepareSessionWorktree(input) {
+  const repoRoot = ensureGitRepo(input.cwd);
+  const branchName = typeof input.worktree === "string" ? sanitizeName(input.worktree) : buildAutoBranchName(input.mode);
+  const repoName = _path2.default.basename(repoRoot);
+  const parentDir = _path2.default.dirname(repoRoot);
+  const basePath = _path2.default.join(parentDir, `${repoName}-${branchName}`);
+  const worktreePath = findAvailablePath(basePath);
+  const existingBranch = branchExists(repoRoot, branchName);
+  const args = existingBranch ? ["worktree", "add", worktreePath, branchName] : ["worktree", "add", "-b", branchName, worktreePath];
+  const result = runGit(repoRoot, args);
+  if (result.status !== 0) {
+    const details = result.stderr.trim() || result.stdout.trim() || "unknown error";
+    throw new Error(`Failed to create git worktree: ${details}`);
+  }
+  return {
+    repoRoot,
+    worktreePath,
+    branchName,
+    createdBranch: !existingBranch
+  };
+}
+
+// src/ui/theme/startup.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+function formatStartupBanner(logo) {
+  return logo.split("\n").map((line, index) => _chunk2VHB43IXcjs.themedFg.call(void 0, index % 2 === 0 ? "accent" : "borderAccent", line, _chalk2.default.cyan)).join("\n");
+}
+function formatWelcomeVersionPrefix(version) {
+  return `${_chunk2VHB43IXcjs.themedFg.call(void 0, "accent", "> Autohand", _chalk2.default.bold)} ${_chunk2VHB43IXcjs.themedFg.call(void 0, "muted", `v${version}`, _chalk2.default.gray)}`;
+}
+function formatUpdateAvailable(version) {
+  return _chunk2VHB43IXcjs.themedFg.call(void 0, "warning", ` \u2B06 Update available: v${version}`, _chalk2.default.yellow);
+}
+function formatUpdateReady() {
+  return _chunk2VHB43IXcjs.themedFg.call(void 0, "success", " \u2713 Up to date", _chalk2.default.green);
+}
+function formatInstallHint(hint) {
+  return `${_chunk2VHB43IXcjs.themedFg.call(void 0, "muted", "  \u21B3 Run: ", _chalk2.default.gray)}${_chunk2VHB43IXcjs.themedFg.call(void 0, "accent", hint, _chalk2.default.cyan)}`;
+}
+function formatWelcomeGreeting(nameOrEmail) {
+  return _chunk2VHB43IXcjs.themedFg.call(void 0, "success", `Welcome back, ${nameOrEmail}!`, _chalk2.default.green);
+}
+function formatWelcomeStatusLine(model, ccEnabled, dir) {
+  const ccStatus = ccEnabled ? _chunk2VHB43IXcjs.themedFg.call(void 0, "success", "[CC: ON]", _chalk2.default.green) : _chunk2VHB43IXcjs.themedFg.call(void 0, "warning", "[CC: OFF]", _chalk2.default.yellow);
+  return [
+    _chunk2VHB43IXcjs.themedFg.call(void 0, "muted", "model:", _chalk2.default.gray),
+    _chunk2VHB43IXcjs.themedFg.call(void 0, "accent", model, _chalk2.default.cyan),
+    ccStatus,
+    _chunk2VHB43IXcjs.themedFg.call(void 0, "muted", "| directory:", _chalk2.default.gray),
+    _chunk2VHB43IXcjs.themedFg.call(void 0, "accent", dir, _chalk2.default.cyan)
+  ].join("  ");
+}
+function formatWelcomeTitle() {
+  return _chunk2VHB43IXcjs.themedFg.call(void 0, "muted", "To get started, describe a task or try one of these commands:", _chalk2.default.gray);
+}
+function formatWelcomeSuggestion(command, description) {
+  return _chunk2VHB43IXcjs.themedFg.call(void 0, "accent", `${command} `, _chalk2.default.cyan) + _chunk2VHB43IXcjs.themedFg.call(void 0, "muted", description, _chalk2.default.gray);
+}
+function formatSessionEnding() {
+  return _chunk2VHB43IXcjs.themedFg.call(void 0, "muted", "Ending Autohand session.", _chalk2.default.gray);
+}
+function formatSessionSaved(sessionId) {
+  return _chunk2VHB43IXcjs.themedFg.call(void 0, "accent", `\u{1F4BE} Session saved: ${sessionId}`, _chalk2.default.cyan);
+}
+function formatResumeHint(sessionId) {
+  return _chunk2VHB43IXcjs.themedFg.call(void 0, "muted", `   Resume with: autohand resume ${sessionId}`, _chalk2.default.gray);
+}
+function formatExitCleanup() {
+  return _chunk2VHB43IXcjs.themedFg.call(void 0, "muted", "\nExiting - clearing queues and stopping...", _chalk2.default.gray);
+}
+function formatForceExit() {
+  return _chunk2VHB43IXcjs.themedFg.call(void 0, "muted", "\nForce exiting...", _chalk2.default.gray);
+}
+
+// src/utils/debugLog.ts
+function isAutohandDebugEnabled(env = process.env) {
+  const value = _optionalChain([env, 'access', _ => _.AUTOHAND_DEBUG, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3(), 'access', _4 => _4.toLowerCase, 'call', _5 => _5()]);
+  return value === "1" || value === "true";
+}
+function writeAutohandDebugLine(message, writer) {
+  if (!isAutohandDebugEnabled()) {
+    return;
+  }
+  if (writer) {
+    writer(message);
+    return;
+  }
+  const line = message.endsWith("\n") ? message : `${message}
+`;
+  process.stderr.write(line);
+}
+
+// src/reporting/AutoReportManager.ts
+
+
+// src/reporting/AutoReportClient.ts
+
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var _os = require('os'); var _os2 = _interopRequireDefault(_os);
+var DEVICE_ID_FILE = _chunkKASXKDF2cjs.AUTOHAND_FILES.deviceId;
+var AutoReportClient = class {
+  
+  constructor(apiBaseUrl = "https://api.autohand.ai") {
+    this.apiBaseUrl = apiBaseUrl;
+  }
+  /**
+   * Read device ID from ~/.autohand/device-id (shared with telemetry)
+   */
+  getDeviceId() {
+    try {
+      if (_fsextra2.default.existsSync(DEVICE_ID_FILE)) {
+        return _fsextra2.default.readFileSync(DEVICE_ID_FILE, "utf8").trim();
+      }
+    } catch (e) {
+    }
+    return `anon-${_crypto2.default.randomUUID().slice(0, 8)}`;
+  }
+  /**
+   * Sanitize a string by replacing absolute paths with safe equivalents.
+   * Removes user home directories and any user-identifying paths.
+   */
+  sanitizePaths(text) {
+    const home = _os2.default.homedir();
+    let sanitized = text;
+    sanitized = sanitized.replaceAll(home, "~");
+    sanitized = sanitized.replace(/\/Users\/[^/\s:]+/g, "~/...");
+    sanitized = sanitized.replace(/\/home\/[^/\s:]+/g, "~/...");
+    sanitized = sanitized.replace(/[A-Z]:\\Users\\[^\\\s:]+/gi, "~\\...");
+    sanitized = sanitized.replace(/\\\\[^\\]+\\[^\\]+\\[^\\\s:]+/g, "~\\...");
+    return sanitized;
+  }
+  /** @deprecated Use sanitizePaths() instead */
+  sanitizeStack(stack) {
+    return this.sanitizePaths(stack);
+  }
+  /**
+   * Send an error report to the API
+   * NEVER throws - always returns a ReportResponse
+   */
+  async report(data) {
+    try {
+      const payload = {
+        ...data,
+        deviceId: this.getDeviceId(),
+        cliVersion: _chunkAQ5PVHOCcjs.package_default.version,
+        platform: process.platform,
+        osVersion: _os2.default.release(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5e3);
+      try {
+        const response = await fetch(`${this.apiBaseUrl}/v1/reports`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-CLI-Version": _chunkAQ5PVHOCcjs.package_default.version,
+            "X-Device-ID": payload.deviceId
+          },
+          body: JSON.stringify(payload),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          const errorText = await response.text().catch(() => "Unknown error");
+          return { success: false, error: `HTTP ${response.status}: ${errorText}` };
+        }
+        const result = await response.json();
+        return result;
+      } catch (err) {
+        clearTimeout(timeoutId);
+        if (err.name === "AbortError") {
+          return { success: false, error: "Request timeout" };
+        }
+        return { success: false, error: err.message };
+      }
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+};
+
+// src/reporting/AutoReportManager.ts
+var isDebug = () => isAutohandDebugEnabled();
+var AutoReportManager = (_class = class _AutoReportManager {
+  
+  __init() {this.reportedHashes = /* @__PURE__ */ new Set()}
+  
+  constructor(config, _cliVersion) {;_class.prototype.__init.call(this);
+    const apiBaseUrl = _optionalChain([config, 'access', _6 => _6.api, 'optionalAccess', _7 => _7.baseUrl]) || "https://api.autohand.ai";
+    this.client = new AutoReportClient(apiBaseUrl);
+    this.enabled = _optionalChain([config, 'access', _8 => _8.autoReport, 'optionalAccess', _9 => _9.enabled]) !== false;
+  }
+  /**
+   * Check if auto-reporting is enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * API error codes that represent expected operational conditions, NOT bugs.
+   * These should never be auto-reported as GitHub issues.
+   */
+  static __initStatic() {this.OPERATIONAL_API_ERROR_CODES = /* @__PURE__ */ 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) {
+    if (error instanceof _chunk3OF56EMAcjs.ApiError) {
+      return _AutoReportManager.OPERATIONAL_API_ERROR_CODES.has(error.code);
+    }
+    return false;
+  }
+  /**
+   * Compute a simple hash from error name + message for in-session deduplication
+   */
+  computeHash(error) {
+    const key = `${error.name}:${error.message.slice(0, 200)}`;
+    return _crypto2.default.createHash("sha256").update(key).digest("hex").slice(0, 16);
+  }
+  /**
+   * Report an error to the API
+   * NEVER throws - silently handles all failures
+   */
+  async reportError(error, context) {
+    try {
+      if (!this.enabled) return;
+      if (this.isOperationalError(error)) {
+        if (isDebug()) {
+          process.stderr.write(`[autohand:report] Skipping operational error: ${error.code}
+`);
+        }
+        return;
+      }
+      const hash = this.computeHash(error);
+      if (this.reportedHashes.has(hash)) {
+        if (isDebug()) {
+          process.stderr.write(`[autohand:report] Skipping duplicate error: ${hash}
+`);
+        }
+        return;
+      }
+      this.reportedHashes.add(hash);
+      const report = {
+        errorType: _optionalChain([context, 'optionalAccess', _10 => _10.errorType]) || error.name,
+        errorMessage: this.client.sanitizePaths(error.message.slice(0, 500)),
+        sanitizedStack: error.stack ? this.client.sanitizePaths(error.stack) : void 0,
+        ...context
+      };
+      const result = await this.client.report(report);
+      if (result.success) {
+        if (isDebug()) {
+          process.stderr.write(`[autohand:report] Reported: issue=${_nullishCoalesce(result.issueNumber, () => ( "n/a"))} dedup=${_nullishCoalesce(result.deduplicated, () => ( false))}
+`);
+        }
+        return;
+      }
+      if (isDebug()) {
+        process.stderr.write(`[autohand:report] First attempt failed: ${result.error}, retrying...
+`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      const retryResult = await this.client.report(report);
+      if (isDebug()) {
+        if (retryResult.success) {
+          process.stderr.write(`[autohand:report] Retry succeeded: issue=${_nullishCoalesce(retryResult.issueNumber, () => ( "n/a"))}
+`);
+        } else {
+          process.stderr.write(`[autohand:report] Retry failed: ${retryResult.error}, giving up
+`);
+        }
+      }
+    } catch (e2) {
+      if (isDebug()) {
+        process.stderr.write(`[autohand:report] Unexpected error in reportError, giving up
+`);
+      }
+    }
+  }
+}, _class.__initStatic(), _class);
+
+// src/telemetry/TelemetryClient.ts
+
+
+
+var TELEMETRY_DIR = _chunkKASXKDF2cjs.AUTOHAND_PATHS.telemetry;
+var QUEUE_FILE = _chunkKASXKDF2cjs.AUTOHAND_FILES.telemetryQueue;
+var DEVICE_ID_FILE2 = _chunkKASXKDF2cjs.AUTOHAND_FILES.deviceId;
+var TelemetryClient = (_class2 = class {
+  
+  __init2() {this.queue = []}
+  
+  __init3() {this.flushTimer = null}
+  __init4() {this.isFlushing = false}
+  constructor(config = {}) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);
+    this.config = {
+      enabled: false,
+      apiBaseUrl: "https://api.autohand.ai",
+      batchSize: 20,
+      flushIntervalMs: 6e4,
+      // 1 minute
+      maxQueueSize: 500,
+      maxRetries: 3,
+      enableSessionSync: true,
+      companySecret: "",
+      clientType: "cli",
+      clientVersion: void 0,
+      ...config
+    };
+    this.deviceId = this.getOrCreateDeviceId();
+    this.loadQueue();
+    this.startFlushTimer();
+  }
+  /**
+   * Get or create a persistent device ID
+   */
+  getOrCreateDeviceId() {
+    try {
+      _fsextra2.default.ensureDirSync(_path2.default.dirname(DEVICE_ID_FILE2));
+      if (_fsextra2.default.existsSync(DEVICE_ID_FILE2)) {
+        return _fsextra2.default.readFileSync(DEVICE_ID_FILE2, "utf8").trim();
+      }
+      const id = _crypto2.default.randomUUID();
+      _fsextra2.default.writeFileSync(DEVICE_ID_FILE2, id);
+      return id;
+    } catch (e3) {
+      return _crypto2.default.randomUUID();
+    }
+  }
+  /**
+   * Load queued events from disk (for offline support)
+   */
+  loadQueue() {
+    try {
+      _fsextra2.default.ensureDirSync(TELEMETRY_DIR);
+      if (_fsextra2.default.existsSync(QUEUE_FILE)) {
+        const data = _fsextra2.default.readFileSync(QUEUE_FILE, "utf8");
+        this.queue = JSON.parse(data);
+      }
+    } catch (e4) {
+      this.queue = [];
+    }
+  }
+  /**
+   * Persist queue to disk for offline support
+   */
+  saveQueue() {
+    try {
+      _fsextra2.default.ensureDirSync(TELEMETRY_DIR);
+      _fsextra2.default.writeFileSync(QUEUE_FILE, JSON.stringify(this.queue, null, 2));
+    } catch (e5) {
+    }
+  }
+  /**
+   * Start periodic flush timer
+   */
+  startFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+    }
+    this.flushTimer = setInterval(() => {
+      this.flush().catch(() => {
+      });
+    }, this.config.flushIntervalMs);
+  }
+  /**
+   * Stop flush timer
+   */
+  stopFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  /**
+   * Get device ID
+   */
+  getDeviceId() {
+    return this.deviceId;
+  }
+  /**
+   * Check if online
+   */
+  async isOnline() {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 3e3);
+      const response = await fetch(`${this.config.apiBaseUrl}/health`, {
+        method: "GET",
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      return response.ok;
+    } catch (e6) {
+      return false;
+    }
+  }
+  /**
+   * Queue an event for sending
+   */
+  async track(event) {
+    if (!this.config.enabled) return;
+    const fullEvent = {
+      ...event,
+      id: _crypto2.default.randomUUID(),
+      deviceId: this.deviceId,
+      clientType: this.config.clientType,
+      clientVersion: this.config.clientVersion,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.queue.push(fullEvent);
+    if (this.queue.length > this.config.maxQueueSize) {
+      this.queue = this.queue.slice(-this.config.maxQueueSize);
+    }
+    this.saveQueue();
+    if (this.queue.length >= this.config.batchSize) {
+      await this.flush();
+    }
+  }
+  /**
+   * Flush queued events to the server
+   */
+  async flush() {
+    if (!this.config.enabled || this.isFlushing || this.queue.length === 0) {
+      return { sent: 0, failed: 0, queued: this.queue.length };
+    }
+    const online = await this.isOnline();
+    if (!online) {
+      return { sent: 0, failed: 0, queued: this.queue.length };
+    }
+    this.isFlushing = true;
+    try {
+      const eventsToSend = this.queue.slice(0, this.config.batchSize);
+      let sent = 0;
+      let failed = 0;
+      for (let attempt = 0; attempt < this.config.maxRetries; attempt++) {
+        try {
+          const authToken = `${this.deviceId}.${this.config.companySecret}`;
+          const response = await fetch(`${this.config.apiBaseUrl}/v1/telemetry`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${authToken}`,
+              "X-CLI-Version": _optionalChain([eventsToSend, 'access', _11 => _11[0], 'optionalAccess', _12 => _12.cliVersion]) || "unknown"
+            },
+            body: JSON.stringify({ events: eventsToSend })
+          });
+          if (response.ok) {
+            this.queue = this.queue.slice(eventsToSend.length);
+            sent = eventsToSend.length;
+            this.saveQueue();
+            break;
+          } else {
+            failed = eventsToSend.length;
+          }
+        } catch (e7) {
+          failed = eventsToSend.length;
+          await new Promise((resolve) => setTimeout(resolve, 1e3 * (attempt + 1)));
+        }
+      }
+      return { sent, failed, queued: this.queue.length };
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+  /**
+   * Force sync all queued events (called on graceful shutdown)
+   */
+  async syncAll() {
+    if (!this.config.enabled || this.queue.length === 0) {
+      return { sent: 0, failed: 0 };
+    }
+    const online = await this.isOnline();
+    if (!online) {
+      this.saveQueue();
+      return { sent: 0, failed: this.queue.length };
+    }
+    let totalSent = 0;
+    let totalFailed = 0;
+    while (this.queue.length > 0) {
+      const result = await this.flush();
+      totalSent += result.sent;
+      if (result.sent === 0) {
+        totalFailed += result.queued;
+        break;
+      }
+    }
+    return { sent: totalSent, failed: totalFailed };
+  }
+  /**
+   * Upload session data for cloud sync
+   */
+  async uploadSession(sessionData) {
+    if (!this.config.enabled || !this.config.enableSessionSync) {
+      return { success: false, error: "Session sync disabled" };
+    }
+    const online = await this.isOnline();
+    if (!online) {
+      try {
+        const syncQueueFile = _path2.default.join(TELEMETRY_DIR, "session-sync-queue.json");
+        let syncQueue = [];
+        if (_fsextra2.default.existsSync(syncQueueFile)) {
+          syncQueue = JSON.parse(_fsextra2.default.readFileSync(syncQueueFile, "utf8"));
+        }
+        syncQueue.push(sessionData);
+        if (syncQueue.length > 10) {
+          syncQueue = syncQueue.slice(-10);
+        }
+        _fsextra2.default.writeFileSync(syncQueueFile, JSON.stringify(syncQueue, null, 2));
+        return { success: false, error: "Offline - queued for sync" };
+      } catch (e8) {
+        return { success: false, error: "Failed to queue session" };
+      }
+    }
+    try {
+      const authToken = `${this.deviceId}.${this.config.companySecret}`;
+      const response = await fetch(`${this.config.apiBaseUrl}/v1/history`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${authToken}`
+        },
+        body: JSON.stringify({
+          deviceId: this.deviceId,
+          sessionId: sessionData.sessionId,
+          messages: sessionData.messages,
+          metadata: sessionData.metadata
+        })
+      });
+      if (response.ok) {
+        const data = await response.json();
+        return { success: true, id: data.id };
+      } else {
+        return { success: false, error: `HTTP ${response.status}` };
+      }
+    } catch (err) {
+      return { success: false, error: String(err) };
+    }
+  }
+  /**
+   * Sync queued sessions (call when back online)
+   */
+  async syncQueuedSessions() {
+    const syncQueueFile = _path2.default.join(TELEMETRY_DIR, "session-sync-queue.json");
+    if (!_fsextra2.default.existsSync(syncQueueFile)) {
+      return { synced: 0, failed: 0 };
+    }
+    try {
+      const syncQueue = JSON.parse(_fsextra2.default.readFileSync(syncQueueFile, "utf8"));
+      let synced = 0;
+      let failed = 0;
+      const remaining = [];
+      for (const session of syncQueue) {
+        const result = await this.uploadSession(session);
+        if (result.success) {
+          synced++;
+        } else if (result.error !== "Offline - queued for sync") {
+          failed++;
+        } else {
+          remaining.push(session);
+        }
+      }
+      if (remaining.length > 0) {
+        _fsextra2.default.writeFileSync(syncQueueFile, JSON.stringify(remaining, null, 2));
+      } else {
+        _fsextra2.default.removeSync(syncQueueFile);
+      }
+      return { synced, failed };
+    } catch (e9) {
+      return { synced: 0, failed: 0 };
+    }
+  }
+  /**
+   * Get queue stats
+   */
+  getStats() {
+    return {
+      queued: this.queue.length,
+      deviceId: this.deviceId
+    };
+  }
+  /**
+   * Disable telemetry
+   */
+  disable() {
+    this.config.enabled = false;
+    this.stopFlushTimer();
+  }
+  /**
+   * Enable telemetry
+   */
+  enable() {
+    this.config.enabled = true;
+    this.startFlushTimer();
+  }
+}, _class2);
+
+// src/telemetry/TelemetryManager.ts
+
+var TelemetryManager = (_class3 = class {
+  
+  __init5() {this.sessionId = null}
+  __init6() {this.sessionStartTime = null}
+  __init7() {this.heartbeatTimer = null}
+  __init8() {this.interactionCount = 0}
+  __init9() {this.toolsUsed = /* @__PURE__ */ new Set()}
+  __init10() {this.errorsCount = 0}
+  __init11() {this.currentModel = null}
+  __init12() {this.currentProvider = null}
+  
+  
+  constructor(config = {}) {;_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);
+    this.client = new TelemetryClient(config);
+    this.telemetryEnabled = config.enabled === true;
+    this.heartbeatIntervalMs = 6e4;
+  }
+  /**
+   * Get system info for events
+   */
+  getSystemInfo() {
+    return {
+      cliVersion: _chunkAQ5PVHOCcjs.package_default.version,
+      platform: process.platform,
+      osVersion: _os2.default.release(),
+      nodeVersion: process.version,
+      cpuArch: process.arch,
+      cpuCores: _os2.default.cpus().length,
+      memoryTotal: Math.round(_os2.default.totalmem() / 1024 / 1024),
+      // MB
+      memoryFree: Math.round(_os2.default.freemem() / 1024 / 1024)
+      // MB
+    };
+  }
+  /**
+   * Track a generic event
+   */
+  async trackEvent(eventType, eventData) {
+    await this.client.track({
+      eventType,
+      eventData,
+      sessionId: this.sessionId || "unknown",
+      ...this.getSystemInfo(),
+      interactionCount: this.interactionCount,
+      toolsUsed: Array.from(this.toolsUsed),
+      errorsCount: this.errorsCount
+    });
+  }
+  /**
+   * Start a new session
+   */
+  async startSession(sessionId, model, provider, startedAt) {
+    this.sessionId = sessionId;
+    this.sessionStartTime = this.normalizeSessionStartTime(startedAt);
+    this.interactionCount = 0;
+    this.toolsUsed.clear();
+    this.errorsCount = 0;
+    this.currentModel = model || null;
+    this.currentProvider = provider || null;
+    this.startHeartbeatTimer();
+    await this.trackEvent("session_start", {
+      model,
+      provider
+    });
+    await this.client.syncQueuedSessions();
+  }
+  /**
+   * End current session
+   */
+  async endSession(status = "completed") {
+    this.stopHeartbeatTimer();
+    const duration = this.getSessionDurationSeconds();
+    await this.trackEvent("session_end", {
+      status,
+      duration,
+      model: this.currentModel,
+      provider: this.currentProvider
+    });
+    await this.client.syncAll();
+  }
+  /**
+   * Track tool usage
+   */
+  async trackToolUse(data) {
+    this.toolsUsed.add(data.tool);
+    if (!data.success) {
+      this.errorsCount++;
+    }
+    await this.trackEvent("tool_use", {
+      tool: data.tool,
+      success: data.success,
+      duration: data.duration,
+      error: data.error
+    });
+  }
+  /**
+   * Track an error
+   */
+  async trackError(data) {
+    this.errorsCount++;
+    const sanitizedStack = _optionalChain([data, 'access', _13 => _13.stack, 'optionalAccess', _14 => _14.replace, 'call', _15 => _15(/\/Users\/[^/]+/g, "/Users/***"), 'access', _16 => _16.replace, 'call', _17 => _17(/\/home\/[^/]+/g, "/home/***"), 'access', _18 => _18.replace, 'call', _19 => _19(/C:\\Users\\[^\\]+/g, "C:\\Users\\***")]);
+    await this.trackEvent("error", {
+      type: data.type,
+      message: data.message,
+      stack: sanitizedStack,
+      context: data.context
+    });
+  }
+  /**
+   * Track a session failure as a bug report with detailed context.
+   * Prefixes the error type with "BUG:" for easy identification.
+   */
+  async trackSessionFailureBug(data) {
+    this.errorsCount++;
+    const sanitizedStack = _optionalChain([data, 'access', _20 => _20.error, 'access', _21 => _21.stack, 'optionalAccess', _22 => _22.replace, 'call', _23 => _23(/\/Users\/[^/]+/g, "/Users/***"), 'access', _24 => _24.replace, 'call', _25 => _25(/\/home\/[^/]+/g, "/home/***"), 'access', _26 => _26.replace, 'call', _27 => _27(/C:\\Users\\[^\\]+/g, "C:\\Users\\***")]);
+    const bugData = {
+      type: "BUG:session_failure",
+      errorMessage: data.error.message,
+      errorName: data.error.name,
+      stack: sanitizedStack,
+      retryAttempt: data.retryAttempt,
+      maxRetries: data.maxRetries,
+      conversationLength: data.conversationLength,
+      lastToolCalls: data.lastToolCalls,
+      iterationCount: data.iterationCount,
+      contextUsage: data.contextUsage,
+      model: data.model || this.currentModel || void 0,
+      provider: data.provider || this.currentProvider || void 0,
+      isRetrying: data.retryAttempt < data.maxRetries
+    };
+    await this.trackEvent("session_failure_bug", bugData);
+  }
+  /**
+   * Track slash command usage
+   */
+  async trackCommand(data) {
+    this.interactionCount++;
+    await this.trackEvent("command_use", {
+      command: data.command,
+      args: data.args
+    });
+  }
+  /**
+   * Track skill activation/usage
+   */
+  async trackSkillUse(data) {
+    await this.trackEvent("skill_use", {
+      skillName: data.skillName,
+      source: data.source,
+      activationType: data.activationType,
+      action: data.action
+    });
+  }
+  /**
+   * Track model switch
+   */
+  async trackModelSwitch(data) {
+    const previousModel = this.currentModel;
+    this.currentModel = data.toModel;
+    this.currentProvider = data.provider;
+    await this.trackEvent("model_switch", {
+      fromModel: previousModel || data.fromModel,
+      toModel: data.toModel,
+      provider: data.provider
+    });
+  }
+  /**
+   * Track heartbeat (periodic check-in)
+   */
+  async trackHeartbeat() {
+    await this.trackEvent("heartbeat", {
+      uptime: this.getSessionDurationSeconds()
+    });
+  }
+  /**
+   * Record an interaction (user message)
+   */
+  recordInteraction() {
+    this.interactionCount++;
+  }
+  /**
+   * Upload session for cloud sync
+   */
+  async syncSession(data) {
+    if (!this.sessionId) {
+      return { success: false, error: "No active session" };
+    }
+    const endTimeMs = Date.now();
+    const endTime = _nullishCoalesce(_optionalChain([data, 'access', _28 => _28.metadata, 'optionalAccess', _29 => _29.endTime]), () => ( new Date(endTimeMs).toISOString()));
+    const startTime = _nullishCoalesce(_optionalChain([data, 'access', _30 => _30.metadata, 'optionalAccess', _31 => _31.startTime]), () => ( _optionalChain([this, 'access', _32 => _32.sessionStartTime, 'optionalAccess', _33 => _33.toISOString, 'call', _34 => _34()])));
+    const durationSeconds = _nullishCoalesce(_optionalChain([data, 'access', _35 => _35.metadata, 'optionalAccess', _36 => _36.durationSeconds]), () => ( this.getSessionDurationSeconds(endTimeMs)));
+    return this.client.uploadSession({
+      sessionId: this.sessionId,
+      messages: data.messages,
+      metadata: {
+        model: this.currentModel || void 0,
+        provider: this.currentProvider || void 0,
+        totalTokens: _optionalChain([data, 'access', _37 => _37.metadata, 'optionalAccess', _38 => _38.totalTokens]),
+        startTime,
+        endTime,
+        durationSeconds,
+        workspaceRoot: _optionalChain([data, 'access', _39 => _39.metadata, 'optionalAccess', _40 => _40.workspaceRoot])
+      }
+    });
+  }
+  /**
+   * Get current session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Get device ID
+   */
+  getDeviceId() {
+    return this.client.getDeviceId();
+  }
+  /**
+   * Get stats
+   */
+  getStats() {
+    return {
+      ...this.client.getStats(),
+      sessionId: this.sessionId,
+      interactionCount: this.interactionCount,
+      toolsUsed: Array.from(this.toolsUsed),
+      errorsCount: this.errorsCount,
+      sessionDuration: this.getSessionDurationSeconds()
+    };
+  }
+  /**
+   * Flush pending events
+   */
+  async flush() {
+    return this.client.flush();
+  }
+  /**
+   * Disable telemetry
+   */
+  disable() {
+    this.telemetryEnabled = false;
+    this.stopHeartbeatTimer();
+    this.client.disable();
+  }
+  /**
+   * Enable telemetry
+   */
+  enable() {
+    this.telemetryEnabled = true;
+    if (this.sessionId) {
+      this.startHeartbeatTimer();
+    }
+    this.client.enable();
+  }
+  /**
+   * Stop and cleanup
+   */
+  async shutdown() {
+    this.stopHeartbeatTimer();
+    this.client.stopFlushTimer();
+    await this.client.syncAll();
+  }
+  normalizeSessionStartTime(startedAt) {
+    if (startedAt instanceof Date) {
+      return Number.isFinite(startedAt.getTime()) ? startedAt : new Date(Date.now());
+    }
+    if (typeof startedAt === "number" || typeof startedAt === "string") {
+      const parsed = new Date(startedAt);
+      return Number.isFinite(parsed.getTime()) ? parsed : new Date(Date.now());
+    }
+    return new Date(Date.now());
+  }
+  getSessionDurationSeconds(nowMs = Date.now()) {
+    if (!this.sessionStartTime) return 0;
+    return Math.max(0, Math.round((nowMs - this.sessionStartTime.getTime()) / 1e3));
+  }
+  startHeartbeatTimer() {
+    this.stopHeartbeatTimer();
+    if (!this.telemetryEnabled) return;
+    this.heartbeatTimer = setInterval(() => {
+      this.trackHeartbeat().catch(() => {
+      });
+    }, this.heartbeatIntervalMs);
+    _optionalChain([this, 'access', _41 => _41.heartbeatTimer, 'access', _42 => _42.unref, 'optionalCall', _43 => _43()]);
+  }
+  stopHeartbeatTimer() {
+    if (!this.heartbeatTimer) return;
+    clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = null;
+  }
+}, _class3);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.isAutohandDebugEnabled = isAutohandDebugEnabled; exports.writeAutohandDebugLine = writeAutohandDebugLine; exports.AutoReportManager = AutoReportManager; exports.TelemetryManager = TelemetryManager; exports.isSessionWorktreeEnabled = isSessionWorktreeEnabled; exports.prepareSessionWorktree = prepareSessionWorktree; exports.formatStartupBanner = formatStartupBanner; exports.formatWelcomeVersionPrefix = formatWelcomeVersionPrefix; exports.formatUpdateAvailable = formatUpdateAvailable; exports.formatUpdateReady = formatUpdateReady; exports.formatInstallHint = formatInstallHint; exports.formatWelcomeGreeting = formatWelcomeGreeting; exports.formatWelcomeStatusLine = formatWelcomeStatusLine; exports.formatWelcomeTitle = formatWelcomeTitle; exports.formatWelcomeSuggestion = formatWelcomeSuggestion; exports.formatSessionEnding = formatSessionEnding; exports.formatSessionSaved = formatSessionSaved; exports.formatResumeHint = formatResumeHint; exports.formatExitCleanup = formatExitCleanup; exports.formatForceExit = formatForceExit;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * AutoReportClient - Low-level HTTP client for error reporting
+ * Sends sanitized error reports to the Autohand API for automatic GitHub issue creation
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * AutoReportManager - High-level manager for automatic error reporting
+ * Handles deduplication, retries, and config-based enable/disable
+ */
+/**
+ * TelemetryClient - Low-level API client with offline batching
+ * @license Apache-2.0
+ */
+/**
+ * TelemetryManager - High-level telemetry tracking
+ * @license Apache-2.0
+ */