openclaw-agent-builder 0.0.1

package/server/routes/config.js

@@ -0,0 +1,130 @@
+import { Router } from 'express';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+function expandHome(p) {
+  return p && p.startsWith('~') ? path.join(os.homedir(), p.slice(1)) : (p || '');
+}
+
+const router = Router();
+const CONFIG_PATH = path.join(os.homedir(), '.openclaw', 'openclaw.json');
+
+function readConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeConfig(cfg) {
+  fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), 'utf8');
+}
+
+router.get('/openclaw-config', (_req, res) => {
+  res.json(readConfig());
+});
+
+// GET /api/install-context — detect whether this is a fresh install
+router.get('/install-context', (_req, res) => {
+  const cfg = readConfig();
+  const defaultWsRaw = cfg.agents?.defaults?.workspace || '~/.openclaw/workspace';
+  const defaultWs = expandHome(defaultWsRaw);
+  const soulExists = fs.existsSync(path.join(defaultWs, 'SOUL.md'));
+  const namedAgents = (cfg.agents?.list || []).filter(a => a.workspace);
+  res.json({
+    isFreshInstall: !soulExists,
+    defaultWorkspace: defaultWsRaw,
+    existingAgentCount: namedAgents.length,
+  });
+});
+
+// Resolve the actual workspace path for an agent, respecting existing config.
+// Falls back to ~/.openclaw/workspace-<id> for new agents.
+router.get('/resolve-workspace/:agentId', (req, res) => {
+  const { agentId } = req.params;
+  const cfg = readConfig();
+  const home = os.homedir();
+
+  // Check agents.list for an existing entry with explicit workspace
+  const existing = (cfg.agents?.list || []).find(a => a.id === agentId);
+  if (existing?.workspace) {
+    const resolved = existing.workspace.replace(/^~/, home);
+    return res.json({ workspace: existing.workspace, resolved, existing: true });
+  }
+
+  // If this agent has no explicit workspace, it inherits agents.defaults.workspace
+  // (the default agent pattern — workspace has no -<id> suffix)
+  const defaultWs = cfg.agents?.defaults?.workspace || '~/.openclaw/workspace';
+  const isDefaultAgent = existing && !existing.workspace;
+  if (isDefaultAgent) {
+    const resolved = defaultWs.replace(/^~/, home);
+    return res.json({ workspace: defaultWs, resolved, existing: true, inheritedDefault: true });
+  }
+
+  // New agent — use workspace-<id> convention
+  const workspace = `~/.openclaw/workspace-${agentId}`;
+  res.json({ workspace, resolved: path.join(home, `.openclaw/workspace-${agentId}`), existing: false });
+});
+
+router.patch('/openclaw-config', (req, res) => {
+  try {
+    const { agents: newAgents, bindings: newBindings, defaultAgentId, isMainAgent } = req.body;
+    const cfg = readConfig();
+
+    // Backup first
+    if (fs.existsSync(CONFIG_PATH)) {
+      const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+      fs.copyFileSync(CONFIG_PATH, `${CONFIG_PATH}.bak-${ts}`);
+    }
+
+    if (!isMainAgent) {
+      // Named agent — upsert into agents.list
+      if (!cfg.agents) cfg.agents = {};
+      if (!cfg.agents.list) cfg.agents.list = [];
+
+      if (newAgents && newAgents.list) {
+        for (const newAgent of newAgents.list) {
+          const idx = cfg.agents.list.findIndex(a => a.id === newAgent.id);
+          if (idx >= 0) {
+            if (newAgent.workspace) cfg.agents.list[idx].workspace = newAgent.workspace;
+          } else {
+            cfg.agents.list.push(newAgent);
+          }
+        }
+      }
+
+      // Ensure exactly one default
+      if (defaultAgentId) {
+        for (const agent of cfg.agents.list) {
+          if (agent.default !== undefined) delete agent.default;
+        }
+        const defAgent = cfg.agents.list.find(a => a.id === defaultAgentId);
+        if (defAgent) defAgent.default = true;
+      }
+    }
+    // isMainAgent === true: the main agent already IS the default via agents.defaults —
+    // no agents.list entry needed. Just handle bindings below.
+
+    // Merge bindings (top-level) — prepend new, deduplicate
+    if (!cfg.bindings) cfg.bindings = [];
+    if (newBindings) {
+      for (const nb of newBindings) {
+        const key = nb.agentId + JSON.stringify(nb.match);
+        const exists = cfg.bindings.some(b => b.agentId + JSON.stringify(b.match) === key);
+        if (!exists) {
+          cfg.bindings.unshift(nb);
+        }
+      }
+    }
+
+    writeConfig(cfg);
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+export default router;

package/server/routes/files.js

@@ -0,0 +1,78 @@
+import { Router } from 'express';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const router = Router();
+
+function expandHome(p) {
+  if (p.startsWith('~')) return path.join(os.homedir(), p.slice(1));
+  return p;
+}
+
+function readOpenClawConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(os.homedir(), '.openclaw', 'openclaw.json'), 'utf8'));
+  } catch { return {}; }
+}
+
+function resolveAgentWorkspace(agentId, cfg) {
+  const existing = (cfg.agents?.list || []).find(a => a.id === agentId);
+  if (existing?.workspace) return existing.workspace;
+  // Agent exists but has no explicit workspace — uses agents.defaults.workspace
+  if (existing) return cfg.agents?.defaults?.workspace || '~/.openclaw/workspace';
+  // New agent
+  return `~/.openclaw/workspace-${agentId}`;
+}
+
+router.get('/check-paths', (req, res) => {
+  const agents = (req.query.agents || '').split(',').filter(Boolean);
+  const cfg = readOpenClawConfig();
+  const conflicts = agents.map(agentId => {
+    const ws = resolveAgentWorkspace(agentId, cfg);
+    const p = expandHome(ws);
+    return { agentId, path: p, exists: fs.existsSync(p) };
+  });
+  res.json({ conflicts });
+});
+
+router.post('/write', async (req, res) => {
+  const { files, basePath, force = false } = req.body;
+  const written = [], skipped = [], errors = [];
+
+  for (const file of files) {
+    try {
+      let filePath = file.path;
+      // Resolve relative to basePath or ~/.openclaw
+      if (!path.isAbsolute(filePath)) {
+        const base = basePath ? expandHome(basePath) : expandHome('~/.openclaw');
+        filePath = path.join(base, filePath);
+      } else {
+        filePath = expandHome(filePath);
+      }
+
+      const dir = path.dirname(filePath);
+      fs.mkdirSync(dir, { recursive: true });
+
+      if (fs.existsSync(filePath) && !force) {
+        skipped.push(filePath);
+        continue;
+      }
+
+      if (fs.existsSync(filePath) && force) {
+        const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+        const bakPath = `${filePath}.bak-${ts}`;
+        fs.copyFileSync(filePath, bakPath);
+      }
+
+      fs.writeFileSync(filePath, file.content, 'utf8');
+      written.push(filePath);
+    } catch (err) {
+      errors.push({ path: file.path, error: err.message });
+    }
+  }
+
+  res.json({ written, skipped, errors });
+});
+
+export default router;

package/server/routes/generate.js

@@ -0,0 +1,17 @@
+import { Router } from 'express';
+import { generateFiles } from '../generators/index.js';
+
+const router = Router();
+
+router.post('/', async (req, res) => {
+  try {
+    const { teamSpec } = req.body;
+    if (!teamSpec) return res.status(400).json({ error: 'teamSpec required' });
+    const files = generateFiles(teamSpec);
+    res.json({ files, errors: [] });
+  } catch (err) {
+    res.status(500).json({ error: err.message, files: [], errors: [err.message] });
+  }
+});
+
+export default router;

package/server/routes/preflight.js

@@ -0,0 +1,114 @@
+import { Router } from 'express';
+import { spawn, execSync } from 'child_process';
+import { existsSync } from 'fs';
+import os from 'os';
+import path from 'path';
+
+const router = Router();
+
+// Build an env with extended PATH covering common node/npm install locations
+function extendedEnv() {
+  const home = os.homedir();
+  const extra = [
+    process.env.NVM_BIN,                       // nvm active bin (already in PATH but be explicit)
+    '/usr/local/bin',
+    '/opt/homebrew/bin',
+    '/opt/homebrew/sbin',
+    `${home}/.npm-global/bin`,
+    `${home}/.volta/bin`,
+    `${home}/.fnm/current/bin`,
+    '/usr/bin',
+    '/bin',
+  ].filter(Boolean);
+
+  return {
+    ...process.env,
+    PATH: [...extra, process.env.PATH || ''].join(':'),
+  };
+}
+
+function tryGetVersion(env) {
+  // Try direct command
+  try {
+    return execSync('openclaw --version', { timeout: 5000, shell: true, env }).toString().trim();
+  } catch {}
+
+  // Try resolving via `which` first, then running the resolved path
+  try {
+    const bin = execSync('which openclaw', { timeout: 3000, shell: true, env }).toString().trim();
+    if (bin) return execSync(`"${bin}" --version`, { timeout: 5000 }).toString().trim();
+  } catch {}
+
+  // Try common absolute paths
+  const home = os.homedir();
+  const candidates = [
+    '/usr/local/bin/openclaw',
+    '/opt/homebrew/bin/openclaw',
+    `${home}/.npm-global/bin/openclaw`,
+    `${home}/.volta/bin/openclaw`,
+  ];
+  for (const p of candidates) {
+    if (existsSync(p)) {
+      try { return execSync(`"${p}" --version`, { timeout: 5000 }).toString().trim(); } catch {}
+    }
+  }
+
+  return null;
+}
+
+// Check if openclaw is installed and get its version
+router.get('/preflight', (_req, res) => {
+  const env = extendedEnv();
+  const version = tryGetVersion(env);
+
+  if (version !== null) {
+    return res.json({ installed: true, version });
+  }
+
+  // Fallback: if ~/.openclaw/openclaw.json exists, the CLI is installed even if we can't find it in PATH
+  const configPath = path.join(os.homedir(), '.openclaw', 'openclaw.json');
+  if (existsSync(configPath)) {
+    return res.json({ installed: true, version: '(version unknown)' });
+  }
+
+  res.json({ installed: false, version: null });
+});
+
+// Run npm install -g openclaw and stream output via SSE
+router.post('/preflight/install', (req, res) => {
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+
+  function send(type, data) {
+    res.write(`data: ${JSON.stringify({ type, data })}\n\n`);
+  }
+
+  send('log', 'Running: npm install -g openclaw\n');
+
+  const proc = spawn('npm', ['install', '-g', 'openclaw'], {
+    shell: true,
+    env: extendedEnv(),
+  });
+
+  proc.stdout.on('data', d => send('log', d.toString()));
+  proc.stderr.on('data', d => send('log', d.toString()));
+
+  proc.on('error', err => {
+    send('error', err.message);
+    res.end();
+  });
+
+  proc.on('close', code => {
+    if (code === 0) {
+      const env = extendedEnv();
+      const version = tryGetVersion(env);
+      send('done', version || '(installed)');
+    } else {
+      send('error', `Install exited with code ${code}`);
+    }
+    res.end();
+  });
+});
+
+export default router;

package/server/routes/validate.js

@@ -0,0 +1,30 @@
+import { Router } from 'express';
+import { spawn } from 'child_process';
+
+const router = Router();
+
+router.post('/validate', (_req, res) => {
+  const proc = spawn('openclaw', ['doctor'], { shell: true });
+  let output = '';
+
+  proc.stdout.on('data', d => { output += d.toString(); });
+  proc.stderr.on('data', d => { output += d.toString(); });
+
+  proc.on('error', err => {
+    if (err.code === 'ENOENT') {
+      res.json({
+        exitCode: 127,
+        output: 'openclaw not found in PATH. Install from https://openclaw.ai',
+        passed: false,
+      });
+    } else {
+      res.json({ exitCode: 1, output: err.message, passed: false });
+    }
+  });
+
+  proc.on('close', code => {
+    res.json({ exitCode: code, output, passed: code === 0 });
+  });
+});
+
+export default router;