autohand-cli 0.6.0 → 0.6.2

package/dist/chunk-7MFSCH7E.js

@@ -0,0 +1,382 @@
+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));
+  if (!await fs.pathExists(configPath)) {
+    const defaultConfig = {
+      provider: "openrouter",
+      openrouter: {
+        apiKey: "replace-me",
+        baseUrl: "https://openrouter.ai/api/v1",
+        model: "anthropic/claude-3.5-sonnet"
+      },
+      workspace: {
+        defaultRoot: process.cwd(),
+        allowDangerousOps: false
+      },
+      ui: {
+        theme: "dark",
+        autoConfirm: false
+      }
+    };
+    await fs.writeJson(configPath, defaultConfig, { spaces: 2 });
+    throw new Error(
+      `Created default config at ${configPath}. Please update it with your OpenRouter credentials before rerunning.`
+    );
+  }
+  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 };
+}
+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-7TV5KURP.js

@@ -0,0 +1,79 @@
+import {
+  AUTOHAND_FILES
+} from "./chunk-7FMMKTRG.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
+ */

package/dist/chunk-7WBK33MM.js

@@ -0,0 +1,57 @@
+import {
+  getAuthClient,
+  saveConfig
+} from "./chunk-7MFSCH7E.js";
+
+// src/commands/logout.ts
+import chalk from "chalk";
+import enquirer from "enquirer";
+var metadata = {
+  command: "/logout",
+  description: "sign out of your Autohand account",
+  implemented: true
+};
+async function logout(ctx) {
+  const config = ctx.config;
+  if (!config?.auth?.token) {
+    console.log(chalk.yellow("You are not currently logged in."));
+    console.log(chalk.gray("Use /login to sign in to your Autohand account."));
+    return null;
+  }
+  const userName = config.auth.user?.name || config.auth.user?.email || "user";
+  const { confirm } = await enquirer.prompt({
+    type: "confirm",
+    name: "confirm",
+    message: `Log out from ${chalk.cyan(userName)}?`,
+    initial: true
+  });
+  if (!confirm) {
+    console.log(chalk.gray("Logout cancelled."));
+    return null;
+  }
+  const authClient = getAuthClient();
+  try {
+    await authClient.logout(config.auth.token);
+  } catch {
+  }
+  const updatedConfig = {
+    ...config,
+    auth: void 0
+  };
+  await saveConfig(updatedConfig);
+  console.log();
+  console.log(chalk.green("Successfully logged out."));
+  console.log(chalk.gray("Your local session has been cleared."));
+  console.log();
+  return null;
+}
+
+export {
+  metadata,
+  logout
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-7XN6PAKV.js

@@ -0,0 +1,79 @@
+import {
+  AUTOHAND_FILES
+} from "./chunk-DAMLAWGE.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
+ */