autohand-cli 0.6.2 → 0.6.3

package/dist/chunk-3OD5MR23.js

@@ -1,384 +0,0 @@
-import {
-  AUTH_CONFIG,
-  AUTOHAND_FILES
-} from "./chunk-737A24RB.js";
-
-// src/config.ts
-import fs from "fs-extra";
-import path from "path";
-import YAML from "yaml";
-var DEFAULT_CONFIG_PATH = AUTOHAND_FILES.configJson;
-var YAML_CONFIG_PATH = AUTOHAND_FILES.configYaml;
-var YML_CONFIG_PATH = AUTOHAND_FILES.configYml;
-var DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
-var DEFAULT_OLLAMA_URL = "http://localhost:11434";
-var DEFAULT_LLAMACPP_URL = "http://localhost:8080";
-var DEFAULT_OPENAI_URL = "https://api.openai.com/v1";
-async function detectConfigPath(customPath) {
-  if (customPath) {
-    return path.resolve(customPath);
-  }
-  const envPath = process.env.AUTOHAND_CONFIG;
-  if (envPath) {
-    return path.resolve(envPath);
-  }
-  if (await fs.pathExists(YAML_CONFIG_PATH)) {
-    return YAML_CONFIG_PATH;
-  }
-  if (await fs.pathExists(YML_CONFIG_PATH)) {
-    return YML_CONFIG_PATH;
-  }
-  return DEFAULT_CONFIG_PATH;
-}
-function isYamlFile(filePath) {
-  const ext = path.extname(filePath).toLowerCase();
-  return ext === ".yaml" || ext === ".yml";
-}
-async function parseConfigFile(configPath) {
-  const content = await fs.readFile(configPath, "utf8");
-  if (isYamlFile(configPath)) {
-    return YAML.parse(content);
-  }
-  return JSON.parse(content);
-}
-async function loadConfig(customPath) {
-  const configPath = await detectConfigPath(customPath);
-  await fs.ensureDir(path.dirname(configPath));
-  let isNewConfig = false;
-  if (!await fs.pathExists(configPath)) {
-    const defaultConfig = {
-      provider: "openrouter",
-      openrouter: {
-        apiKey: "",
-        baseUrl: "https://openrouter.ai/api/v1",
-        model: "anthropic/claude-sonnet-4-20250514"
-      },
-      workspace: {
-        defaultRoot: process.cwd(),
-        allowDangerousOps: false
-      },
-      ui: {
-        theme: "dark",
-        autoConfirm: false
-      },
-      telemetry: {
-        enabled: true
-      }
-    };
-    await fs.writeJson(configPath, defaultConfig, { spaces: 2 });
-    isNewConfig = true;
-  }
-  let parsed;
-  try {
-    parsed = await parseConfigFile(configPath);
-  } catch (error) {
-    throw new Error(`Failed to parse config at ${configPath}: ${error.message}`);
-  }
-  const normalized = normalizeConfig(parsed);
-  const withEnv = mergeEnvVariables(normalized);
-  validateConfig(withEnv, configPath);
-  return { ...withEnv, configPath, isNewConfig };
-}
-function mergeEnvVariables(config) {
-  return {
-    ...config,
-    api: {
-      baseUrl: process.env.AUTOHAND_API_URL || config.api?.baseUrl || "https://api.autohand.ai",
-      companySecret: process.env.AUTOHAND_SECRET || config.api?.companySecret || ""
-    }
-  };
-}
-function normalizeConfig(config) {
-  if (isModernConfig(config)) {
-    const provider = config.provider ?? "openrouter";
-    return { provider, ...config };
-  }
-  if (isLegacyConfig(config)) {
-    return {
-      provider: "openrouter",
-      openrouter: {
-        apiKey: config.api_key ?? "replace-me",
-        baseUrl: config.base_url ?? DEFAULT_BASE_URL,
-        model: config.model ?? "anthropic/claude-3.5-sonnet"
-      },
-      workspace: {
-        defaultRoot: process.cwd(),
-        allowDangerousOps: false
-      },
-      ui: {
-        autoConfirm: config.dry_run ?? false,
-        theme: "dark"
-      }
-    };
-  }
-  return config;
-}
-function isModernConfig(config) {
-  return typeof config.openrouter === "object" || typeof config.ollama === "object" || typeof config.llamacpp === "object" || typeof config.openai === "object";
-}
-function isLegacyConfig(config) {
-  return typeof config.api_key === "string";
-}
-function validateConfig(config, configPath) {
-  const provider = config.provider ?? "openrouter";
-  const providerConfig = getProviderConfig(config, provider);
-  if (config.workspace) {
-    if (config.workspace.defaultRoot && typeof config.workspace.defaultRoot !== "string") {
-      throw new Error(`workspace.defaultRoot must be a string in ${configPath}`);
-    }
-    if (config.workspace.allowDangerousOps !== void 0 && typeof config.workspace.allowDangerousOps !== "boolean") {
-      throw new Error(`workspace.allowDangerousOps must be boolean in ${configPath}`);
-    }
-  }
-  if (config.ui) {
-    if (config.ui.theme && config.ui.theme !== "dark" && config.ui.theme !== "light") {
-      throw new Error(`ui.theme must be 'dark' or 'light' in ${configPath}`);
-    }
-    if (config.ui.autoConfirm !== void 0 && typeof config.ui.autoConfirm !== "boolean") {
-      throw new Error(`ui.autoConfirm must be boolean in ${configPath}`);
-    }
-  }
-  if (config.externalAgents) {
-    if (config.externalAgents.enabled !== void 0 && typeof config.externalAgents.enabled !== "boolean") {
-      throw new Error(`externalAgents.enabled must be boolean in ${configPath}`);
-    }
-    if (config.externalAgents.paths !== void 0) {
-      if (!Array.isArray(config.externalAgents.paths)) {
-        throw new Error(`externalAgents.paths must be an array in ${configPath}`);
-      }
-      for (const p of config.externalAgents.paths) {
-        if (typeof p !== "string") {
-          throw new Error(`externalAgents.paths must contain only strings in ${configPath}`);
-        }
-      }
-    }
-  }
-}
-function resolveWorkspaceRoot(config, requestedPath) {
-  const candidate = requestedPath ?? process.cwd() ?? config.workspace?.defaultRoot;
-  return path.resolve(candidate);
-}
-function getProviderConfig(config, provider) {
-  const chosen = provider ?? config.provider ?? "openrouter";
-  const configByProvider = {
-    openrouter: config.openrouter,
-    ollama: config.ollama,
-    llamacpp: config.llamacpp,
-    openai: config.openai
-  };
-  const entry = configByProvider[chosen];
-  if (!entry) {
-    return null;
-  }
-  if (chosen === "openrouter") {
-    const { apiKey, model } = entry;
-    if (!apiKey || apiKey === "replace-me" || !model) {
-      return null;
-    }
-  } else {
-    if (!entry.model) {
-      return null;
-    }
-  }
-  return {
-    ...entry,
-    baseUrl: entry.baseUrl ?? defaultBaseUrlFor(chosen, entry.port)
-  };
-}
-function defaultBaseUrlFor(provider, port) {
-  if (provider === "openrouter") return DEFAULT_BASE_URL;
-  const p = port ? port.toString() : void 0;
-  switch (provider) {
-    case "ollama":
-      return p ? `http://localhost:${p}` : DEFAULT_OLLAMA_URL;
-    case "llamacpp":
-      return p ? `http://localhost:${p}` : DEFAULT_LLAMACPP_URL;
-    case "openai":
-      return DEFAULT_OPENAI_URL;
-    default:
-      return void 0;
-  }
-}
-async function saveConfig(config) {
-  const { configPath, ...data } = config;
-  if (isYamlFile(configPath)) {
-    const yamlContent = YAML.stringify(data, { indent: 2 });
-    await fs.writeFile(configPath, yamlContent, "utf8");
-  } else {
-    await fs.writeJson(configPath, data, { spaces: 2 });
-  }
-}
-
-// src/auth/AuthClient.ts
-var DEFAULT_TIMEOUT = 1e4;
-var AuthClient = class {
-  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();
-      return {
-        authenticated: true,
-        user: data.user || data
-      };
-    } catch {
-      clearTimeout(timeoutId);
-      return { authenticated: false };
-    }
-  }
-  /**
-   * 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;
-}
-
-export {
-  loadConfig,
-  resolveWorkspaceRoot,
-  getProviderConfig,
-  saveConfig,
-  getAuthClient
-};
-/**
- * @license
- * Copyright 2025 Autohand AI LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * @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
- *
- * Auth module exports
- */

package/dist/chunk-4LDR3Y3A.js

@@ -1,79 +0,0 @@
-import {
-  AUTOHAND_FILES
-} from "./chunk-SN7D2PJO.js";
-
-// src/commands/feedback.ts
-import fs from "fs-extra";
-import chalk from "chalk";
-import enquirer from "enquirer";
-var metadata = {
-  command: "/feedback",
-  description: "share feedback with environment details",
-  implemented: true
-};
-async function feedback(_ctx) {
-  const answer = await enquirer.prompt([
-    {
-      type: "input",
-      name: "feedback",
-      message: "What worked? What broke?"
-    }
-  ]);
-  if (!answer.feedback?.trim()) {
-    console.log(chalk.gray("Feedback discarded (empty)."));
-    return null;
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const runtimeError = getLastRuntimeError();
-  const payload = {
-    timestamp: now,
-    feedback: answer.feedback.trim(),
-    env: {
-      platform: `${process.platform}-${process.arch}`,
-      node: process.version,
-      bun: process.versions?.bun,
-      cwd: process.cwd(),
-      shell: process.env.SHELL
-    },
-    runtimeError: runtimeError ? formatError(runtimeError) : null
-  };
-  try {
-    const feedbackPath = AUTOHAND_FILES.feedbackLog;
-    await fs.ensureFile(feedbackPath);
-    await fs.appendFile(feedbackPath, JSON.stringify(payload) + "\n", "utf8");
-    console.log(chalk.green("Feedback recorded."));
-    console.log(chalk.gray(`Saved to ${feedbackPath}`));
-  } catch (error) {
-    console.error(chalk.red(`Failed to save feedback: ${error.message}`));
-  }
-  if (runtimeError) {
-    console.log(chalk.yellow("Detected a recent runtime error; included in feedback payload."));
-  }
-  return null;
-}
-function getLastRuntimeError() {
-  const globalAny = globalThis;
-  return globalAny.__autohandLastError ?? null;
-}
-function formatError(err) {
-  if (!err) return {};
-  if (err instanceof Error) {
-    return { message: err.message, stack: err.stack };
-  }
-  if (typeof err === "object") {
-    const message = "message" in err ? String(err.message) : void 0;
-    const stack = "stack" in err ? String(err.stack) : void 0;
-    return { message, stack };
-  }
-  return { message: String(err) };
-}
-
-export {
-  metadata,
-  feedback
-};
-/**
- * @license
- * Copyright 2025 Autohand AI LLC
- * SPDX-License-Identifier: Apache-2.0
- */