autohand-cli 0.7.4 → 0.7.6

package/dist/chunk-K6NBYSME.cjs

@@ -0,0 +1,613 @@
+"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 _chunkJYTXG6OVcjs = require('./chunk-JYTXG6OV.cjs');
+
+
+var _chunkXTHHDIBGcjs = require('./chunk-XTHHDIBG.cjs');
+
+// src/commands/share.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var _enquirer = require('enquirer'); var _enquirer2 = _interopRequireDefault(_enquirer);
+var _ora = require('ora'); var _ora2 = _interopRequireDefault(_ora);
+
+// src/share/costEstimator.ts
+var DEFAULT_COST_PER_1K_TOKENS = 3e-3;
+function estimateCost(totalTokens) {
+  if (totalTokens <= 0) return 0;
+  const cost = totalTokens / 1e3 * DEFAULT_COST_PER_1K_TOKENS;
+  return Math.round(cost * 1e4) / 1e4;
+}
+function formatCost(cost) {
+  if (cost < 0.01) {
+    if (cost === 0) return "$0.00";
+    return `$${cost.toFixed(4)}`;
+  }
+  return `$${cost.toFixed(2)}`;
+}
+function formatTokens(tokens) {
+  if (tokens >= 1e6) {
+    return `${(tokens / 1e6).toFixed(1)}M`;
+  }
+  if (tokens >= 1e3) {
+    return `${(tokens / 1e3).toFixed(1)}K`;
+  }
+  return tokens.toString();
+}
+function formatDuration(seconds) {
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes < 60) {
+    if (remainingSeconds === 0) return `${minutes}m`;
+    return `${minutes}m ${remainingSeconds}s`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  if (remainingMinutes === 0) return `${hours}h`;
+  return `${hours}h ${remainingMinutes}m`;
+}
+
+// src/share/sessionSerializer.ts
+function extractToolUsage(messages) {
+  const toolCounts = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (message.role === "assistant" && message.toolCalls) {
+      for (const toolCall of message.toolCalls) {
+        const toolName = _optionalChain([toolCall, 'access', _ => _.function, 'optionalAccess', _2 => _2.name]) || toolCall.name || "unknown";
+        const current = toolCounts.get(toolName) || { total: 0, success: 0 };
+        current.total++;
+        toolCounts.set(toolName, current);
+      }
+    }
+    if (message.role === "tool" && message.name) {
+      const current = toolCounts.get(message.name);
+      if (current) {
+        const isError = message.content.toLowerCase().includes("error") || message.content.toLowerCase().includes("failed");
+        if (!isError) {
+          current.success++;
+        }
+      }
+    }
+  }
+  const result = [];
+  for (const [name, counts] of toolCounts) {
+    result.push({
+      name,
+      count: counts.total,
+      successRate: counts.total > 0 ? counts.success / counts.total : void 0
+    });
+  }
+  return result.sort((a, b) => b.count - a.count);
+}
+function estimateTokensFromMessages(messages) {
+  let input = 0;
+  let output = 0;
+  for (const message of messages) {
+    const chars = message.content.length;
+    const tokens = Math.ceil(chars / 4);
+    if (message.role === "user" || message.role === "system") {
+      input += tokens;
+    } else {
+      output += tokens;
+    }
+  }
+  return {
+    total: input + output,
+    input,
+    output
+  };
+}
+function parseGitDiff(diffContent) {
+  if (!diffContent || diffContent.trim().length === 0) {
+    return void 0;
+  }
+  const lines = diffContent.split("\n");
+  const filesChanged = /* @__PURE__ */ new Set();
+  let linesAdded = 0;
+  let linesRemoved = 0;
+  for (const line of lines) {
+    if (line.startsWith("diff --git")) {
+      const match = line.match(/diff --git a\/(.+) b\/(.+)/);
+      if (match) {
+        filesChanged.add(match[2]);
+      }
+    } else if (line.startsWith("+") && !line.startsWith("+++")) {
+      linesAdded++;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      linesRemoved++;
+    }
+  }
+  if (filesChanged.size === 0 && linesAdded === 0 && linesRemoved === 0) {
+    return void 0;
+  }
+  return {
+    filesChanged: Array.from(filesChanged),
+    linesAdded,
+    linesRemoved,
+    diffContent
+  };
+}
+function calculateDuration(startedAt, endedAt) {
+  const start = new Date(startedAt).getTime();
+  const end = new Date(endedAt).getTime();
+  return Math.max(0, Math.floor((end - start) / 1e3));
+}
+function serializeSession(session, options) {
+  const messages = session.getMessages();
+  const { metadata: metadata2 } = session;
+  const endedAt = metadata2.closedAt || (/* @__PURE__ */ new Date()).toISOString();
+  const durationSeconds = calculateDuration(metadata2.createdAt, endedAt);
+  const sessionMetadata = {
+    sessionId: metadata2.sessionId,
+    projectName: metadata2.projectName,
+    model: options.model || metadata2.model,
+    provider: options.provider || "openrouter",
+    startedAt: metadata2.createdAt,
+    endedAt,
+    durationSeconds,
+    messageCount: messages.length,
+    status: metadata2.status,
+    summary: metadata2.summary
+  };
+  let usage;
+  if (options.totalTokens && options.totalTokens > 0) {
+    const inputTokens = Math.floor(options.totalTokens * 0.3);
+    const outputTokens = options.totalTokens - inputTokens;
+    usage = {
+      totalTokens: options.totalTokens,
+      inputTokens,
+      outputTokens,
+      estimatedCost: estimateCost(options.totalTokens)
+    };
+  } else {
+    const estimated = estimateTokensFromMessages(messages);
+    usage = {
+      totalTokens: estimated.total,
+      inputTokens: estimated.input,
+      outputTokens: estimated.output,
+      estimatedCost: estimateCost(estimated.total)
+    };
+  }
+  const toolUsage = extractToolUsage(messages);
+  const gitDiff = options.gitDiff ? parseGitDiff(options.gitDiff) : void 0;
+  const client = {
+    cliVersion: _chunkJYTXG6OVcjs.package_default.version,
+    platform: process.platform,
+    deviceId: options.deviceId
+  };
+  const sharedMessages = messages.map((msg) => ({
+    role: msg.role,
+    content: msg.content,
+    timestamp: msg.timestamp,
+    name: msg.name,
+    toolCalls: msg.toolCalls,
+    tool_call_id: msg.tool_call_id
+  }));
+  return {
+    metadata: sessionMetadata,
+    usage,
+    toolUsage,
+    gitDiff,
+    messages: sharedMessages,
+    visibility: options.visibility,
+    client,
+    userId: options.userId
+  };
+}
+
+// src/share/ShareApiClient.ts
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+function getBaseUrl() {
+  return process.env.AUTOHAND_SHARE_URL || "https://autohand.link/api";
+}
+var DEFAULT_CONFIG = {
+  baseUrl: getBaseUrl(),
+  timeout: 3e4,
+  // 30s for large payloads
+  maxRetries: 3,
+  offlineQueue: true,
+  cliVersion: _chunkJYTXG6OVcjs.package_default.version
+};
+var ShareApiClient = class {
+  constructor(configOverrides) {
+    this.deviceId = null;
+    this.config = { ...DEFAULT_CONFIG, ...configOverrides };
+    const dataDir = _path2.default.join(_chunkXTHHDIBGcjs.AUTOHAND_PATHS.config, "share");
+    this.queuePath = _path2.default.join(dataDir, "queue.json");
+    this.deviceIdPath = _path2.default.join(_chunkXTHHDIBGcjs.AUTOHAND_PATHS.feedback, ".device-id");
+  }
+  // ============ Device ID ============
+  /**
+   * Get or create anonymous device identifier
+   * Shared with FeedbackApiClient for consistency
+   */
+  async getDeviceId() {
+    if (this.deviceId) return this.deviceId;
+    try {
+      if (await _fsextra2.default.pathExists(this.deviceIdPath)) {
+        this.deviceId = (await _fsextra2.default.readFile(this.deviceIdPath, "utf8")).trim();
+        return this.deviceId;
+      }
+    } catch (e) {
+    }
+    this.deviceId = `anon_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+    try {
+      await _fsextra2.default.ensureDir(_path2.default.dirname(this.deviceIdPath));
+      await _fsextra2.default.writeFile(this.deviceIdPath, this.deviceId);
+    } catch (e2) {
+    }
+    return this.deviceId;
+  }
+  // ============ Create Share ============
+  /**
+   * Upload a session to create a shareable link
+   */
+  async createShare(payload) {
+    try {
+      const response = await this.sendToApi("POST", "/share", payload);
+      if (response.success) {
+        this.flushQueue().catch(() => {
+        });
+      }
+      return response;
+    } catch (error) {
+      if (this.config.offlineQueue) {
+        await this.addToQueue(payload);
+        return {
+          success: false,
+          error: `Queued for retry: ${error.message}`
+        };
+      }
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+  // ============ Delete Share ============
+  /**
+   * Delete a shared session (owner only)
+   */
+  async deleteShare(shareId) {
+    const deviceId = await this.getDeviceId();
+    try {
+      const response = await this.sendToApi(
+        "DELETE",
+        `/share/${shareId}`,
+        void 0,
+        { "X-Device-ID": deviceId }
+      );
+      return response;
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+  // ============ API Communication ============
+  /**
+   * Send request to API endpoint
+   */
+  async sendToApi(method, endpoint, body, extraHeaders) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const headers = {
+        "Content-Type": "application/json",
+        "X-CLI-Version": this.config.cliVersion,
+        ...extraHeaders
+      };
+      const response = await fetch(`${this.config.baseUrl}${endpoint}`, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "Unknown error");
+        throw new Error(`API error: ${response.status} ${errorText}`);
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        throw new Error("Request timeout");
+      }
+      throw error;
+    }
+  }
+  // ============ Offline Queue ============
+  /**
+   * Add share to offline queue
+   */
+  async addToQueue(payload) {
+    try {
+      let queue = [];
+      if (await _fsextra2.default.pathExists(this.queuePath)) {
+        queue = await _fsextra2.default.readJson(this.queuePath);
+      }
+      queue.push({
+        payload,
+        attempts: 0,
+        lastAttempt: (/* @__PURE__ */ new Date()).toISOString(),
+        id: `q_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`
+      });
+      if (queue.length > 10) {
+        queue = queue.slice(-10);
+      }
+      await _fsextra2.default.ensureDir(_path2.default.dirname(this.queuePath));
+      await _fsextra2.default.writeJson(this.queuePath, queue, { spaces: 2 });
+    } catch (e3) {
+    }
+  }
+  /**
+   * Attempt to flush queued shares
+   */
+  async flushQueue() {
+    let sent = 0;
+    let failed = 0;
+    try {
+      if (!await _fsextra2.default.pathExists(this.queuePath)) {
+        return { sent, failed };
+      }
+      const queue = await _fsextra2.default.readJson(this.queuePath);
+      const remaining = [];
+      for (const item of queue) {
+        if (item.attempts >= this.config.maxRetries) {
+          failed++;
+          continue;
+        }
+        try {
+          const response = await this.sendToApi("POST", "/share", item.payload);
+          if (response.success) {
+            sent++;
+          } else {
+            item.attempts++;
+            item.lastAttempt = (/* @__PURE__ */ new Date()).toISOString();
+            remaining.push(item);
+            failed++;
+          }
+        } catch (e4) {
+          item.attempts++;
+          item.lastAttempt = (/* @__PURE__ */ new Date()).toISOString();
+          remaining.push(item);
+          failed++;
+        }
+      }
+      if (remaining.length > 0) {
+        await _fsextra2.default.writeJson(this.queuePath, remaining, { spaces: 2 });
+      } else {
+        await _fsextra2.default.remove(this.queuePath);
+      }
+    } catch (e5) {
+    }
+    return { sent, failed };
+  }
+  /**
+   * Get queue status
+   */
+  async getQueueStatus() {
+    try {
+      if (!await _fsextra2.default.pathExists(this.queuePath)) {
+        return { pending: 0, oldestItem: null };
+      }
+      const queue = await _fsextra2.default.readJson(this.queuePath);
+      return {
+        pending: queue.length,
+        oldestItem: _optionalChain([queue, 'access', _3 => _3[0], 'optionalAccess', _4 => _4.lastAttempt]) || null
+      };
+    } catch (e6) {
+      return { pending: 0, oldestItem: null };
+    }
+  }
+  // ============ Health Check ============
+  /**
+   * Check if API is reachable
+   */
+  async healthCheck() {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5e3);
+      const response = await fetch(`${this.config.baseUrl}/health`, {
+        method: "GET",
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return response.ok;
+    } catch (e7) {
+      return false;
+    }
+  }
+};
+var instance = null;
+var instanceBaseUrl = null;
+function getShareApiClient(config) {
+  const currentBaseUrl = _optionalChain([config, 'optionalAccess', _5 => _5.baseUrl]) || getBaseUrl();
+  if (instance && instanceBaseUrl !== currentBaseUrl) {
+    instance = null;
+  }
+  if (!instance) {
+    instance = new ShareApiClient(config);
+    instanceBaseUrl = currentBaseUrl;
+  }
+  return instance;
+}
+
+// src/commands/share.ts
+function terminalLink(url, text) {
+  const displayText = text || url;
+  const OSC = "\x1B]8;;";
+  const ST = "\x1B\\";
+  return `${OSC}${url}${ST}${_chalk2.default.cyan.underline(displayText)}${OSC}${ST}`;
+}
+var metadata = {
+  command: "/share",
+  description: "Share current session via public URL",
+  implemented: true
+};
+async function execute(_args, context) {
+  if (_optionalChain([context, 'optionalAccess', _6 => _6.config, 'optionalAccess', _7 => _7.share, 'optionalAccess', _8 => _8.enabled]) === false) {
+    console.log(_chalk2.default.yellow("Session sharing is disabled."));
+    console.log(
+      _chalk2.default.gray("To enable, set share.enabled: true in your config file.")
+    );
+    return;
+  }
+  if (!_optionalChain([context, 'optionalAccess', _9 => _9.currentSession])) {
+    console.log(_chalk2.default.yellow("No active session to share."));
+    console.log(
+      _chalk2.default.gray("Start a conversation first, then use /share to share it.")
+    );
+    return;
+  }
+  const session = context.currentSession;
+  const messages = session.getMessages();
+  if (messages.length === 0) {
+    console.log(_chalk2.default.yellow("Session has no messages to share."));
+    return;
+  }
+  const client = getShareApiClient();
+  const deviceId = await client.getDeviceId();
+  const totalTokens = _nullishCoalesce(_optionalChain([context, 'access', _10 => _10.getTotalTokensUsed, 'optionalCall', _11 => _11()]), () => ( 0));
+  const duration = calculateDuration2(session.metadata.createdAt);
+  console.log();
+  console.log(_chalk2.default.bold("Session Summary"));
+  console.log(_chalk2.default.gray("\u2500".repeat(40)));
+  console.log(`  Project:   ${_chalk2.default.cyan(session.metadata.projectName)}`);
+  console.log(`  Model:     ${_chalk2.default.cyan(context.model)}`);
+  console.log(`  Messages:  ${_chalk2.default.cyan(messages.length)}`);
+  console.log(`  Tokens:    ${_chalk2.default.cyan(formatTokens(totalTokens))}`);
+  console.log(
+    `  Est. Cost: ${_chalk2.default.green(formatCost(totalTokens / 1e3 * 3e-3))}`
+  );
+  console.log(`  Duration:  ${_chalk2.default.cyan(formatDuration(duration))}`);
+  console.log();
+  const { Select, Confirm } = _enquirer2.default;
+  const visibilityPrompt = new Select({
+    name: "visibility",
+    message: "Share visibility:",
+    choices: [
+      { name: "public", message: "Public  - Anyone with the link can view" },
+      { name: "private", message: "Private - Requires one-time passcode" }
+    ]
+  });
+  let visibility;
+  try {
+    visibility = await visibilityPrompt.run();
+  } catch (e8) {
+    console.log(_chalk2.default.gray("Cancelled."));
+    return;
+  }
+  const confirmPrompt = new Confirm({
+    name: "confirm",
+    message: `Share this session as ${visibility}?`,
+    initial: true
+  });
+  let confirmed;
+  try {
+    confirmed = await confirmPrompt.run();
+  } catch (e9) {
+    console.log(_chalk2.default.gray("Cancelled."));
+    return;
+  }
+  if (!confirmed) {
+    console.log(_chalk2.default.gray("Cancelled."));
+    return;
+  }
+  console.log();
+  const spinner = _ora2.default.call(void 0, "Uploading session...").start();
+  try {
+    const payload = serializeSession(session, {
+      model: context.model,
+      provider: context.provider,
+      totalTokens,
+      visibility,
+      deviceId
+    });
+    const response = await client.createShare(payload);
+    spinner.stop();
+    if (response.success && response.url) {
+      console.log();
+      console.log(_chalk2.default.green.bold("Session shared successfully!"));
+      console.log();
+      console.log(`${_chalk2.default.bold("URL:")} ${terminalLink(response.url)}`);
+      if (visibility === "private" && response.passcode) {
+        console.log();
+        console.log(`${_chalk2.default.bold("Passcode:")} ${_chalk2.default.yellow.bold(response.passcode)}`);
+        console.log(
+          _chalk2.default.gray("  Share this passcode with people who need access.")
+        );
+      }
+      console.log();
+      console.log(_chalk2.default.gray("Tip: Click the URL or copy it to share with others!"));
+      console.log();
+    } else {
+      console.log();
+      console.log(
+        _chalk2.default.red(`Failed to share: ${response.error || "Unknown error"}`)
+      );
+      console.log();
+    }
+  } catch (error) {
+    spinner.stop();
+    console.log();
+    console.log(_chalk2.default.red(`Failed to share: ${error.message}`));
+    console.log();
+  }
+}
+function calculateDuration2(startedAt) {
+  const start = new Date(startedAt).getTime();
+  const now = Date.now();
+  return Math.max(0, Math.floor((now - start) / 1e3));
+}
+
+
+
+
+exports.metadata = metadata; exports.execute = execute;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Cost Estimator
+ * Simplified token cost estimation for session sharing
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Session Serializer
+ * Converts session data to ShareSessionPayload format
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Share API Client
+ * Handles communication with autohand.link for session sharing
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Share Module
+ * Session sharing functionality
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * /share Command
+ * Share current session via public URL
+ */