autohand-cli 0.8.2 → 0.9.0

package/dist/chunk-JIMSII7R.js

@@ -0,0 +1,987 @@
+import {
+  package_default
+} from "./chunk-3PXKRVCW.js";
+import {
+  ApiError
+} from "./chunk-FQVG6ZHF.js";
+import {
+  themedFg
+} from "./chunk-JAQO6XDB.js";
+import {
+  AUTOHAND_FILES,
+  AUTOHAND_PATHS
+} from "./chunk-TWQDAUZU.js";
+
+// src/utils/sessionWorktree.ts
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import path from "path";
+import crypto from "crypto";
+function runGit(cwd, args) {
+  const result = spawnSync("git", args, {
+    cwd,
+    encoding: "utf8"
+  });
+  return {
+    stdout: result.stdout ?? "",
+    stderr: 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 = crypto.randomBytes(3).toString("hex");
+  return sanitizeName(`autohand-${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 (!existsSync(basePath)) {
+    return basePath;
+  }
+  for (let i = 2; i < 1e3; i++) {
+    const candidate = `${basePath}-${i}`;
+    if (!existsSync(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 = path.basename(repoRoot);
+  const parentDir = path.dirname(repoRoot);
+  const basePath = path.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
+import chalk from "chalk";
+function formatStartupBanner(logo) {
+  return logo.split("\n").map((line, index) => themedFg(index % 2 === 0 ? "accent" : "borderAccent", line, chalk.cyan)).join("\n");
+}
+function formatWelcomeVersionPrefix(version) {
+  return `${themedFg("accent", "> Autohand", chalk.bold)} ${themedFg("muted", `v${version}`, chalk.gray)}`;
+}
+function formatUpdateAvailable(version) {
+  return themedFg("warning", ` \u2B06 Update available: v${version}`, chalk.yellow);
+}
+function formatUpdateReady() {
+  return themedFg("success", " \u2713 Up to date", chalk.green);
+}
+function formatInstallHint(hint) {
+  return `${themedFg("muted", "  \u21B3 Run: ", chalk.gray)}${themedFg("accent", hint, chalk.cyan)}`;
+}
+function formatWelcomeGreeting(nameOrEmail) {
+  return themedFg("success", `Welcome back, ${nameOrEmail}!`, chalk.green);
+}
+function formatWelcomeStatusLine(model, ccEnabled, dir) {
+  const ccStatus = ccEnabled ? themedFg("success", "[CC: ON]", chalk.green) : themedFg("warning", "[CC: OFF]", chalk.yellow);
+  return [
+    themedFg("muted", "model:", chalk.gray),
+    themedFg("accent", model, chalk.cyan),
+    ccStatus,
+    themedFg("muted", "| directory:", chalk.gray),
+    themedFg("accent", dir, chalk.cyan)
+  ].join("  ");
+}
+function formatWelcomeTitle() {
+  return themedFg("muted", "To get started, describe a task or try one of these commands:", chalk.gray);
+}
+function formatWelcomeSuggestion(command, description) {
+  return themedFg("accent", `${command} `, chalk.cyan) + themedFg("muted", description, chalk.gray);
+}
+function formatSessionEnding() {
+  return themedFg("muted", "Ending Autohand session.", chalk.gray);
+}
+function formatSessionSaved(sessionId) {
+  return themedFg("accent", `\u{1F4BE} Session saved: ${sessionId}`, chalk.cyan);
+}
+function formatResumeHint(sessionId) {
+  return themedFg("muted", `   Resume with: autohand resume ${sessionId}`, chalk.gray);
+}
+function formatExitCleanup() {
+  return themedFg("muted", "\nExiting - clearing queues and stopping...", chalk.gray);
+}
+function formatForceExit() {
+  return themedFg("muted", "\nForce exiting...", chalk.gray);
+}
+
+// src/utils/debugLog.ts
+function isAutohandDebugEnabled(env = process.env) {
+  const value = env.AUTOHAND_DEBUG?.trim().toLowerCase();
+  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
+import crypto3 from "crypto";
+
+// src/reporting/AutoReportClient.ts
+import crypto2 from "crypto";
+import fs from "fs-extra";
+import os from "os";
+var DEVICE_ID_FILE = AUTOHAND_FILES.deviceId;
+var AutoReportClient = class {
+  apiBaseUrl;
+  constructor(apiBaseUrl = "https://api.autohand.ai") {
+    this.apiBaseUrl = apiBaseUrl;
+  }
+  /**
+   * Read device ID from ~/.autohand/device-id (shared with telemetry)
+   */
+  getDeviceId() {
+    try {
+      if (fs.existsSync(DEVICE_ID_FILE)) {
+        return fs.readFileSync(DEVICE_ID_FILE, "utf8").trim();
+      }
+    } catch {
+    }
+    return `anon-${crypto2.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 = os.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: package_default.version,
+        platform: process.platform,
+        osVersion: os.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": 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 _AutoReportManager {
+  client;
+  reportedHashes = /* @__PURE__ */ new Set();
+  enabled;
+  constructor(config, _cliVersion) {
+    const apiBaseUrl = config.api?.baseUrl || "https://api.autohand.ai";
+    this.client = new AutoReportClient(apiBaseUrl);
+    this.enabled = config.autoReport?.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 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 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 crypto3.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: context?.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=${result.issueNumber ?? "n/a"} dedup=${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=${retryResult.issueNumber ?? "n/a"}
+`);
+        } else {
+          process.stderr.write(`[autohand:report] Retry failed: ${retryResult.error}, giving up
+`);
+        }
+      }
+    } catch {
+      if (isDebug()) {
+        process.stderr.write(`[autohand:report] Unexpected error in reportError, giving up
+`);
+      }
+    }
+  }
+};
+
+// src/telemetry/TelemetryClient.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+import crypto4 from "crypto";
+var TELEMETRY_DIR = AUTOHAND_PATHS.telemetry;
+var QUEUE_FILE = AUTOHAND_FILES.telemetryQueue;
+var DEVICE_ID_FILE2 = AUTOHAND_FILES.deviceId;
+var TelemetryClient = class {
+  config;
+  queue = [];
+  deviceId;
+  flushTimer = null;
+  isFlushing = false;
+  constructor(config = {}) {
+    this.config = {
+      enabled: false,
+      apiBaseUrl: "https://api.autohand.ai",
+      batchSize: 20,
+      flushIntervalMs: 6e4,
+      // 1 minute
+      maxQueueSize: 500,
+      maxRetries: 3,
+      enableSessionSync: false,
+      companySecret: "",
+      clientType: "cli",
+      clientVersion: void 0,
+      ...config
+    };
+    this.deviceId = this.getOrCreateDeviceId();
+    this.loadQueue();
+    this.startFlushTimer();
+  }
+  /**
+   * Get or create a persistent device ID
+   */
+  getOrCreateDeviceId() {
+    try {
+      fs2.ensureDirSync(path2.dirname(DEVICE_ID_FILE2));
+      if (fs2.existsSync(DEVICE_ID_FILE2)) {
+        return fs2.readFileSync(DEVICE_ID_FILE2, "utf8").trim();
+      }
+      const id = crypto4.randomUUID();
+      fs2.writeFileSync(DEVICE_ID_FILE2, id);
+      return id;
+    } catch {
+      return crypto4.randomUUID();
+    }
+  }
+  /**
+   * Load queued events from disk (for offline support)
+   */
+  loadQueue() {
+    try {
+      fs2.ensureDirSync(TELEMETRY_DIR);
+      if (fs2.existsSync(QUEUE_FILE)) {
+        const data = fs2.readFileSync(QUEUE_FILE, "utf8");
+        this.queue = JSON.parse(data);
+      }
+    } catch {
+      this.queue = [];
+    }
+  }
+  /**
+   * Persist queue to disk for offline support
+   */
+  saveQueue() {
+    try {
+      fs2.ensureDirSync(TELEMETRY_DIR);
+      fs2.writeFileSync(QUEUE_FILE, JSON.stringify(this.queue, null, 2));
+    } catch {
+    }
+  }
+  /**
+   * 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 {
+      return false;
+    }
+  }
+  /**
+   * Queue an event for sending
+   */
+  async track(event) {
+    if (!this.config.enabled) return;
+    const fullEvent = {
+      ...event,
+      id: crypto4.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": eventsToSend[0]?.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 {
+          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.join(TELEMETRY_DIR, "session-sync-queue.json");
+        let syncQueue = [];
+        if (fs2.existsSync(syncQueueFile)) {
+          syncQueue = JSON.parse(fs2.readFileSync(syncQueueFile, "utf8"));
+        }
+        syncQueue.push(sessionData);
+        if (syncQueue.length > 10) {
+          syncQueue = syncQueue.slice(-10);
+        }
+        fs2.writeFileSync(syncQueueFile, JSON.stringify(syncQueue, null, 2));
+        return { success: false, error: "Offline - queued for sync" };
+      } catch {
+        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.join(TELEMETRY_DIR, "session-sync-queue.json");
+    if (!fs2.existsSync(syncQueueFile)) {
+      return { synced: 0, failed: 0 };
+    }
+    try {
+      const syncQueue = JSON.parse(fs2.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) {
+        fs2.writeFileSync(syncQueueFile, JSON.stringify(remaining, null, 2));
+      } else {
+        fs2.removeSync(syncQueueFile);
+      }
+      return { synced, failed };
+    } catch {
+      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();
+  }
+};
+
+// src/telemetry/TelemetryManager.ts
+import os2 from "os";
+var TelemetryManager = class {
+  client;
+  sessionId = null;
+  sessionStartTime = null;
+  interactionCount = 0;
+  toolsUsed = /* @__PURE__ */ new Set();
+  errorsCount = 0;
+  currentModel = null;
+  currentProvider = null;
+  constructor(config = {}) {
+    this.client = new TelemetryClient(config);
+  }
+  /**
+   * Get system info for events
+   */
+  getSystemInfo() {
+    return {
+      cliVersion: package_default.version,
+      platform: process.platform,
+      osVersion: os2.release(),
+      nodeVersion: process.version,
+      cpuArch: process.arch,
+      cpuCores: os2.cpus().length,
+      memoryTotal: Math.round(os2.totalmem() / 1024 / 1024),
+      // MB
+      memoryFree: Math.round(os2.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) {
+    this.sessionId = sessionId;
+    this.sessionStartTime = /* @__PURE__ */ new Date();
+    this.interactionCount = 0;
+    this.toolsUsed.clear();
+    this.errorsCount = 0;
+    this.currentModel = model || null;
+    this.currentProvider = provider || null;
+    await this.trackEvent("session_start", {
+      model,
+      provider
+    });
+    await this.client.syncQueuedSessions();
+  }
+  /**
+   * End current session
+   */
+  async endSession(status = "completed") {
+    const duration = this.sessionStartTime ? Math.round((Date.now() - this.sessionStartTime.getTime()) / 1e3) : 0;
+    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 = data.stack?.replace(/\/Users\/[^/]+/g, "/Users/***").replace(/\/home\/[^/]+/g, "/home/***").replace(/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 = data.error.stack?.replace(/\/Users\/[^/]+/g, "/Users/***").replace(/\/home\/[^/]+/g, "/home/***").replace(/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.sessionStartTime ? Math.round((Date.now() - this.sessionStartTime.getTime()) / 1e3) : 0
+    });
+  }
+  /**
+   * 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" };
+    }
+    return this.client.uploadSession({
+      sessionId: this.sessionId,
+      messages: data.messages,
+      metadata: {
+        model: this.currentModel || void 0,
+        provider: this.currentProvider || void 0,
+        totalTokens: data.metadata?.totalTokens,
+        startTime: this.sessionStartTime?.toISOString(),
+        endTime: (/* @__PURE__ */ new Date()).toISOString(),
+        workspaceRoot: data.metadata?.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.sessionStartTime ? Math.round((Date.now() - this.sessionStartTime.getTime()) / 1e3) : 0
+    };
+  }
+  /**
+   * Flush pending events
+   */
+  async flush() {
+    return this.client.flush();
+  }
+  /**
+   * Disable telemetry
+   */
+  disable() {
+    this.client.disable();
+  }
+  /**
+   * Enable telemetry
+   */
+  enable() {
+    this.client.enable();
+  }
+  /**
+   * Stop and cleanup
+   */
+  async shutdown() {
+    this.client.stopFlushTimer();
+    await this.client.syncAll();
+  }
+};
+
+export {
+  isAutohandDebugEnabled,
+  writeAutohandDebugLine,
+  AutoReportManager,
+  TelemetryManager,
+  isSessionWorktreeEnabled,
+  prepareSessionWorktree,
+  formatStartupBanner,
+  formatWelcomeVersionPrefix,
+  formatUpdateAvailable,
+  formatUpdateReady,
+  formatInstallHint,
+  formatWelcomeGreeting,
+  formatWelcomeStatusLine,
+  formatWelcomeTitle,
+  formatWelcomeSuggestion,
+  formatSessionEnding,
+  formatSessionSaved,
+  formatResumeHint,
+  formatExitCleanup,
+  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
+ */