@autenai/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,486 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander = require("commander");
+
+// src/commands/login.ts
+var import_inquirer = __toESM(require("inquirer"));
+var import_chalk2 = __toESM(require("chalk"));
+var import_ora = __toESM(require("ora"));
+var import_sdk = require("@autenai/sdk");
+
+// src/lib/config.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var CONFIG_DIR = path.join(os.homedir(), ".auten");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function readConfig() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
+function writeConfig(config) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+  fs.chmodSync(CONFIG_FILE, 384);
+}
+function getApiKey() {
+  if (process.env.AUTEN_API_KEY) {
+    return process.env.AUTEN_API_KEY;
+  }
+  return readConfig().apiKey;
+}
+function getBaseUrl() {
+  return readConfig().baseUrl || process.env.AUTEN_BASE_URL || "https://auten.ai";
+}
+
+// src/lib/output.ts
+var import_chalk = __toESM(require("chalk"));
+function header(text) {
+  console.log();
+  console.log(import_chalk.default.bold.cyan(text));
+  console.log(import_chalk.default.dim("\u2500".repeat(text.length + 4)));
+}
+function success(text) {
+  console.log(import_chalk.default.green("\u2713") + " " + text);
+}
+function error(text) {
+  console.error(import_chalk.default.red("\u2717") + " " + text);
+}
+function warn(text) {
+  console.log(import_chalk.default.yellow("!") + " " + text);
+}
+function info(text) {
+  console.log(import_chalk.default.dim("i") + " " + text);
+}
+function table(headers, rows) {
+  const widths = headers.map((h, i) => {
+    const maxRow = Math.max(...rows.map((r) => (r[i] || "").length));
+    return Math.max(h.length, maxRow) + 2;
+  });
+  const headerLine = headers.map((h, i) => import_chalk.default.bold(h.padEnd(widths[i]))).join(" ");
+  console.log(headerLine);
+  console.log(widths.map((w) => import_chalk.default.dim("\u2500".repeat(w))).join(" "));
+  for (const row of rows) {
+    const line = row.map((cell, i) => (cell || "").padEnd(widths[i])).join(" ");
+    console.log(line);
+  }
+}
+
+// src/commands/login.ts
+async function loginCommand() {
+  console.log();
+  console.log(import_chalk2.default.bold("Auten.ai Login"));
+  console.log();
+  info(`Get your API key at: ${import_chalk2.default.underline("https://auten.ai/settings")} \u2192 API Keys`);
+  console.log();
+  const { apiKey } = await import_inquirer.default.prompt([
+    {
+      type: "password",
+      name: "apiKey",
+      message: "Paste your API key:",
+      mask: "*",
+      validate: (input) => {
+        if (!input.startsWith("auten_live_") && !input.startsWith("auten_test_")) {
+          return "API key should start with auten_live_ or auten_test_";
+        }
+        return true;
+      }
+    }
+  ]);
+  const spinner = (0, import_ora.default)("Validating API key...").start();
+  try {
+    const baseUrl = getBaseUrl();
+    const auten = new import_sdk.Auten({ apiKey, baseUrl, retries: 0 });
+    const providers = await auten.providers.list();
+    spinner.stop();
+    success("Authenticated successfully!");
+    if (providers.length > 0) {
+      info(`${providers.length} provider(s) connected: ${providers.map((p) => p.slug).join(", ")}`);
+    } else {
+      info("No providers connected yet. Connect them at auten.ai/settings/integrations");
+    }
+    const config = readConfig();
+    config.apiKey = apiKey;
+    writeConfig(config);
+    console.log();
+    success(`API key saved to ${import_chalk2.default.dim("~/.auten/config.json")}`);
+  } catch (err) {
+    spinner.stop();
+    error(`Authentication failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/providers.ts
+var import_ora2 = __toESM(require("ora"));
+var import_sdk2 = require("@autenai/sdk");
+function requireAuth() {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    error("Not logged in. Run: auten login");
+    process.exit(1);
+  }
+  return new import_sdk2.Auten({ apiKey, baseUrl: getBaseUrl() });
+}
+async function providersListCommand() {
+  const auten = requireAuth();
+  const spinner = (0, import_ora2.default)("Fetching providers...").start();
+  try {
+    const providers = await auten.providers.list();
+    spinner.stop();
+    if (providers.length === 0) {
+      header("Connected Providers");
+      info("No providers connected. Visit auten.ai/settings/integrations to connect.");
+      return;
+    }
+    header(`Connected Providers (${providers.length})`);
+    table(
+      ["Provider", "Category", "Account", "Connected"],
+      providers.map((p) => [
+        p.slug,
+        p.category,
+        p.accountEmail || "-",
+        new Date(p.connectedAt).toLocaleDateString()
+      ])
+    );
+  } catch (err) {
+    spinner.stop();
+    error(err.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/init.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var import_inquirer2 = __toESM(require("inquirer"));
+var import_chalk3 = __toESM(require("chalk"));
+async function initCommand(name) {
+  console.log();
+  console.log(import_chalk3.default.bold("Create a new Auten agent"));
+  console.log();
+  let projectName = name;
+  let description = "";
+  if (!projectName) {
+    const answers = await import_inquirer2.default.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: "Agent name:",
+        default: "my-agent",
+        validate: (input) => input.trim() ? true : "Name is required"
+      },
+      {
+        type: "input",
+        name: "description",
+        message: "Description (optional):"
+      }
+    ]);
+    projectName = answers.name;
+    description = answers.description;
+  }
+  const dir = path2.resolve(projectName);
+  if (fs2.existsSync(dir)) {
+    error(`Directory "${projectName}" already exists`);
+    process.exit(1);
+  }
+  fs2.mkdirSync(dir, { recursive: true });
+  fs2.mkdirSync(path2.join(dir, "tools"));
+  const config = {
+    name: projectName,
+    description,
+    tools: ["example-tool"],
+    schedule: {
+      cron: "0 9 * * *",
+      timezone: "UTC"
+    },
+    providers: []
+  };
+  fs2.writeFileSync(
+    path2.join(dir, "auten.config.json"),
+    JSON.stringify(config, null, 2)
+  );
+  const exampleTool = `/**
+ * Example Auten agent tool
+ *
+ * Available globals:
+ *   Auth.getToken(provider)  \u2014 Get OAuth token (auto-refreshed)
+ *   HTTP.get/post/put/delete \u2014 HTTP requests
+ *   AI.call(prompt)          \u2014 LLM text response
+ *   AI.json(prompt)          \u2014 LLM JSON response
+ *   Knowledge.get/set        \u2014 Read/write persistent data
+ *   log(message, data)       \u2014 Logging
+ */
+
+const { spec, previousResults } = __context__;
+
+log('Hello from example-tool!');
+
+// Example: fetch data from a provider
+// const { accessToken } = await Auth.getToken('google-gmail');
+// const emails = await HTTP.get('https://gmail.googleapis.com/gmail/v1/users/me/messages?maxResults=5', {
+//   headers: { Authorization: 'Bearer ' + accessToken }
+// });
+
+// Example: use AI to analyze data
+// const analysis = await AI.json(\`
+//   Analyze this data: \${JSON.stringify(data)}
+//   Return: { summary: string, action: string }
+// \`);
+
+return { success: true, message: 'Example tool executed' };
+`;
+  fs2.writeFileSync(path2.join(dir, "tools", "example-tool.js"), exampleTool);
+  const packageJson = {
+    name: projectName,
+    version: "1.0.0",
+    private: true,
+    description: description || `Auten.ai agent: ${projectName}`,
+    scripts: {
+      deploy: "auten agent deploy",
+      run: "auten agent run --once"
+    },
+    dependencies: {
+      "@autenai/sdk": "^0.1.0"
+    }
+  };
+  fs2.writeFileSync(
+    path2.join(dir, "package.json"),
+    JSON.stringify(packageJson, null, 2)
+  );
+  fs2.writeFileSync(path2.join(dir, ".gitignore"), "node_modules/\n.env\ndata/\n");
+  fs2.writeFileSync(
+    path2.join(dir, ".env.example"),
+    "# Your Auten API key (get at https://auten.ai/settings \u2192 API Keys)\nAUTEN_API_KEY=\n"
+  );
+  console.log();
+  success(`Agent project created: ${import_chalk3.default.bold(projectName)}/`);
+  console.log();
+  info("Project structure:");
+  console.log(`  ${import_chalk3.default.dim(projectName + "/")}`);
+  console.log(`  \u251C\u2500\u2500 auten.config.json    ${import_chalk3.default.dim("Agent configuration")}`);
+  console.log(`  \u251C\u2500\u2500 package.json`);
+  console.log(`  \u251C\u2500\u2500 .env.example`);
+  console.log(`  \u2514\u2500\u2500 tools/`);
+  console.log(`      \u2514\u2500\u2500 example-tool.js  ${import_chalk3.default.dim("Your first tool")}`);
+  console.log();
+  info("Next steps:");
+  console.log(`  1. ${import_chalk3.default.cyan("cd " + projectName)}`);
+  console.log(`  2. Edit ${import_chalk3.default.cyan("tools/example-tool.js")}`);
+  console.log(`  3. ${import_chalk3.default.cyan("auten agent deploy")} to deploy`);
+  console.log(`  4. ${import_chalk3.default.cyan("auten agent run --once")} to test`);
+}
+
+// src/commands/agent.ts
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var import_ora3 = __toESM(require("ora"));
+var import_chalk4 = __toESM(require("chalk"));
+var import_sdk3 = require("@autenai/sdk");
+function requireAuth2() {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    error("Not logged in. Run: auten login");
+    process.exit(1);
+  }
+  return new import_sdk3.Auten({ apiKey, baseUrl: getBaseUrl() });
+}
+function readAgentConfig() {
+  const configPath = path3.resolve("auten.config.json");
+  if (!fs3.existsSync(configPath)) {
+    error("No auten.config.json found. Run: auten init");
+    process.exit(1);
+  }
+  return JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+}
+function writeAgentConfig(config) {
+  fs3.writeFileSync(
+    path3.resolve("auten.config.json"),
+    JSON.stringify(config, null, 2)
+  );
+}
+async function agentListCommand() {
+  const auten = requireAuth2();
+  const spinner = (0, import_ora3.default)("Fetching agents...").start();
+  try {
+    const agents = await auten.agents.list();
+    spinner.stop();
+    if (agents.length === 0) {
+      header("My Agents");
+      info("No agents yet. Run: auten init my-agent");
+      return;
+    }
+    header(`My Agents (${agents.length})`);
+    table(
+      ["ID", "Name", "Status", "Schedule"],
+      agents.map((a) => [
+        a.id.substring(0, 12) + "...",
+        a.name,
+        a.status,
+        a.schedule?.cron || "-"
+      ])
+    );
+  } catch (err) {
+    spinner.stop();
+    error(err.message);
+    process.exit(1);
+  }
+}
+async function agentDeployCommand() {
+  const auten = requireAuth2();
+  const config = readAgentConfig();
+  const toolsDir = path3.resolve("tools");
+  if (!fs3.existsSync(toolsDir)) {
+    error("No tools/ directory found");
+    process.exit(1);
+  }
+  const tools = [];
+  for (const toolName of config.tools) {
+    const toolPath = path3.join(toolsDir, `${toolName}.js`);
+    if (!fs3.existsSync(toolPath)) {
+      warn(`Tool file not found: tools/${toolName}.js \u2014 skipping`);
+      continue;
+    }
+    const code = fs3.readFileSync(toolPath, "utf-8");
+    tools.push({ name: toolName, code });
+  }
+  if (tools.length === 0) {
+    error("No tools to deploy");
+    process.exit(1);
+  }
+  const spinner = (0, import_ora3.default)(`Deploying ${tools.length} tool(s)...`).start();
+  try {
+    if (config.agentId) {
+      const result = await auten.agents.deploy(config.agentId, {
+        tools,
+        schedule: config.schedule
+      });
+      spinner.stop();
+      success(`Deployed to agent ${import_chalk4.default.bold(config.agentId.substring(0, 12))}...`);
+      info(`Tools: ${result.tools.join(", ")}`);
+    } else {
+      const result = await auten.agents.create({
+        name: config.name,
+        description: config.description,
+        tools,
+        schedule: config.schedule
+      });
+      config.agentId = result.id;
+      writeAgentConfig(config);
+      spinner.stop();
+      success(`Agent created: ${import_chalk4.default.bold(result.id)}`);
+      info(`Tools: ${tools.map((t) => t.name).join(", ")}`);
+      info(`Status: ${result.status}`);
+    }
+  } catch (err) {
+    spinner.stop();
+    error(err.message);
+    process.exit(1);
+  }
+}
+async function agentRunCommand(options) {
+  const auten = requireAuth2();
+  const config = readAgentConfig();
+  if (!config.agentId) {
+    error("Agent not deployed yet. Run: auten agent deploy");
+    process.exit(1);
+  }
+  const spinner = (0, import_ora3.default)("Triggering agent run...").start();
+  try {
+    const result = await auten.agents.run(config.agentId);
+    spinner.stop();
+    success(`Agent run triggered`);
+    info(`Execution ID: ${result.executionId || "started"}`);
+    info(`Status: ${result.status || "running"}`);
+    if (options.once) {
+      info("Waiting for completion...");
+      let status = "running";
+      while (status === "running") {
+        await new Promise((r) => setTimeout(r, 3e3));
+        const agentStatus = await auten.agents.status(config.agentId);
+        status = agentStatus.status;
+        process.stdout.write(".");
+      }
+      console.log();
+      success(`Run complete: ${status}`);
+    }
+  } catch (err) {
+    spinner.stop();
+    error(err.message);
+    process.exit(1);
+  }
+}
+async function agentStatusCommand(id) {
+  const auten = requireAuth2();
+  const agentId = id || readAgentConfig().agentId;
+  if (!agentId) {
+    error("No agent ID. Deploy first or provide ID: auten agent status <id>");
+    process.exit(1);
+  }
+  const spinner = (0, import_ora3.default)("Fetching status...").start();
+  try {
+    const agent = await auten.agents.get(agentId);
+    spinner.stop();
+    header(agent.name);
+    console.log(`  Status:    ${import_chalk4.default.bold(agent.status)}`);
+    console.log(`  Tools:     ${agent.tools.map((t) => t.name).join(", ")}`);
+    if (agent.schedule) {
+      console.log(`  Schedule:  ${agent.schedule.cron} (${agent.schedule.timezone})`);
+      console.log(`  Enabled:   ${agent.schedule.enabled ? import_chalk4.default.green("yes") : import_chalk4.default.red("no")}`);
+    }
+    console.log(`  Created:   ${new Date(agent.createdAt).toLocaleString()}`);
+    console.log(`  Updated:   ${new Date(agent.updatedAt).toLocaleString()}`);
+  } catch (err) {
+    spinner.stop();
+    error(err.message);
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new import_commander.Command();
+program.name("auten").description("Auten.ai CLI \u2014 build and deploy AI agents").version("0.1.0");
+program.command("login").description("Authenticate with your Auten.ai API key").action(loginCommand);
+var providersCmd = program.command("providers").description("Manage provider connections");
+providersCmd.command("list").description("List connected providers").action(providersListCommand);
+program.command("init [name]").description("Create a new agent project").action(initCommand);
+var agentCmd = program.command("agent").description("Manage agents");
+agentCmd.command("list").description("List your agents").action(agentListCommand);
+agentCmd.command("deploy").description("Deploy agent from current directory").action(agentDeployCommand);
+agentCmd.command("run").description("Trigger agent execution").option("--once", "Wait for completion").action(agentRunCommand);
+agentCmd.command("status [id]").description("Show agent status").action(agentStatusCommand);
+program.parse();

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@autenai/cli",
+  "version": "0.1.0",
+  "description": "Auten.ai CLI — build and deploy AI agents from your terminal",
+  "main": "./dist/index.js",
+  "bin": {
+    "auten": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs --target node18 --clean",
+    "dev": "tsup src/index.ts --format cjs --target node18 --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "auten",
+    "ai",
+    "agents",
+    "automation",
+    "cli"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@autenai/sdk": "^0.1.0",
+    "commander": "^12.0.0",
+    "chalk": "^4.1.2",
+    "ora": "^5.4.1",
+    "inquirer": "^8.2.6"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}