autohand-cli 0.9.0 → 0.9.2

package/dist/{chunk-ACDQGA4Z.js → chunk-3V77OB3W.js}

@@ -1,80 +1,21 @@
+import {
+  buildSessionChatLog,
+  formatChatLogPreview
+} from "./chunk-RS2E32YB.js";
 import {
   showModal
-} from "./chunk-DLP436GI.js";
+} from "./chunk-LOSXLH7P.js";
 import {
   AUTOHAND_PATHS
-} from "./chunk-TWQDAUZU.js";
+} from "./chunk-PG2JIU5M.js";
 import {
   t
-} from "./chunk-CBFH2J3O.js";
+} from "./chunk-SJQU2ZFR.js";
 
 // src/commands/resume.ts
 import chalk from "chalk";
 import fs from "fs-extra";
 import path from "path";
-
-// src/session/chatLog.ts
-function decodeJsonStringLiteral(value) {
-  try {
-    return JSON.parse(`"${value}"`);
-  } catch {
-    return value;
-  }
-}
-function extractJsonStringField(raw, field) {
-  const match = raw.match(new RegExp(`"${field}"\\s*:\\s*"((?:\\\\.|[^"\\\\])*)"`, "s"));
-  return match?.[1] ? decodeJsonStringLiteral(match[1]) : null;
-}
-function getAssistantChatLogContent(content) {
-  const trimmed = content.trim();
-  if (!trimmed) {
-    return null;
-  }
-  try {
-    const parsed = JSON.parse(trimmed);
-    for (const field of ["finalResponse", "response", "content", "message"]) {
-      const value = parsed[field];
-      if (typeof value === "string" && value.trim()) {
-        return value.trim();
-      }
-    }
-    return null;
-  } catch {
-    const finalResponse = extractJsonStringField(trimmed, "finalResponse") ?? extractJsonStringField(trimmed, "response");
-    if (finalResponse?.trim()) {
-      return finalResponse.trim();
-    }
-    if (trimmed.startsWith("{") || trimmed.includes('"thought"')) {
-      return null;
-    }
-    return trimmed;
-  }
-}
-function buildSessionChatLog(messages) {
-  const chatMessages = [];
-  for (const message of messages) {
-    if (message.role === "user") {
-      const content = message.content.trim();
-      if (content) {
-        chatMessages.push({ role: "user", content });
-      }
-      continue;
-    }
-    if (message.role === "assistant") {
-      const content = getAssistantChatLogContent(message.content);
-      if (content) {
-        chatMessages.push({ role: "assistant", content });
-      }
-    }
-  }
-  return chatMessages;
-}
-function formatChatLogPreview(content, maxLength = 100) {
-  const singleLine = content.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
-  return singleLine.length > maxLength ? `${singleLine.slice(0, maxLength)}...` : singleLine;
-}
-
-// src/commands/resume.ts
 var metadata = {
   command: "/resume",
   description: t("commands.resume.description"),
@@ -226,15 +167,9 @@ ${t("commands.resume.resuming", { id: title })}`));
 }
 
 export {
-  buildSessionChatLog,
   metadata,
   resume
 };
-/**
- * @license
- * Copyright 2026 Autohand AI LLC
- * SPDX-License-Identifier: Apache-2.0
- */
 /**
  * @license
  * Copyright 2025 Autohand AI LLC

package/dist/{chunk-HS4USDND.cjs → chunk-3Y5UEK7K.cjs}

@@ -3,10 +3,10 @@
 var _chunkDA7NBAJKcjs = require('./chunk-DA7NBAJK.cjs');
 
 
-var _chunkYFXTE422cjs = require('./chunk-YFXTE422.cjs');
+var _chunkVWHAUB77cjs = require('./chunk-VWHAUB77.cjs');
 
 
-var _chunkCHI52KFRcjs = require('./chunk-CHI52KFR.cjs');
+var _chunkRJCZLFHEcjs = require('./chunk-RJCZLFHE.cjs');
 
 // src/commands/clear.ts
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
@@ -17,7 +17,7 @@ async function clearConversation(ctx) {
     });
   }
   const conversationHistory = _chunkDA7NBAJKcjs.ConversationManager.getInstance().history();
-  const saved = await _chunkYFXTE422cjs.extractAndSaveSessionMemories.call(void 0, {
+  const saved = await _chunkVWHAUB77cjs.extractAndSaveSessionMemories.call(void 0, {
     llm: ctx.llm,
     memoryManager: ctx.memoryManager,
     conversationHistory,
@@ -42,7 +42,7 @@ async function clearConversation(ctx) {
       )
     );
   } else {
-    console.log(_chalk2.default.cyan(_chunkCHI52KFRcjs.t.call(void 0, "commands.new.cleared")));
+    console.log(_chalk2.default.cyan(_chunkRJCZLFHEcjs.t.call(void 0, "commands.new.cleared")));
   }
   console.log();
   return null;

package/dist/{chunk-XV2HXRHX.js → chunk-4GPPSBEZ.js}

@@ -1,16 +1,16 @@
 import {
   SetupWizard
-} from "./chunk-2HOLOHVK.js";
+} from "./chunk-TJZUPS4Z.js";
 import {
   loadConfig,
   resolveWorkspaceRoot,
   saveConfig
-} from "./chunk-3UT7R3XV.js";
+} from "./chunk-CM24K6ZT.js";
 import {
   detectLocale,
   initI18n,
   t
-} from "./chunk-CBFH2J3O.js";
+} from "./chunk-SJQU2ZFR.js";
 
 // src/commands/setup.ts
 import chalk from "chalk";

package/dist/chunk-5CMBAJ6K.js

@@ -0,0 +1,377 @@
+import {
+  getAssistantChatLogContent
+} from "./chunk-RS2E32YB.js";
+import {
+  package_default
+} from "./chunk-NOWCRKP2.js";
+import {
+  AUTOHAND_FILES
+} from "./chunk-PG2JIU5M.js";
+
+// src/commands/go.ts
+import os from "os";
+import chalk from "chalk";
+import QRCode from "qrcode";
+import terminalLink from "terminal-link";
+
+// src/mobile/MobileHandoffClient.ts
+import crypto from "crypto";
+import fs from "fs-extra";
+import path from "path";
+var DEFAULT_API_BASE_URL = "https://api.autohand.ai";
+var DEFAULT_TIMEOUT_MS = 1e4;
+function getMobileApiBaseUrl(config) {
+  return (config?.api?.baseUrl || process.env.AUTOHAND_API_URL || DEFAULT_API_BASE_URL).replace(/\/+$/, "");
+}
+var MobileHandoffClient = class {
+  baseUrl;
+  timeoutMs;
+  constructor(config = {}) {
+    this.baseUrl = (config.baseUrl || DEFAULT_API_BASE_URL).replace(/\/+$/, "");
+    this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
+  async getDeviceId() {
+    try {
+      await fs.ensureDir(path.dirname(AUTOHAND_FILES.deviceId));
+      if (await fs.pathExists(AUTOHAND_FILES.deviceId)) {
+        const existing = (await fs.readFile(AUTOHAND_FILES.deviceId, "utf8")).trim();
+        if (existing) return existing;
+      }
+      const next = crypto.randomUUID();
+      await fs.writeFile(AUTOHAND_FILES.deviceId, next);
+      return next;
+    } catch {
+      return crypto.randomUUID();
+    }
+  }
+  async registerDevice(token, payload) {
+    await this.request("/v1/devices/register", token, {
+      method: "POST",
+      body: JSON.stringify({
+        deviceId: payload.deviceId,
+        clientType: payload.clientType ?? "cli",
+        agentName: payload.agentName,
+        metadata: payload.metadata
+      }),
+      headers: {
+        "X-Device-ID": payload.deviceId
+      }
+    });
+  }
+  async createPairing(token, payload) {
+    const data = await this.request(
+      "/v1/mobile/pairings",
+      token,
+      {
+        method: "POST",
+        body: JSON.stringify(payload),
+        headers: {
+          "X-CLI-Version": package_default.version,
+          "X-Device-ID": payload.deviceId
+        }
+      }
+    );
+    if (data.success !== true || !data.pairing?.pairingUrl) {
+      throw new Error(data.error || "Invalid mobile pairing response");
+    }
+    return data.pairing;
+  }
+  async sendRelayHeartbeat(token, payload) {
+    await this.request(`/v1/mobile/sessions/${encodeURIComponent(payload.sessionId)}/heartbeat`, token, {
+      method: "POST",
+      body: JSON.stringify({
+        deviceId: payload.deviceId,
+        pairingId: payload.pairingId,
+        mode: payload.mode
+      }),
+      headers: {
+        "X-Device-ID": payload.deviceId
+      }
+    });
+  }
+  async claimWork(token, deviceId) {
+    const data = await this.request(
+      "/v1/work/claim",
+      token,
+      {
+        method: "POST",
+        body: JSON.stringify({ deviceId }),
+        headers: {
+          "X-Device-ID": deviceId
+        },
+        allowNotFound: true
+      }
+    );
+    if (data.success === false && data.error === "No work available") {
+      return null;
+    }
+    if (!data.success || !data.work) {
+      throw new Error(data.error || "Invalid work claim response");
+    }
+    return data.work;
+  }
+  async request(path2, token, options) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await fetch(`${this.baseUrl}${path2}`, {
+        method: options.method,
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+          ...options.headers
+        },
+        body: options.body,
+        signal: controller.signal
+      });
+      if (options.allowNotFound && response.status === 404) {
+        const data = await response.json().catch(() => ({ success: false, error: "No work available" }));
+        return data;
+      }
+      if (!response.ok) {
+        const text = await response.text().catch(() => "Unknown error");
+        throw new Error(`API error: ${response.status} ${text}`);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error("Request timeout");
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+
+// src/mobile/MobileRelay.ts
+var activeRelay = null;
+function startMobileRelay(options) {
+  stopMobileRelay();
+  activeRelay = {
+    deviceId: options.deviceId,
+    timer: setInterval(() => {
+      void pollOnce(options);
+    }, Math.max(options.pollIntervalMs, 1e3)),
+    polling: false
+  };
+  activeRelay.timer.unref?.();
+  void pollOnce(options);
+}
+function stopMobileRelay() {
+  if (!activeRelay) return;
+  clearInterval(activeRelay.timer);
+  activeRelay = null;
+}
+async function pollOnce(options) {
+  if (!activeRelay || activeRelay.deviceId !== options.deviceId || activeRelay.polling) {
+    return;
+  }
+  activeRelay.polling = true;
+  try {
+    try {
+      await options.client.sendRelayHeartbeat(options.token, {
+        sessionId: options.sessionId,
+        deviceId: options.deviceId,
+        pairingId: options.pairingId,
+        mode: options.mode
+      });
+    } catch (error) {
+      options.onError?.(error);
+    }
+    const work = await options.client.claimWork(options.token, options.deviceId);
+    if (work?.prompt) {
+      options.enqueueInstruction(work.prompt);
+    }
+  } catch (error) {
+    options.onError?.(error);
+  } finally {
+    if (activeRelay?.deviceId === options.deviceId) {
+      activeRelay.polling = false;
+    }
+  }
+}
+
+// src/commands/go.ts
+var metadata = {
+  command: "/go",
+  description: "pair this session with the Autohand Code iOS app",
+  implemented: true
+};
+var handoffSessionMetadata = {
+  command: "/handoff session",
+  description: "handoff this session to the Autohand Code iOS app",
+  implemented: true
+};
+var MAX_MOBILE_SNAPSHOT_MESSAGES = 24;
+var HANDOFF_FLAG = "experimental_handoff";
+function formatUrl(url) {
+  return terminalLink.isSupported ? terminalLink(url, url) : chalk.cyan.underline(url);
+}
+function formatExpiry(value) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return date.toLocaleString();
+}
+function nativeAppUrl(pairingUrl) {
+  const url = new URL(pairingUrl);
+  const nativeUrl = new URL("autohand-code://go");
+  const pairingId = url.searchParams.get("pairing");
+  const token = url.searchParams.get("token");
+  if (pairingId) nativeUrl.searchParams.set("pairing", pairingId);
+  if (token) nativeUrl.searchParams.set("token", token);
+  return nativeUrl.toString();
+}
+function buildMobileSessionSnapshot(session) {
+  const messages = [];
+  for (const message of session.getMessages()) {
+    if (message.role === "user") {
+      const content = message.content.trim();
+      if (content) {
+        messages.push({ role: "user", content, timestamp: message.timestamp });
+      }
+      continue;
+    }
+    if (message.role === "assistant") {
+      const content = getAssistantChatLogContent(message.content);
+      if (content) {
+        messages.push({ role: "assistant", content, timestamp: message.timestamp });
+      }
+    }
+  }
+  const recentMessages = messages.slice(-MAX_MOBILE_SNAPSHOT_MESSAGES);
+  const firstUserMessage = messages.find((message) => message.role === "user");
+  const title = firstUserMessage?.content ? firstUserMessage.content.replace(/\s+/g, " ").slice(0, 80) : `Continue ${session.metadata.projectName}`;
+  return {
+    title,
+    summary: session.metadata.summary,
+    messageCount: session.metadata.messageCount,
+    lastActivity: session.metadata.lastActiveAt,
+    messages: recentMessages
+  };
+}
+function parseMode(args, canSteer) {
+  if (args.includes("--queue")) return "queue";
+  if (args.includes("--steer")) return "steer";
+  return canSteer ? "steer" : "queue";
+}
+async function go(ctx, args = []) {
+  const mode = parseMode(args, Boolean(ctx.enqueueInstruction));
+  if (mode === "steer" && !ctx.enqueueInstruction) {
+    return [
+      chalk.yellow("Steer mode requires an interactive CLI session."),
+      chalk.gray("Run /go --queue to create a durable queue-only handoff from this mode.")
+    ].join("\n");
+  }
+  const token = ctx.config?.auth?.token;
+  if (!token) {
+    return [
+      chalk.yellow("Sign in first with /login."),
+      chalk.gray("Then run /go again to pair this laptop session with your phone.")
+    ].join("\n");
+  }
+  const session = ctx.currentSession ?? ctx.sessionManager.getCurrentSession();
+  if (!session) {
+    return [
+      chalk.yellow("No active session to pair."),
+      chalk.gray("Start a conversation, then run /go from the project you want to control remotely.")
+    ].join("\n");
+  }
+  const client = ctx.client ?? new MobileHandoffClient({
+    baseUrl: getMobileApiBaseUrl(ctx.config)
+  });
+  try {
+    const deviceId = await client.getDeviceId();
+    await client.registerDevice(token, {
+      deviceId,
+      clientType: "cli",
+      agentName: `${os.hostname()} Autohand Code`,
+      metadata: {
+        workspacePath: ctx.workspaceRoot,
+        projectName: session.metadata.projectName,
+        sessionId: session.metadata.sessionId,
+        model: ctx.model,
+        provider: ctx.provider,
+        platform: process.platform,
+        hostname: os.hostname(),
+        client: session.metadata.client,
+        clientVersion: session.metadata.clientVersion
+      }
+    });
+    const pairing = await client.createPairing(token, {
+      deviceId,
+      sessionId: session.metadata.sessionId,
+      workspacePath: ctx.workspaceRoot,
+      projectName: session.metadata.projectName,
+      model: ctx.model,
+      provider: ctx.provider,
+      capabilities: ["prompt", "approval", "notifications"],
+      metadata: {
+        platform: process.platform,
+        hostname: os.hostname(),
+        client: session.metadata.client,
+        clientVersion: session.metadata.clientVersion,
+        sessionSnapshot: JSON.stringify(buildMobileSessionSnapshot(session))
+      }
+    });
+    if (mode === "steer" && ctx.enqueueInstruction) {
+      startMobileRelay({
+        client,
+        token,
+        deviceId,
+        sessionId: session.metadata.sessionId,
+        pairingId: pairing.id,
+        mode,
+        pollIntervalMs: pairing.pollIntervalMs,
+        enqueueInstruction: ctx.enqueueInstruction
+      });
+    }
+    const appUrl = nativeAppUrl(pairing.pairingUrl);
+    const qr = await QRCode.toString(pairing.pairingUrl, {
+      type: "utf8",
+      errorCorrectionLevel: "M"
+    });
+    return [
+      "",
+      chalk.bold("Autohand Code mobile handoff"),
+      chalk.gray("Scan this with the iOS app to continue this session from your phone."),
+      "",
+      qr,
+      "",
+      `${chalk.gray("Scan or open:")} ${formatUrl(pairing.pairingUrl)}`,
+      `${chalk.gray("Simulator fallback:")} ${formatUrl(appUrl)}`,
+      `${chalk.gray("Project:")} ${chalk.cyan(session.metadata.projectName)}`,
+      `${chalk.gray("Session:")} ${chalk.cyan(session.metadata.sessionId)}`,
+      `${chalk.gray("Mode:")} ${mode === "steer" ? chalk.green("steer live") : chalk.yellow("queue")}`,
+      `${chalk.gray("Relay:")} ${mode === "steer" ? chalk.green("listening for mobile prompts") : chalk.yellow("prompts will wait in the queue")}`,
+      `${chalk.gray("Expires:")} ${chalk.cyan(formatExpiry(pairing.expiresAt))}`,
+      ""
+    ].join("\n");
+  } catch (error) {
+    return [
+      chalk.red("Could not create mobile handoff."),
+      chalk.gray(error.message)
+    ].join("\n");
+  }
+}
+async function handoffSession(ctx, args = []) {
+  const localDefault = ctx.config?.features?.experimentalHandoff === true;
+  const enabled = ctx.isFeatureEnabled?.(HANDOFF_FLAG, localDefault) ?? localDefault;
+  if (!enabled) {
+    return `The /handoff session command is behind ${HANDOFF_FLAG}. Run /features enable ${HANDOFF_FLAG}, then /handoff session again. No restart required.`;
+  }
+  await ctx.trackFeatureActivation?.(HANDOFF_FLAG, { surface: "slash_command" });
+  return go(ctx, args);
+}
+
+export {
+  metadata,
+  handoffSessionMetadata,
+  go,
+  handoffSession
+};
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-MO4KP6XS.cjs → chunk-5YRXFBYZ.cjs}

@@ -1,12 +1,12 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
 
-var _chunk7LWQCE4Ycjs = require('./chunk-7LWQCE4Y.cjs');
+var _chunkEFXFURDYcjs = require('./chunk-EFXFURDY.cjs');
 
 
-var _chunkREMGR23Vcjs = require('./chunk-REMGR23V.cjs');
+var _chunkCSUGNNJYcjs = require('./chunk-CSUGNNJY.cjs');
 
 
-var _chunk46C73ZKKcjs = require('./chunk-46C73ZKK.cjs');
+var _chunkCNQKIWIScjs = require('./chunk-CNQKIWIS.cjs');
 
 // src/reporting/processErrorReporting.ts
 var DEFAULT_API_BASE_URL = "https://api.autohand.ai";
@@ -45,6 +45,9 @@ function detectClientName(processRef) {
 function getLogPrefix(processRef) {
   return detectClientName(processRef) === "acp" ? "[ACP]" : "[DEBUG]";
 }
+function isProcessAutoReportDisabled(processRef) {
+  return processRef.env.AUTOHAND_DISABLE_AUTO_REPORT === "1" || processRef.env.AUTOHAND_AUTO_REPORT === "0";
+}
 function captureLastError(reason) {
   globalThis.__autohandLastError = reason;
 }
@@ -78,11 +81,11 @@ async function getAutoReportManager(processRef, explicitConfigPath) {
   const managerPromise = (async () => {
     let config;
     try {
-      config = await _chunk46C73ZKKcjs.loadConfig.call(void 0, configPath);
+      config = await _chunkCNQKIWIScjs.loadConfig.call(void 0, configPath);
     } catch (e) {
       config = buildFallbackConfig(configPath, processRef);
     }
-    return new (0, _chunk7LWQCE4Ycjs.AutoReportManager)(config, _chunkREMGR23Vcjs.package_default.version);
+    return new (0, _chunkEFXFURDYcjs.AutoReportManager)(config, _chunkCSUGNNJYcjs.package_default.version);
   })();
   managerCache.set(cacheKey, managerPromise);
   return managerPromise;
@@ -94,6 +97,19 @@ function isIgnorableStdinReadError(err, _processRef) {
   const maybeError = err;
   return maybeError.code === "EIO" && maybeError.syscall === "read";
 }
+function isIgnorableTerminalPipeError(err) {
+  if (!err || typeof err !== "object") {
+    return false;
+  }
+  const maybeError = err;
+  if (maybeError.code === "UV_EPIPE" && maybeError.syscall === "recv") {
+    return true;
+  }
+  if (maybeError.code !== "EPIPE") {
+    return false;
+  }
+  return maybeError.syscall === "read" || maybeError.syscall === "write" || /\b(read|write) EPIPE\b/i.test(_nullishCoalesce(maybeError.message, () => ( "")));
+}
 function isIgnorableFilesystemError(err) {
   if (!err || typeof err !== "object") return false;
   const maybeError = err;
@@ -113,6 +129,7 @@ function isIgnorableUnhandledRejection(reason, processRef) {
     return true;
   }
   if (isIgnorableStdinReadError(reason, processRef)) return true;
+  if (isIgnorableTerminalPipeError(reason)) return true;
   if (isIgnorableFilesystemError(reason)) return true;
   if (isIgnorableTerminalOrRuntimeError(reason)) return true;
   return false;
@@ -151,10 +168,13 @@ function describeReasonType(reason) {
 }
 async function reportProcessError(reason, options) {
   const processRef = _nullishCoalesce(options.processRef, () => ( process));
+  if (isProcessAutoReportDisabled(processRef)) {
+    return;
+  }
   if (options.handler === "unhandledRejection" && isIgnorableUnhandledRejection(reason, processRef)) {
     return;
   }
-  if (options.handler === "uncaughtException" && (isIgnorableStdinReadError(reason, processRef) || isIgnorableTerminalOrRuntimeError(reason))) {
+  if (options.handler === "uncaughtException" && (isIgnorableStdinReadError(reason, processRef) || isIgnorableTerminalPipeError(reason) || isIgnorableTerminalOrRuntimeError(reason))) {
     return;
   }
   captureLastError(reason);
@@ -186,9 +206,15 @@ function installProcessErrorHandlers(options = {}) {
     processRef.exit(code);
   })));
   processRef.on("uncaughtException", (error) => {
+    if (isProcessAutoReportDisabled(processRef)) {
+      return;
+    }
     if (isIgnorableStdinReadError(error, processRef)) {
       return;
     }
+    if (isIgnorableTerminalPipeError(error)) {
+      return;
+    }
     if (isIgnorableTerminalOrRuntimeError(error)) {
       return;
     }
@@ -205,6 +231,9 @@ function installProcessErrorHandlers(options = {}) {
     })();
   });
   processRef.on("unhandledRejection", (reason, promise) => {
+    if (isProcessAutoReportDisabled(processRef)) {
+      return;
+    }
     if (isIgnorableUnhandledRejection(reason, processRef)) {
       return;
     }