@openagents-org/agent-launcher 0.1.0

package/src/env.js

@@ -0,0 +1,111 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Manages ~/.openagents/env/<type>.env files and resolve_env rules.
+ *
+ * Env files use key=value format (one per line, # for comments).
+ * resolve_env maps generic LLM_* vars to provider-specific vars
+ * (e.g. LLM_API_KEY → OPENAI_API_KEY or ANTHROPIC_API_KEY).
+ */
+class EnvManager {
+  constructor(configDir) {
+    this.envDir = path.join(configDir, 'env');
+  }
+
+  /**
+   * Load env vars from ~/.openagents/env/<agentType>.env
+   */
+  load(agentType) {
+    const envFile = path.join(this.envDir, `${agentType}.env`);
+    const env = {};
+    try {
+      if (!fs.existsSync(envFile)) return env;
+      const lines = fs.readFileSync(envFile, 'utf-8').split('\n');
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#') || !trimmed.includes('=')) continue;
+        const idx = trimmed.indexOf('=');
+        const key = trimmed.slice(0, idx).trim();
+        const val = trimmed.slice(idx + 1).trim();
+        if (key) env[key] = val;
+      }
+    } catch {}
+    return env;
+  }
+
+  /**
+   * Save env vars to ~/.openagents/env/<agentType>.env
+   * Merges with existing values (new values override).
+   */
+  save(agentType, env) {
+    fs.mkdirSync(this.envDir, { recursive: true });
+    const envFile = path.join(this.envDir, `${agentType}.env`);
+    const existing = this.load(agentType);
+    const merged = { ...existing, ...env };
+    const lines = Object.entries(merged)
+      .filter(([, v]) => v !== null && v !== undefined && v !== '')
+      .map(([k, v]) => `${k}=${v}`);
+    fs.writeFileSync(envFile, lines.join('\n') + '\n', 'utf-8');
+  }
+
+  /**
+   * Delete env file for an agent type.
+   */
+  delete(agentType) {
+    const envFile = path.join(this.envDir, `${agentType}.env`);
+    try { fs.unlinkSync(envFile); } catch {}
+  }
+
+  /**
+   * Apply resolve_env rules to map generic vars to provider-specific vars.
+   *
+   * Rules format (from YAML plugin definition):
+   *   { from: 'LLM_API_KEY', to: 'OPENAI_API_KEY', unless_base_url_contains: 'anthropic' }
+   *   { from: 'LLM_API_KEY', to: 'ANTHROPIC_API_KEY', if_base_url_contains: 'anthropic' }
+   *   { from: 'LLM_BASE_URL', to: 'OPENAI_BASE_URL' }
+   *
+   * @param {object} saved - The saved env vars (from the env file)
+   * @param {object[]} rules - The resolve_env rules from the registry
+   * @returns {object} - The resolved env vars (provider-specific)
+   */
+  resolve(agentType, saved, registry) {
+    const rules = registry ? registry.getResolveRules(agentType) : [];
+    if (!rules || rules.length === 0) return saved;
+
+    const resolved = {};
+    const baseUrl = (saved.LLM_BASE_URL || '').toLowerCase();
+
+    for (const rule of rules) {
+      const src = rule.from || '';
+      const dst = rule.to || '';
+      const srcVal = saved[src];
+      if (!srcVal || !dst) continue;
+
+      // Conditional rules based on base URL
+      if (rule.if_base_url_contains) {
+        if (!baseUrl.includes(rule.if_base_url_contains.toLowerCase())) continue;
+      }
+      if (rule.unless_base_url_contains) {
+        if (baseUrl.includes(rule.unless_base_url_contains.toLowerCase())) continue;
+      }
+
+      resolved[dst] = srcVal;
+    }
+
+    return resolved;
+  }
+
+  /**
+   * Get the full effective env for an agent: saved + resolved.
+   */
+  getEffective(agentType, registry) {
+    const saved = this.load(agentType);
+    const resolved = this.resolve(agentType, saved, registry);
+    return { ...saved, ...resolved };
+  }
+}
+
+module.exports = { EnvManager };

package/src/index.js

@@ -0,0 +1,205 @@
+'use strict';
+
+const { Config } = require('./config');
+const { EnvManager } = require('./env');
+const { Registry } = require('./registry');
+const { Installer } = require('./installer');
+const { Daemon } = require('./daemon');
+const { WorkspaceClient } = require('./workspace-client');
+
+/**
+ * Main entry point for the agent-connector library.
+ * Provides agent management, configuration, and lifecycle control.
+ */
+class AgentConnector {
+  constructor(opts = {}) {
+    const configDir = opts.configDir || AgentConnector.defaultConfigDir();
+    this.config = new Config(configDir);
+    this.env = new EnvManager(configDir);
+    this.registry = new Registry(configDir, opts.registryUrl);
+    this.installer = new Installer(this.registry, configDir);
+    this.workspace = new WorkspaceClient(opts.workspaceEndpoint);
+    this._configDir = configDir;
+  }
+
+  static defaultConfigDir() {
+    const os = require('os');
+    const path = require('path');
+    return path.join(os.homedir(), '.openagents');
+  }
+
+  // -- Registry --
+
+  async getCatalog() {
+    const catalog = await this.registry.getCatalog();
+    return catalog.map((entry) => ({
+      ...entry,
+      installed: this.installer.isInstalled(entry.name),
+    }));
+  }
+
+  getEnvFields(agentType) {
+    return this.registry.getEnvFields(agentType);
+  }
+
+  // -- Install / Uninstall --
+
+  async install(agentType) {
+    return this.installer.install(agentType);
+  }
+
+  async uninstall(agentType) {
+    return this.installer.uninstall(agentType);
+  }
+
+  isInstalled(agentType) {
+    return this.installer.isInstalled(agentType);
+  }
+
+  healthCheck(agentType) {
+    return this.installer.healthCheck(agentType);
+  }
+
+  // -- Agent CRUD --
+
+  listAgents() {
+    const agents = this.config.getAgents();
+    const networks = this.config.getNetworks();
+    return agents.map((a) => {
+      const agentEnv = this.env.load(a.type);
+      const network = networks.find((n) => n.slug === a.network || n.id === a.network);
+      return {
+        name: a.name,
+        type: a.type || 'openclaw',
+        role: a.role || 'worker',
+        network: a.network || null,
+        networkName: network ? (network.name || network.slug) : null,
+        path: a.path || null,
+        env: { ...agentEnv, ...(a.env || {}) },
+      };
+    });
+  }
+
+  addAgent({ name, type, role, path }) {
+    this.config.addAgent({ name, type: type || 'openclaw', role: role || 'worker', path });
+    return { success: true };
+  }
+
+  removeAgent(name) {
+    this.config.removeAgent(name);
+    return { success: true };
+  }
+
+  // -- Env config --
+
+  getAgentEnv(agentType) {
+    return this.env.load(agentType);
+  }
+
+  saveAgentEnv(agentType, env) {
+    this.env.save(agentType, env);
+    return { success: true };
+  }
+
+  resolveAgentEnv(agentType, saved) {
+    return this.env.resolve(agentType, saved, this.registry);
+  }
+
+  // -- Workspace --
+
+  listWorkspaces() {
+    return this.config.getNetworks().map((n) => ({
+      id: n.id,
+      slug: n.slug,
+      name: n.name || n.slug,
+      endpoint: n.endpoint || '',
+    }));
+  }
+
+  connectWorkspace(agentName, networkSlug) {
+    this.config.setAgentNetwork(agentName, networkSlug);
+    return { success: true };
+  }
+
+  disconnectWorkspace(agentName) {
+    this.config.setAgentNetwork(agentName, null);
+    return { success: true };
+  }
+
+  // -- Daemon lifecycle --
+
+  /**
+   * Create a Daemon instance for this connector's config.
+   */
+  createDaemon() {
+    return new Daemon(this.config, this.env, this.registry);
+  }
+
+  /**
+   * Start daemon in background (daemonize).
+   */
+  startDaemon(foregroundArgs) {
+    Daemon.daemonize(this._configDir, foregroundArgs);
+  }
+
+  /**
+   * Stop running daemon.
+   */
+  stopDaemon() {
+    return Daemon.stopDaemon(this._configDir);
+  }
+
+  /**
+   * Get daemon PID if running, null otherwise.
+   */
+  getDaemonPid() {
+    return Daemon.readDaemonPid(this._configDir);
+  }
+
+  /**
+   * Get agent status from daemon status file.
+   */
+  getDaemonStatus() {
+    return this.config.getStatus();
+  }
+
+  /**
+   * Send a command to the running daemon via daemon.cmd file.
+   */
+  sendDaemonCommand(cmd) {
+    this.config.writeCommand(cmd);
+  }
+
+  /**
+   * Get daemon logs, optionally filtered by agent name.
+   */
+  getLogs(agentName, lines = 200) {
+    return this.config.getLogs(agentName, lines);
+  }
+
+  // -- Workspace API --
+
+  async createWorkspace(opts) {
+    return this.workspace.createWorkspace(opts);
+  }
+
+  async joinWorkspace(agentName, token, opts) {
+    return this.workspace.joinNetwork(agentName, token, opts);
+  }
+
+  async resolveToken(token) {
+    return this.workspace.resolveToken(token);
+  }
+
+  // -- LLM test --
+
+  async testLLM(env) {
+    const { testLLMConnection } = require('./utils');
+    return testLLMConnection(env);
+  }
+}
+
+const adapters = require('./adapters');
+
+const paths = require('./paths');
+module.exports = { AgentConnector, Daemon, WorkspaceClient, adapters, paths };