autohand-cli 0.8.3 → 0.9.1

package/dist/{chunk-A4IJHHV7.cjs → chunk-63ANVAOJ.cjs}

@@ -1,14 +1,16 @@
 "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 _chunk7BTSG4MEcjs = require('./chunk-7BTSG4ME.cjs');
+var _chunkSY2P3Z5Wcjs = require('./chunk-SY2P3Z5W.cjs');
 
 // src/commands/automode.ts
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
 var metadata = {
   command: "/automode",
-  description: _chunk7BTSG4MEcjs.t.call(void 0, "commands.automode.description"),
+  description: _chunkSY2P3Z5Wcjs.t.call(void 0, "commands.automode.description"),
   implemented: true,
   subcommands: [
+    { name: "on", description: "Enable interactive auto-mode for this session" },
+    { name: "off", description: "Disable interactive auto-mode for this session" },
     { name: "status", description: "Show current loop state" },
     { name: "pause", description: "Pause the active loop" },
     { name: "resume", description: "Resume paused loop" },
@@ -22,6 +24,10 @@ function parseArgs(args) {
     result.subcommand = firstArg;
     args = args.slice(1);
   }
+  if (["on", "off"].includes(firstArg)) {
+    result.subcommand = firstArg;
+    args = args.slice(1);
+  }
   const promptParts = [];
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -42,25 +48,46 @@ function parseArgs(args) {
 }
 async function automode(ctx, args = []) {
   const { automodeManager } = ctx;
-  if (!automodeManager) {
+  const parsed = parseArgs(args);
+  const interactiveAutomodeEnabled = _optionalChain([ctx, 'access', _4 => _4.isInteractiveAutomodeEnabled, 'optionalCall', _5 => _5()]) === true;
+  const canToggleInteractiveAutomode = typeof ctx.setInteractiveAutomodeEnabled === "function";
+  if (!automodeManager && !canToggleInteractiveAutomode && parsed.subcommand !== "status") {
     return "Auto-mode manager not available. Please restart autohand.";
   }
-  const parsed = parseArgs(args);
   switch (parsed.subcommand) {
     case "status":
-      return handleStatus(automodeManager);
+      return handleStatus(automodeManager, interactiveAutomodeEnabled);
+    case "on":
+      return handleInteractiveToggle(ctx, true);
+    case "off":
+      return handleInteractiveToggle(ctx, false);
     case "pause":
+      if (!automodeManager) {
+        return "No auto-mode session is currently running.";
+      }
       return handlePause(automodeManager);
     case "resume":
+      if (!automodeManager) {
+        return "No auto-mode session to resume.";
+      }
       return handleResume(automodeManager);
     case "cancel":
+      if (!automodeManager) {
+        return "No auto-mode session to cancel.";
+      }
       return handleCancel(automodeManager);
     case "help":
       return showHelp();
     default:
+      if (!parsed.prompt && canToggleInteractiveAutomode) {
+        return handleInteractiveToggle(ctx, !interactiveAutomodeEnabled);
+      }
       if (!parsed.prompt) {
         return showHelp();
       }
+      if (!automodeManager) {
+        return 'Standalone auto-mode loops are only available from the CLI flag today. Use `autohand --auto-mode "<task>"`.';
+      }
       return handleStart(automodeManager, parsed);
   }
 }
@@ -80,10 +107,14 @@ Settings:
 
 ` + _chalk2.default.gray("Press ESC to cancel at any time.");
 }
-function handleStatus(manager) {
-  const state = manager.getState();
+function handleStatus(manager, interactiveEnabled) {
+  const state = _optionalChain([manager, 'optionalAccess', _6 => _6.getState, 'call', _7 => _7()]);
+  const lines = [
+    `Interactive auto-mode: ${interactiveEnabled ? "enabled" : "disabled"}`
+  ];
   if (!state) {
-    return "No auto-mode session is currently active.";
+    lines.push("No auto-mode session is currently active.");
+    return lines.join("\n");
   }
   const statusEmoji = {
     running: "\u{1F504}",
@@ -92,16 +123,16 @@ function handleStatus(manager) {
     cancelled: "\u26A0\uFE0F",
     failed: "\u274C"
   };
-  const lines = [
+  lines.push(
     "",
     `${_nullishCoalesce(statusEmoji[state.status], () => ( "\u2753"))} Auto-Mode Status`,
     "",
     `  Session: ${state.sessionId}`,
     `  Status: ${state.status}`,
-    `  ${_chunk7BTSG4MEcjs.t.call(void 0, "commands.automode.iteration", { current: String(state.currentIteration), max: String(state.maxIterations) })}`,
+    `  ${_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.automode.iteration", { current: String(state.currentIteration), max: String(state.maxIterations) })}`,
     `  Files created: ${state.filesCreated}`,
     `  Files modified: ${state.filesModified}`
-  ];
+  );
   if (state.branch) {
     lines.push(`  Branch: ${state.branch}`);
   }
@@ -111,6 +142,13 @@ function handleStatus(manager) {
   lines.push("");
   return lines.join("\n");
 }
+function handleInteractiveToggle(ctx, enabled) {
+  if (!ctx.setInteractiveAutomodeEnabled) {
+    return "Interactive auto-mode is not available in this session.";
+  }
+  ctx.setInteractiveAutomodeEnabled(enabled);
+  return `Interactive auto-mode ${enabled ? "enabled" : "disabled"}.`;
+}
 async function handlePause(manager) {
   if (!manager.isActive()) {
     return "No auto-mode session is currently running.";
@@ -146,6 +184,9 @@ Auto-mode lets autohand work autonomously on tasks through
 iterative improvement cycles-inspired by the Ralph technique.
 
 ${_chalk2.default.yellow("Usage:")}
+  /automode                      Toggle interactive auto-mode on or off
+  /automode on                   Enable interactive auto-mode
+  /automode off                  Disable interactive auto-mode
   /automode <prompt>              Start auto-mode with a task
   /automode status                Show current loop state
   /automode pause                 Pause the loop

package/dist/{chunk-MYISNQH4.js → chunk-65LRPW5W.js}

@@ -1,6 +1,6 @@
 import {
   t
-} from "./chunk-APIXPPMT.js";
+} from "./chunk-LEZEWKPA.js";
 
 // src/commands/quit.ts
 async function quit() {

package/dist/chunk-6AYJCDTA.js

@@ -0,0 +1,360 @@
+import {
+  checkForUpdates
+} from "./chunk-GLBAF54O.js";
+import {
+  getTerminalColumns,
+  renderAutohandLogo
+} from "./chunk-7DJJGKM6.js";
+import {
+  package_default
+} from "./chunk-JB3JCYBJ.js";
+import {
+  showModal
+} from "./chunk-NZ3ZWLUW.js";
+import {
+  loadConfig
+} from "./chunk-IEPLQ47J.js";
+import {
+  AUTH_CONFIG
+} from "./chunk-SHRLFX6F.js";
+
+// src/auth/AuthClient.ts
+var DEFAULT_TIMEOUT = 1e4;
+var AuthClient = class {
+  baseUrl;
+  timeout;
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl || AUTH_CONFIG.apiBaseUrl;
+    this.timeout = config.timeout || DEFAULT_TIMEOUT;
+  }
+  /**
+   * Initiate device authorization flow
+   * Returns device code and user code for display
+   */
+  async initiateDeviceAuth() {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/cli/initiate`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ clientId: "autohand-cli" }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const data = await response.json();
+      if (!response.ok) {
+        return {
+          success: false,
+          error: data.error || data.message || `HTTP ${response.status}`
+        };
+      }
+      return {
+        success: true,
+        deviceCode: data.deviceCode,
+        userCode: data.userCode,
+        verificationUri: data.verificationUri,
+        verificationUriComplete: data.verificationUriComplete,
+        expiresIn: data.expiresIn,
+        interval: data.interval
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        return { success: false, error: "Request timeout" };
+      }
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Poll for device authorization status
+   */
+  async pollDeviceAuth(deviceCode) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/cli/poll`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ deviceCode }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const data = await response.json();
+      if (!response.ok && response.status !== 404) {
+        return {
+          success: false,
+          status: "pending",
+          error: data.error || data.message || `HTTP ${response.status}`
+        };
+      }
+      return {
+        success: data.success !== false,
+        status: data.status || "pending",
+        token: data.token,
+        user: data.user,
+        error: data.error
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        return { success: false, status: "pending", error: "Request timeout" };
+      }
+      return { success: false, status: "pending", error: error.message };
+    }
+  }
+  /**
+   * Validate current session token
+   */
+  async validateSession(token) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/me`, {
+        method: "GET",
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Cookie": `auth_session=${token}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        return { authenticated: false };
+      }
+      const data = await response.json();
+      let user;
+      if (typeof data === "object" && "user" in data) {
+        user = data.user;
+      } else if (typeof data === "object") {
+        user = data;
+      }
+      return {
+        authenticated: true,
+        user
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Logout and invalidate session
+   */
+  async logout(token) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/logout`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Cookie": `auth_session=${token}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return { success: response.ok };
+    } catch {
+      clearTimeout(timeoutId);
+      return { success: true };
+    }
+  }
+};
+var instance = null;
+function getAuthClient(config) {
+  if (!instance) {
+    instance = new AuthClient(config);
+  }
+  return instance;
+}
+
+// src/auth/ensureAuth.ts
+import chalk from "chalk";
+import { spawn } from "child_process";
+import { platform } from "os";
+async function getGitCommit() {
+  if (true) {
+    return "da69f79";
+  }
+  const match = package_default.version.match(/-alpha\.([0-9a-f]{7,40})$/i);
+  if (match?.[1]) {
+    return match[1];
+  }
+  try {
+    const { execSync } = await import("child_process");
+    return execSync("git rev-parse --short HEAD", { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }).trim();
+  } catch {
+    return "unknown";
+  }
+}
+async function runUpgrade() {
+  const os = platform();
+  let command;
+  let args;
+  const shell = false;
+  if (os === "win32") {
+    command = "powershell.exe";
+    args = ["-Command", "iwr -useb https://autohand.ai/install.ps1 | iex"];
+  } else if (os === "darwin") {
+    command = "sh";
+    args = ["-c", "brew tap autohandai/code && brew install autohand-code || curl -fsSL https://autohand.ai/install.sh | sh"];
+  } else {
+    command = "sh";
+    args = ["-c", "curl -fsSL https://autohand.ai/install.sh | sh"];
+  }
+  console.log(chalk.gray("Upgrading Autohand..."));
+  console.log(chalk.gray(`Running: ${command} ${args.join(" ")}`));
+  console.log();
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: "inherit",
+      shell: shell || void 0
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        console.log();
+        console.log(chalk.green("Upgrade completed successfully!"));
+        console.log(chalk.gray("Please restart Autohand to use the new version."));
+        resolve();
+      } else {
+        console.log();
+        console.log(chalk.red("Upgrade failed."));
+        console.log(chalk.gray("You can try manually:"));
+        if (os === "win32") {
+          console.log(chalk.gray("  iwr -useb https://autohand.ai/install.ps1 | iex"));
+        } else {
+          console.log(chalk.gray("  curl -fsSL https://autohand.ai/install.sh | sh"));
+          console.log(chalk.gray("  or: brew tap autohandai/code && brew install autohand-code"));
+        }
+        console.log(chalk.gray("  or: npm i -g autohand-cli"));
+        console.log(chalk.gray("  or: bun i -g autohand-cli"));
+        reject(new Error(`Upgrade failed with exit code ${code}`));
+      }
+    });
+    child.on("error", (error) => {
+      console.log();
+      console.log(chalk.red("Upgrade failed."));
+      console.log(chalk.gray(`Error: ${error.message}`));
+      reject(error);
+    });
+  });
+}
+async function ensureAuthenticated(config) {
+  if (config.auth?.token) {
+    if (isTokenExpiredLocally(config)) {
+      return await promptLogin(config);
+    }
+    return config;
+  }
+  return await promptLogin(config);
+}
+async function checkAuthenticated(config) {
+  if (!config.auth?.token) {
+    return false;
+  }
+  if (isTokenExpiredLocally(config)) {
+    return false;
+  }
+  const client = new AuthClient({ timeout: 3e3 });
+  try {
+    const result = await client.validateSession(config.auth.token);
+    return result.authenticated;
+  } catch {
+    return true;
+  }
+}
+function isTokenExpiredLocally(config) {
+  if (!config.auth?.expiresAt) {
+    return false;
+  }
+  const expiresAt = new Date(config.auth.expiresAt);
+  return expiresAt < /* @__PURE__ */ new Date();
+}
+async function promptLogin(config) {
+  if (process.stdout.isTTY) {
+    const commit = await getGitCommit();
+    const versionStr = commit !== "unknown" ? `v${package_default.version} (${commit})` : `v${package_default.version}`;
+    let updateAvailable = false;
+    let latestVersion = null;
+    try {
+      const updateResult = await checkForUpdates(package_default.version, { forceCheck: true });
+      if (!updateResult.error && !updateResult.isUpToDate && updateResult.latestVersion) {
+        updateAvailable = true;
+        latestVersion = updateResult.latestVersion;
+      }
+    } catch {
+    }
+    const logo = renderAutohandLogo({
+      columns: getTerminalColumns(process.stdout),
+      includeWordmark: true
+    });
+    const logoWithVersion = [logo, "", chalk.gray(versionStr)].join("\n");
+    const options = [
+      { label: "Login", value: "login" }
+    ];
+    if (updateAvailable && latestVersion) {
+      options.push({
+        label: `Upgrade (v${latestVersion} available)`,
+        value: "upgrade"
+      });
+    }
+    options.push({ label: "Exit", value: "exit" });
+    const selected = await showModal({
+      logo: logoWithVersion,
+      skipAltScreen: true,
+      title: updateAvailable ? chalk.yellow("New version available!") : chalk.white("Sign in to continue."),
+      options
+    });
+    if (!selected || selected.value === "exit") {
+      process.exit(0);
+    }
+    if (selected.value === "upgrade") {
+      try {
+        await runUpgrade();
+        process.exit(0);
+      } catch {
+        process.exit(1);
+      }
+    }
+  }
+  const { login } = await import("./login-Q7DZKAX4.js");
+  await login({ config });
+  const refreshed = await loadConfig(config.configPath);
+  if (!refreshed.auth?.token) {
+    console.log(chalk.red("Login failed. Autohand requires authentication to run."));
+    process.exit(1);
+  }
+  return refreshed;
+}
+
+export {
+  getAuthClient,
+  ensureAuthenticated,
+  checkAuthenticated
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Auth API Client for CLI authentication
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Mandatory authentication gate for CLI startup
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Auth module exports
+ */

package/dist/{chunk-X2MSVKDV.js → chunk-6HF6XSCC.js}

@@ -1,9 +1,9 @@
 import {
   safePrompt
-} from "./chunk-6ZCULLCA.js";
+} from "./chunk-MMKZSJUN.js";
 import {
   AUTOHAND_PATHS
-} from "./chunk-EGFT4PGW.js";
+} from "./chunk-SHRLFX6F.js";
 
 // src/commands/agents-new.ts
 import path from "path";

package/dist/{chunk-AEJH23FO.cjs → chunk-6JWCGQJU.cjs}

@@ -1,16 +1,16 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _chunk7BTSG4MEcjs = require('./chunk-7BTSG4ME.cjs');
+var _chunkSY2P3Z5Wcjs = require('./chunk-SY2P3Z5W.cjs');
 
 // src/commands/memory.ts
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
 async function memory(ctx) {
   const { project, user } = await ctx.memoryManager.listAll();
   console.log();
-  console.log(_chalk2.default.bold.cyan(_chunk7BTSG4MEcjs.t.call(void 0, "commands.memory.title")));
+  console.log(_chalk2.default.bold.cyan(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.memory.title")));
   console.log(_chalk2.default.gray("\u2500".repeat(50)));
   if (project.length === 0 && user.length === 0) {
-    console.log(_chalk2.default.gray(_chunk7BTSG4MEcjs.t.call(void 0, "commands.memory.noMemory")));
+    console.log(_chalk2.default.gray(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.memory.noMemory")));
     console.log();
     console.log(_chalk2.default.gray("Tip: Type # followed by text to store a memory."));
     console.log(_chalk2.default.gray("Example: # Always use TypeScript strict mode"));
@@ -18,7 +18,7 @@ async function memory(ctx) {
   }
   if (project.length > 0) {
     console.log();
-    console.log(_chalk2.default.bold.yellow(_chunk7BTSG4MEcjs.t.call(void 0, "commands.memory.projectMemory")) + _chalk2.default.gray(" (.autohand/memory/)"));
+    console.log(_chalk2.default.bold.yellow(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.memory.projectMemory")) + _chalk2.default.gray(" (.autohand/memory/)"));
     console.log();
     for (const entry of project) {
       const date = new Date(entry.updatedAt).toLocaleDateString();
@@ -30,7 +30,7 @@ async function memory(ctx) {
   }
   if (user.length > 0) {
     console.log();
-    console.log(_chalk2.default.bold.magenta(_chunk7BTSG4MEcjs.t.call(void 0, "commands.memory.userMemory")) + _chalk2.default.gray(" (~/.autohand/memory/)"));
+    console.log(_chalk2.default.bold.magenta(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.memory.userMemory")) + _chalk2.default.gray(" (~/.autohand/memory/)"));
     console.log();
     for (const entry of user) {
       const date = new Date(entry.updatedAt).toLocaleDateString();
@@ -46,7 +46,7 @@ async function memory(ctx) {
 }
 var metadata = {
   command: "/memory",
-  description: _chunk7BTSG4MEcjs.t.call(void 0, "commands.memory.description"),
+  description: _chunkSY2P3Z5Wcjs.t.call(void 0, "commands.memory.description"),
   implemented: true
 };