autohand-cli 0.9.0 → 0.9.2

package/dist/{chunk-JIMSII7R.js → chunk-WH6YUQDB.js}

@@ -1,16 +1,37 @@
-import {
-  package_default
-} from "./chunk-3PXKRVCW.js";
 import {
   ApiError
 } from "./chunk-FQVG6ZHF.js";
+import {
+  looksLikeInlineAgents
+} from "./chunk-TJFKA6A7.js";
+import {
+  package_default
+} from "./chunk-NOWCRKP2.js";
 import {
   themedFg
 } from "./chunk-JAQO6XDB.js";
 import {
   AUTOHAND_FILES,
   AUTOHAND_PATHS
-} from "./chunk-TWQDAUZU.js";
+} from "./chunk-PG2JIU5M.js";
+
+// 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/utils/sessionWorktree.ts
 import { spawnSync } from "child_process";
@@ -87,6 +108,74 @@ function prepareSessionWorktree(input) {
   };
 }
 
+// src/runtime/bareMode.ts
+import fs from "fs-extra";
+import path2 from "path";
+var BARE_SLASH_COMMANDS_DISABLED_MESSAGE = "Slash commands are disabled in bare mode.";
+function applyBareModeConfig(config, options) {
+  const bareConfig = {
+    ...config,
+    ui: {
+      ...config.ui,
+      promptSuggestions: false,
+      checkForUpdates: false,
+      notifications: false
+    },
+    telemetry: {
+      ...config.telemetry,
+      enabled: false,
+      enableSessionSync: false
+    },
+    autoReport: {
+      ...config.autoReport,
+      enabled: false
+    },
+    communitySkills: {
+      ...config.communitySkills,
+      enabled: false,
+      showSuggestionsOnStartup: false,
+      autoBackup: false
+    },
+    hooks: {
+      ...config.hooks,
+      enabled: false,
+      hooks: []
+    },
+    mcp: options.mcpConfig ? config.mcp : {
+      ...config.mcp,
+      enabled: false,
+      servers: []
+    },
+    sync: {
+      ...config.sync,
+      enabled: false
+    },
+    externalAgents: options.agents && !looksLikeInlineAgents(options.agents) ? { enabled: true, paths: [path2.resolve(options.agents)] } : { enabled: false, paths: [] }
+  };
+  if (options.pluginDir) {
+    bareConfig.pluginDir = path2.resolve(options.pluginDir);
+  }
+  return bareConfig;
+}
+async function applyExplicitBareFiles(config, options) {
+  if (!options.mcpConfig) {
+    return config;
+  }
+  const mcpConfigPath = path2.resolve(options.mcpConfig);
+  const mcpConfig = await fs.readJson(mcpConfigPath);
+  return {
+    ...config,
+    mcp: Array.isArray(mcpConfig?.servers) ? { enabled: true, servers: mcpConfig.servers } : mcpConfig
+  };
+}
+async function prepareBareModeConfig(config, options) {
+  if (!options.bare) {
+    return config;
+  }
+  process.env.AUTOHAND_CODE_SIMPLE = "1";
+  return applyExplicitBareFiles(applyBareModeConfig(config, options), options);
+}
+
 // src/ui/theme/startup.ts
 import chalk from "chalk";
 function formatStartupBanner(logo) {
@@ -139,30 +228,12 @@ 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 fs2 from "fs-extra";
 import os from "os";
 var DEVICE_ID_FILE = AUTOHAND_FILES.deviceId;
 var AutoReportClient = class {
@@ -175,8 +246,8 @@ var AutoReportClient = class {
    */
   getDeviceId() {
     try {
-      if (fs.existsSync(DEVICE_ID_FILE)) {
-        return fs.readFileSync(DEVICE_ID_FILE, "utf8").trim();
+      if (fs2.existsSync(DEVICE_ID_FILE)) {
+        return fs2.readFileSync(DEVICE_ID_FILE, "utf8").trim();
       }
     } catch {
     }
@@ -367,8 +438,8 @@ var AutoReportManager = class _AutoReportManager {
 };
 
 // src/telemetry/TelemetryClient.ts
-import fs2 from "fs-extra";
-import path2 from "path";
+import fs3 from "fs-extra";
+import path3 from "path";
 import crypto4 from "crypto";
 var TELEMETRY_DIR = AUTOHAND_PATHS.telemetry;
 var QUEUE_FILE = AUTOHAND_FILES.telemetryQueue;
@@ -388,7 +459,7 @@ var TelemetryClient = class {
       // 1 minute
       maxQueueSize: 500,
       maxRetries: 3,
-      enableSessionSync: false,
+      enableSessionSync: true,
       companySecret: "",
       clientType: "cli",
       clientVersion: void 0,
@@ -403,12 +474,12 @@ var TelemetryClient = class {
    */
   getOrCreateDeviceId() {
     try {
-      fs2.ensureDirSync(path2.dirname(DEVICE_ID_FILE2));
-      if (fs2.existsSync(DEVICE_ID_FILE2)) {
-        return fs2.readFileSync(DEVICE_ID_FILE2, "utf8").trim();
+      fs3.ensureDirSync(path3.dirname(DEVICE_ID_FILE2));
+      if (fs3.existsSync(DEVICE_ID_FILE2)) {
+        return fs3.readFileSync(DEVICE_ID_FILE2, "utf8").trim();
       }
       const id = crypto4.randomUUID();
-      fs2.writeFileSync(DEVICE_ID_FILE2, id);
+      fs3.writeFileSync(DEVICE_ID_FILE2, id);
       return id;
     } catch {
       return crypto4.randomUUID();
@@ -419,9 +490,9 @@ var TelemetryClient = class {
    */
   loadQueue() {
     try {
-      fs2.ensureDirSync(TELEMETRY_DIR);
-      if (fs2.existsSync(QUEUE_FILE)) {
-        const data = fs2.readFileSync(QUEUE_FILE, "utf8");
+      fs3.ensureDirSync(TELEMETRY_DIR);
+      if (fs3.existsSync(QUEUE_FILE)) {
+        const data = fs3.readFileSync(QUEUE_FILE, "utf8");
         this.queue = JSON.parse(data);
       }
     } catch {
@@ -433,8 +504,8 @@ var TelemetryClient = class {
    */
   saveQueue() {
     try {
-      fs2.ensureDirSync(TELEMETRY_DIR);
-      fs2.writeFileSync(QUEUE_FILE, JSON.stringify(this.queue, null, 2));
+      fs3.ensureDirSync(TELEMETRY_DIR);
+      fs3.writeFileSync(QUEUE_FILE, JSON.stringify(this.queue, null, 2));
     } catch {
     }
   }
@@ -578,34 +649,37 @@ var TelemetryClient = class {
    * Upload session data for cloud sync
    */
   async uploadSession(sessionData) {
-    if (!this.config.enabled || !this.config.enableSessionSync) {
+    if (!this.config.enableSessionSync) {
       return { success: false, error: "Session sync disabled" };
     }
+    if (!this.config.authToken) {
+      return { success: false, error: "Login required for session sync" };
+    }
     const online = await this.isOnline();
     if (!online) {
       try {
-        const syncQueueFile = path2.join(TELEMETRY_DIR, "session-sync-queue.json");
+        const syncQueueFile = path3.join(TELEMETRY_DIR, "session-sync-queue.json");
         let syncQueue = [];
-        if (fs2.existsSync(syncQueueFile)) {
-          syncQueue = JSON.parse(fs2.readFileSync(syncQueueFile, "utf8"));
+        if (fs3.existsSync(syncQueueFile)) {
+          syncQueue = JSON.parse(fs3.readFileSync(syncQueueFile, "utf8"));
         }
         syncQueue.push(sessionData);
         if (syncQueue.length > 10) {
           syncQueue = syncQueue.slice(-10);
         }
-        fs2.writeFileSync(syncQueueFile, JSON.stringify(syncQueue, null, 2));
+        fs3.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}`
+          "Authorization": `Bearer ${this.config.authToken}`,
+          "X-CLI-Version": this.config.clientVersion || "unknown"
         },
         body: JSON.stringify({
           deviceId: this.deviceId,
@@ -628,12 +702,12 @@ var TelemetryClient = class {
    * Sync queued sessions (call when back online)
    */
   async syncQueuedSessions() {
-    const syncQueueFile = path2.join(TELEMETRY_DIR, "session-sync-queue.json");
-    if (!fs2.existsSync(syncQueueFile)) {
+    const syncQueueFile = path3.join(TELEMETRY_DIR, "session-sync-queue.json");
+    if (!fs3.existsSync(syncQueueFile)) {
       return { synced: 0, failed: 0 };
     }
     try {
-      const syncQueue = JSON.parse(fs2.readFileSync(syncQueueFile, "utf8"));
+      const syncQueue = JSON.parse(fs3.readFileSync(syncQueueFile, "utf8"));
       let synced = 0;
       let failed = 0;
       const remaining = [];
@@ -648,9 +722,9 @@ var TelemetryClient = class {
         }
       }
       if (remaining.length > 0) {
-        fs2.writeFileSync(syncQueueFile, JSON.stringify(remaining, null, 2));
+        fs3.writeFileSync(syncQueueFile, JSON.stringify(remaining, null, 2));
       } else {
-        fs2.removeSync(syncQueueFile);
+        fs3.removeSync(syncQueueFile);
       }
       return { synced, failed };
     } catch {
@@ -688,13 +762,19 @@ var TelemetryManager = class {
   client;
   sessionId = null;
   sessionStartTime = null;
+  heartbeatTimer = null;
   interactionCount = 0;
   toolsUsed = /* @__PURE__ */ new Set();
   errorsCount = 0;
   currentModel = null;
   currentProvider = null;
+  currentProviderMetadata = {};
+  telemetryEnabled;
+  heartbeatIntervalMs;
   constructor(config = {}) {
     this.client = new TelemetryClient(config);
+    this.telemetryEnabled = config.enabled === true;
+    this.heartbeatIntervalMs = 6e4;
   }
   /**
    * Get system info for events
@@ -730,17 +810,20 @@ var TelemetryManager = class {
   /**
    * Start a new session
    */
-  async startSession(sessionId, model, provider) {
+  async startSession(sessionId, model, provider, startedAt, providerMetadata = {}) {
     this.sessionId = sessionId;
-    this.sessionStartTime = /* @__PURE__ */ new Date();
+    this.sessionStartTime = this.normalizeSessionStartTime(startedAt);
     this.interactionCount = 0;
     this.toolsUsed.clear();
     this.errorsCount = 0;
     this.currentModel = model || null;
     this.currentProvider = provider || null;
+    this.currentProviderMetadata = providerMetadata;
+    this.startHeartbeatTimer();
     await this.trackEvent("session_start", {
       model,
-      provider
+      provider,
+      ...providerMetadata
     });
     await this.client.syncQueuedSessions();
   }
@@ -748,12 +831,14 @@ var TelemetryManager = class {
    * End current session
    */
   async endSession(status = "completed") {
-    const duration = this.sessionStartTime ? Math.round((Date.now() - this.sessionStartTime.getTime()) / 1e3) : 0;
+    this.stopHeartbeatTimer();
+    const duration = this.getSessionDurationSeconds();
     await this.trackEvent("session_end", {
       status,
       duration,
       model: this.currentModel,
-      provider: this.currentProvider
+      provider: this.currentProvider,
+      ...this.currentProviderMetadata
     });
     await this.client.syncAll();
   }
@@ -837,10 +922,17 @@ var TelemetryManager = class {
     const previousModel = this.currentModel;
     this.currentModel = data.toModel;
     this.currentProvider = data.provider;
+    this.currentProviderMetadata = {
+      providerDisplayName: data.providerDisplayName,
+      providerApiFormat: data.providerApiFormat,
+      reasoningEffort: data.reasoningEffort,
+      contextWindow: data.contextWindow
+    };
     await this.trackEvent("model_switch", {
       fromModel: previousModel || data.fromModel,
       toModel: data.toModel,
-      provider: data.provider
+      provider: data.provider,
+      ...this.currentProviderMetadata
     });
   }
   /**
@@ -848,7 +940,7 @@ var TelemetryManager = class {
    */
   async trackHeartbeat() {
     await this.trackEvent("heartbeat", {
-      uptime: this.sessionStartTime ? Math.round((Date.now() - this.sessionStartTime.getTime()) / 1e3) : 0
+      uptime: this.getSessionDurationSeconds()
     });
   }
   /**
@@ -864,15 +956,20 @@ var TelemetryManager = class {
     if (!this.sessionId) {
       return { success: false, error: "No active session" };
     }
+    const endTimeMs = Date.now();
+    const startTime = data.metadata?.startTime ?? this.sessionStartTime?.toISOString();
+    const durationSeconds = data.metadata?.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,
+        ...this.currentProviderMetadata,
         totalTokens: data.metadata?.totalTokens,
-        startTime: this.sessionStartTime?.toISOString(),
-        endTime: (/* @__PURE__ */ new Date()).toISOString(),
+        startTime,
+        ...data.metadata?.endTime ? { endTime: data.metadata.endTime } : {},
+        durationSeconds,
         workspaceRoot: data.metadata?.workspaceRoot
       }
     });
@@ -899,7 +996,7 @@ var TelemetryManager = class {
       interactionCount: this.interactionCount,
       toolsUsed: Array.from(this.toolsUsed),
       errorsCount: this.errorsCount,
-      sessionDuration: this.sessionStartTime ? Math.round((Date.now() - this.sessionStartTime.getTime()) / 1e3) : 0
+      sessionDuration: this.getSessionDurationSeconds()
     };
   }
   /**
@@ -912,21 +1009,56 @@ var TelemetryManager = class {
    * 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);
+    this.heartbeatTimer.unref?.();
+  }
+  stopHeartbeatTimer() {
+    if (!this.heartbeatTimer) return;
+    clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = null;
+  }
 };
 
 export {
@@ -936,6 +1068,8 @@ export {
   TelemetryManager,
   isSessionWorktreeEnabled,
   prepareSessionWorktree,
+  BARE_SLASH_COMMANDS_DISABLED_MESSAGE,
+  prepareBareModeConfig,
   formatStartupBanner,
   formatWelcomeVersionPrefix,
   formatUpdateAvailable,

package/dist/{chunk-VKBIE6I6.js → chunk-WQ6TD55V.js}

@@ -5,10 +5,10 @@ import {
 import {
   showModal,
   showPassword
-} from "./chunk-DLP436GI.js";
+} from "./chunk-LOSXLH7P.js";
 import {
   saveConfig
-} from "./chunk-3UT7R3XV.js";
+} from "./chunk-CM24K6ZT.js";
 
 // src/commands/search.ts
 import chalk from "chalk";

package/dist/{chunk-ZR46OJNZ.js → chunk-WQWECXTY.js}

@@ -6,13 +6,13 @@ import {
   getManifestTarget,
   hasActiveHandoff,
   openChromeContinuation
-} from "./chunk-ARBEHFCG.js";
+} from "./chunk-S7KVUIOS.js";
 import {
   showModal
-} from "./chunk-DLP436GI.js";
+} from "./chunk-LOSXLH7P.js";
 import {
   saveConfig
-} from "./chunk-3UT7R3XV.js";
+} from "./chunk-CM24K6ZT.js";
 
 // src/commands/chrome.ts
 import chalk from "chalk";

package/dist/{chunk-SOLBYSLY.cjs → chunk-WVDJUJH6.cjs}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkOPNI6O7Fcjs = require('./chunk-OPNI6O7F.cjs');
+var _chunkTZB5XADLcjs = require('./chunk-TZB5XADL.cjs');
 
 // src/skills/learnPrompts.ts
 function buildLearnSystemPrompt() {
@@ -139,7 +139,7 @@ Return ONLY the JSON object, no other text.`;
 }
 function buildLearnGenerationUserPrompt(analysis, gapAnalysis, lowScoringSkills) {
   const parts = [];
-  parts.push(_chunkOPNI6O7Fcjs.buildSkillGenerationPrompt.call(void 0, analysis));
+  parts.push(_chunkTZB5XADLcjs.buildSkillGenerationPrompt.call(void 0, analysis));
   parts.push("");
   parts.push("## Context");
   parts.push("No existing community skills matched well for this project.");