autohand-cli 0.8.3 → 0.9.1

package/dist/chunk-CO2AADYU.cjs

@@ -0,0 +1,360 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } 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 _chunkFMB3TSWPcjs = require('./chunk-FMB3TSWP.cjs');
+
+
+
+var _chunkSD3NTC7Dcjs = require('./chunk-SD3NTC7D.cjs');
+
+
+var _chunkAQ5PVHOCcjs = require('./chunk-AQ5PVHOC.cjs');
+
+
+var _chunkCK4HAHVYcjs = require('./chunk-CK4HAHVY.cjs');
+
+
+var _chunkX5P6QQOBcjs = require('./chunk-X5P6QQOB.cjs');
+
+
+var _chunkKASXKDF2cjs = require('./chunk-KASXKDF2.cjs');
+
+// src/auth/AuthClient.ts
+var DEFAULT_TIMEOUT = 1e4;
+var AuthClient = class {
+  
+  
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl || _chunkKASXKDF2cjs.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 (e) {
+      clearTimeout(timeoutId);
+      return { success: true };
+    }
+  }
+};
+var instance = null;
+function getAuthClient(config) {
+  if (!instance) {
+    instance = new AuthClient(config);
+  }
+  return instance;
+}
+
+// src/auth/ensureAuth.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var _child_process = require('child_process');
+var _os = require('os');
+async function getGitCommit() {
+  if (true) {
+    return "da69f79";
+  }
+  const match = _chunkAQ5PVHOCcjs.package_default.version.match(/-alpha\.([0-9a-f]{7,40})$/i);
+  if (_optionalChain([match, 'optionalAccess', _ => _[1]])) {
+    return match[1];
+  }
+  try {
+    const { execSync } = await Promise.resolve().then(() => _interopRequireWildcard(require("child_process")));
+    return execSync("git rev-parse --short HEAD", { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }).trim();
+  } catch (e2) {
+    return "unknown";
+  }
+}
+async function runUpgrade() {
+  const os = _os.platform.call(void 0, );
+  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(_chalk2.default.gray("Upgrading Autohand..."));
+  console.log(_chalk2.default.gray(`Running: ${command} ${args.join(" ")}`));
+  console.log();
+  return new Promise((resolve, reject) => {
+    const child = _child_process.spawn.call(void 0, command, args, {
+      stdio: "inherit",
+      shell: shell || void 0
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        console.log();
+        console.log(_chalk2.default.green("Upgrade completed successfully!"));
+        console.log(_chalk2.default.gray("Please restart Autohand to use the new version."));
+        resolve();
+      } else {
+        console.log();
+        console.log(_chalk2.default.red("Upgrade failed."));
+        console.log(_chalk2.default.gray("You can try manually:"));
+        if (os === "win32") {
+          console.log(_chalk2.default.gray("  iwr -useb https://autohand.ai/install.ps1 | iex"));
+        } else {
+          console.log(_chalk2.default.gray("  curl -fsSL https://autohand.ai/install.sh | sh"));
+          console.log(_chalk2.default.gray("  or: brew tap autohandai/code && brew install autohand-code"));
+        }
+        console.log(_chalk2.default.gray("  or: npm i -g autohand-cli"));
+        console.log(_chalk2.default.gray("  or: bun i -g autohand-cli"));
+        reject(new Error(`Upgrade failed with exit code ${code}`));
+      }
+    });
+    child.on("error", (error) => {
+      console.log();
+      console.log(_chalk2.default.red("Upgrade failed."));
+      console.log(_chalk2.default.gray(`Error: ${error.message}`));
+      reject(error);
+    });
+  });
+}
+async function ensureAuthenticated(config) {
+  if (_optionalChain([config, 'access', _2 => _2.auth, 'optionalAccess', _3 => _3.token])) {
+    if (isTokenExpiredLocally(config)) {
+      return await promptLogin(config);
+    }
+    return config;
+  }
+  return await promptLogin(config);
+}
+async function checkAuthenticated(config) {
+  if (!_optionalChain([config, 'access', _4 => _4.auth, 'optionalAccess', _5 => _5.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 (e3) {
+    return true;
+  }
+}
+function isTokenExpiredLocally(config) {
+  if (!_optionalChain([config, 'access', _6 => _6.auth, 'optionalAccess', _7 => _7.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${_chunkAQ5PVHOCcjs.package_default.version} (${commit})` : `v${_chunkAQ5PVHOCcjs.package_default.version}`;
+    let updateAvailable = false;
+    let latestVersion = null;
+    try {
+      const updateResult = await _chunkFMB3TSWPcjs.checkForUpdates.call(void 0, _chunkAQ5PVHOCcjs.package_default.version, { forceCheck: true });
+      if (!updateResult.error && !updateResult.isUpToDate && updateResult.latestVersion) {
+        updateAvailable = true;
+        latestVersion = updateResult.latestVersion;
+      }
+    } catch (e4) {
+    }
+    const logo = _chunkSD3NTC7Dcjs.renderAutohandLogo.call(void 0, {
+      columns: _chunkSD3NTC7Dcjs.getTerminalColumns.call(void 0, process.stdout),
+      includeWordmark: true
+    });
+    const logoWithVersion = [logo, "", _chalk2.default.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 _chunkCK4HAHVYcjs.showModal.call(void 0, {
+      logo: logoWithVersion,
+      skipAltScreen: true,
+      title: updateAvailable ? _chalk2.default.yellow("New version available!") : _chalk2.default.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 (e5) {
+        process.exit(1);
+      }
+    }
+  }
+  const { login } = await Promise.resolve().then(() => _interopRequireWildcard(require("./login-GST7MWXJ.cjs")));
+  await login({ config });
+  const refreshed = await _chunkX5P6QQOBcjs.loadConfig.call(void 0, config.configPath);
+  if (!_optionalChain([refreshed, 'access', _8 => _8.auth, 'optionalAccess', _9 => _9.token])) {
+    console.log(_chalk2.default.red("Login failed. Autohand requires authentication to run."));
+    process.exit(1);
+  }
+  return refreshed;
+}
+
+
+
+
+
+exports.getAuthClient = getAuthClient; exports.ensureAuthenticated = ensureAuthenticated; exports.checkAuthenticated = 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
+ */