eacn3 0.1.0

package/scripts/cli.cjs

@@ -0,0 +1,332 @@
+#!/usr/bin/env node
+/**
+ * cli.js — `eacn` CLI entry point
+ * Usage:
+ *   npx eacn setup     — configure OpenClaw native plugin
+ *   npx eacn diagnose  — run diagnostics
+ */
+
+const { spawnSync, execFileSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const PKG_ROOT = path.resolve(__dirname, '..');
+const PLUGIN_ID = 'eacn';
+const EXT_DIR = path.join(os.homedir(), '.openclaw', 'extensions', PLUGIN_ID);
+const CONFIG_PATH = path.join(os.homedir(), '.openclaw', 'openclaw.json');
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+function readJSON(filePath) {
+  try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); }
+  catch (_) { return {}; }
+}
+
+function writeJSON(filePath, obj) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(obj, null, 2) + '\n', 'utf8');
+}
+
+function merge(target, source) {
+  for (const [k, v] of Object.entries(source)) {
+    if (v && typeof v === 'object' && !Array.isArray(v)) {
+      target[k] = merge(target[k] || {}, v);
+    } else {
+      target[k] = v;
+    }
+  }
+  return target;
+}
+
+function copyDirRecursive(src, dst) {
+  fs.mkdirSync(dst, { recursive: true });
+  for (const entry of fs.readdirSync(src)) {
+    const srcPath = path.join(src, entry);
+    const dstPath = path.join(dst, entry);
+    if (fs.statSync(srcPath).isDirectory()) {
+      if (entry === 'node_modules' || entry === '.git') continue;
+      copyDirRecursive(srcPath, dstPath);
+    } else {
+      fs.copyFileSync(srcPath, dstPath);
+    }
+  }
+}
+
+function log(msg) { console.log(`  ${msg}`); }
+function ok(msg)  { console.log(`  ✓ ${msg}`); }
+function fail(msg){ console.log(`  ✗ ${msg}`); }
+
+// ── diagnose ──────────────────────────────────────────────────────────────────
+
+function diagnose() {
+  console.log('\neacn diagnostics\n');
+  let allOk = true;
+
+  function check(label, fn) {
+    try {
+      const result = fn();
+      ok(label + (result ? ` — ${result}` : ''));
+      return true;
+    } catch (e) {
+      fail(label + ` — ${e.message}`);
+      allOk = false;
+      return false;
+    }
+  }
+
+  // 1. Package integrity
+  console.log('── Package ──');
+  check('openclaw.plugin.json', () => {
+    const m = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, 'openclaw.plugin.json'), 'utf8'));
+    return `id=${m.id} v=${m.version}`;
+  });
+  check('dist/index.js', () => {
+    const p = path.join(PKG_ROOT, 'dist', 'index.js');
+    if (!fs.existsSync(p)) throw new Error('not found — run "npm run build"');
+    const stat = fs.statSync(p);
+    return `${(stat.size / 1024).toFixed(1)} KB, modified ${stat.mtime.toISOString().slice(0, 19)}`;
+  });
+  check('dist/server.js', () => {
+    const p = path.join(PKG_ROOT, 'dist', 'server.js');
+    if (!fs.existsSync(p)) throw new Error('not found — run "npm run build"');
+    const stat = fs.statSync(p);
+    return `${(stat.size / 1024).toFixed(1)} KB`;
+  });
+  check('skill files', () => {
+    const dir = path.join(PKG_ROOT, 'skills');
+    if (!fs.existsSync(dir)) throw new Error('skills/ not found');
+    const skills = fs.readdirSync(dir).filter(d => {
+      const skillMd = path.join(dir, d, 'SKILL.md');
+      return fs.existsSync(skillMd);
+    });
+    return `${skills.length} skills (${skills.join(', ')})`;
+  });
+
+  // 2. Binaries
+  console.log('\n── Binaries ──');
+  check('node', () => process.version);
+  check('git', () => {
+    return execFileSync('git', ['--version'], { encoding: 'utf8', timeout: 5000 }).trim();
+  });
+
+  // 3. OpenClaw installation
+  console.log('\n── OpenClaw Integration ──');
+  check('extensions directory', () => {
+    if (!fs.existsSync(EXT_DIR)) throw new Error(`${EXT_DIR} not found — run "npx eacn setup"`);
+    const files = fs.readdirSync(EXT_DIR);
+    return `${files.length} entries in ${EXT_DIR}`;
+  });
+  check('dist/index.js in extensions', () => {
+    const p = path.join(EXT_DIR, 'dist', 'index.js');
+    if (!fs.existsSync(p)) throw new Error('not found — run "npx eacn setup" to copy');
+    return 'exists';
+  });
+  check('openclaw.json plugin entry', () => {
+    if (!fs.existsSync(CONFIG_PATH)) throw new Error(`${CONFIG_PATH} not found`);
+    const config = readJSON(CONFIG_PATH);
+    const entry = config?.plugins?.entries?.[PLUGIN_ID];
+    if (!entry) throw new Error(`no "${PLUGIN_ID}" entry in plugins.entries`);
+    if (!entry.enabled) throw new Error('plugin is disabled');
+    return 'enabled';
+  });
+  check('plugins.allow whitelist', () => {
+    const config = readJSON(CONFIG_PATH);
+    const allow = config?.plugins?.allow;
+    if (!Array.isArray(allow)) throw new Error('plugins.allow is missing or not an array');
+    if (!allow.includes(PLUGIN_ID)) throw new Error(`"${PLUGIN_ID}" not in plugins.allow`);
+    return `[${allow.join(', ')}]`;
+  });
+  check('plugins.installs metadata', () => {
+    const config = readJSON(CONFIG_PATH);
+    const inst = config?.plugins?.installs?.[PLUGIN_ID];
+    if (!inst) throw new Error('no install entry — run "npx eacn setup"');
+    return `source=${inst.source} v=${inst.version} @ ${inst.installedAt}`;
+  });
+  check('skills.entries registration', () => {
+    const config = readJSON(CONFIG_PATH);
+    const skills = config?.skills?.entries;
+    if (!skills) throw new Error('skills.entries missing');
+    const eacnSkills = Object.keys(skills).filter(k => k.startsWith('eacn-') && skills[k]?.enabled);
+    if (eacnSkills.length === 0) throw new Error('no eacn skills enabled');
+    return `${eacnSkills.length} enabled: ${eacnSkills.join(', ')}`;
+  });
+  check('skill files in extensions', () => {
+    const skillsDir = path.join(EXT_DIR, 'skills');
+    if (!fs.existsSync(skillsDir)) throw new Error(`${skillsDir} not found`);
+    const skills = fs.readdirSync(skillsDir).filter(d =>
+      fs.existsSync(path.join(skillsDir, d, 'SKILL.md'))
+    );
+    return `${skills.length} skills: ${skills.join(', ')}`;
+  });
+  check('manifest skill paths resolve', () => {
+    const extManifest = path.join(EXT_DIR, 'openclaw.plugin.json');
+    if (!fs.existsSync(extManifest)) throw new Error('no manifest in extensions');
+    const m = JSON.parse(fs.readFileSync(extManifest, 'utf8'));
+    for (const sp of m.skills || []) {
+      const resolved = path.resolve(EXT_DIR, sp);
+      if (!fs.existsSync(resolved)) throw new Error(`"${sp}" resolves to ${resolved} — not found`);
+    }
+    return (m.skills || []).join(', ');
+  });
+
+  // Summary
+  console.log('');
+  if (allOk) {
+    console.log('  All checks passed.\n');
+  } else {
+    console.log('  Some checks failed. Fix the issues above and re-run:\n');
+    console.log('    npx eacn diagnose\n');
+  }
+
+  return allOk;
+}
+
+// ── setup ─────────────────────────────────────────────────────────────────────
+
+function setupOpenclaw() {
+  console.log('\neacn setup\n');
+
+  // 1. Check dist exists
+  const distSrc = path.join(PKG_ROOT, 'dist', 'index.js');
+  if (!fs.existsSync(distSrc)) {
+    fail('dist/index.js not found — building now...');
+    const build = spawnSync('npm', ['run', 'build'], { cwd: PKG_ROOT, stdio: 'inherit' });
+    if (build.status !== 0) {
+      fail('build failed — cannot continue');
+      process.exit(1);
+    }
+    ok('build succeeded');
+  } else {
+    ok(`dist/index.js exists`);
+  }
+
+  // 2. Copy plugin files
+  log(`copying to ${EXT_DIR} ...`);
+  fs.mkdirSync(EXT_DIR, { recursive: true });
+
+  // Copy dist/
+  copyDirRecursive(path.join(PKG_ROOT, 'dist'), path.join(EXT_DIR, 'dist'));
+  ok('dist/ copied');
+
+  // Copy skills/
+  const skillsSrc = path.join(PKG_ROOT, 'skills');
+  if (fs.existsSync(skillsSrc)) {
+    copyDirRecursive(skillsSrc, path.join(EXT_DIR, 'skills'));
+    ok('skills/ copied');
+  }
+
+  // Copy manifest
+  const manifestSrc = path.join(PKG_ROOT, 'openclaw.plugin.json');
+  if (fs.existsSync(manifestSrc)) {
+    fs.copyFileSync(manifestSrc, path.join(EXT_DIR, 'openclaw.plugin.json'));
+    ok('openclaw.plugin.json copied');
+  }
+
+  // Copy package.json
+  fs.copyFileSync(path.join(PKG_ROOT, 'package.json'), path.join(EXT_DIR, 'package.json'));
+  ok('package.json copied');
+
+  // Copy node_modules/ (runtime dependencies like ws, zod, @modelcontextprotocol/sdk)
+  const nmSrc = path.join(PKG_ROOT, 'node_modules');
+  if (fs.existsSync(nmSrc)) {
+    copyDirRecursive(nmSrc, path.join(EXT_DIR, 'node_modules'));
+    ok('node_modules/ copied');
+  } else {
+    fail('node_modules/ not found — run "npm install" first');
+  }
+
+  // Clean up stale extension directory from previous installs (used wrong name)
+  const staleDir = path.join(os.homedir(), '.openclaw', 'extensions', 'eacn');
+  if (staleDir !== EXT_DIR && fs.existsSync(staleDir)) {
+    fs.rmSync(staleDir, { recursive: true, force: true });
+    ok('removed stale extensions/eacn directory');
+  }
+
+  // 3. Discover skills
+  const skillNames = [];
+  if (fs.existsSync(skillsSrc)) {
+    for (const d of fs.readdirSync(skillsSrc)) {
+      if (fs.existsSync(path.join(skillsSrc, d, 'SKILL.md'))) {
+        skillNames.push(d);
+      }
+    }
+  }
+  ok(`found ${skillNames.length} skills: ${skillNames.join(', ')}`);
+
+  // 4. Update openclaw.json
+  log(`updating ${CONFIG_PATH} ...`);
+  const config = readJSON(CONFIG_PATH);
+  const pkg = readJSON(path.join(PKG_ROOT, 'package.json'));
+
+  // plugins — clean stale "eacn" entries from previous installs
+  if (!config.plugins) config.plugins = {};
+  if (!Array.isArray(config.plugins.allow)) config.plugins.allow = [];
+  config.plugins.allow = config.plugins.allow.filter(id => id !== 'eacn');
+  if (config.plugins.entries) delete config.plugins.entries['eacn'];
+  if (config.plugins.installs) delete config.plugins.installs['eacn'];
+
+  // plugins.allow
+  if (!config.plugins.allow.includes(PLUGIN_ID)) {
+    config.plugins.allow.push(PLUGIN_ID);
+  }
+  ok(`plugins.allow: ${PLUGIN_ID} added`);
+
+  // plugins.entries
+  merge(config, {
+    plugins: { entries: { [PLUGIN_ID]: { enabled: true, config: {} } } }
+  });
+  ok(`plugins.entries: ${PLUGIN_ID} enabled`);
+
+  // plugins.installs
+  if (!config.plugins.installs) config.plugins.installs = {};
+  config.plugins.installs[PLUGIN_ID] = {
+    source: 'path',
+    sourcePath: PKG_ROOT,
+    installPath: EXT_DIR,
+    version: pkg.version || '0.1.0',
+    installedAt: new Date().toISOString()
+  };
+  ok('plugins.installs: metadata recorded');
+
+  // skills.entries
+  if (!config.skills) config.skills = {};
+  if (!config.skills.entries) config.skills.entries = {};
+  for (const skill of skillNames) {
+    config.skills.entries[skill] = { enabled: true };
+  }
+  ok(`skills.entries: ${skillNames.join(', ')} registered`);
+
+  writeJSON(CONFIG_PATH, config);
+  ok('openclaw.json written');
+
+  // 5. Verify
+  console.log('\n── Verification ──');
+  const verified = diagnose();
+
+  if (verified) {
+    console.log('Setup complete. Run: openclaw gateway restart\n');
+  } else {
+    console.log('Setup finished with warnings — check above.\n');
+  }
+}
+
+// ── main ──────────────────────────────────────────────────────────────────────
+
+const cmd = process.argv[2];
+
+switch (cmd) {
+  case 'setup':
+    setupOpenclaw();
+    break;
+  case 'diagnose':
+  case 'diag':
+  case 'doctor':
+    diagnose();
+    break;
+  default:
+    console.log('Usage:');
+    console.log('  npx eacn setup     — install plugin into OpenClaw');
+    console.log('  npx eacn diagnose  — run full diagnostics');
+    process.exit(0);
+}

package/scripts/postinstall.cjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * postinstall.js — verify installation and report status
+ */
+
+const { execFileSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const PKG_ROOT = path.resolve(__dirname, '..');
+
+function check(label, fn) {
+  try {
+    const result = fn();
+    console.log(`  ✓ ${label}` + (result ? ` — ${result}` : ''));
+    return true;
+  } catch (e) {
+    console.log(`  ✗ ${label} — ${e.message}`);
+    return false;
+  }
+}
+
+console.log('\neacn postinstall\n');
+
+let ok = true;
+
+ok = check('plugin manifest', () => {
+  const manifest = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, 'openclaw.plugin.json'), 'utf8'));
+  return `id=${manifest.id} v${manifest.version}`;
+}) && ok;
+
+ok = check('dist/index.js', () => {
+  const p = path.join(PKG_ROOT, 'dist', 'index.js');
+  if (!fs.existsSync(p)) throw new Error('not found — run "npm run build" first');
+  return 'exists';
+}) && ok;
+
+ok = check('dist/server.js', () => {
+  const p = path.join(PKG_ROOT, 'dist', 'server.js');
+  if (!fs.existsSync(p)) throw new Error('not found — run "npm run build" first');
+  return 'exists';
+}) && ok;
+
+ok = check('skill files', () => {
+  const skillsDir = path.join(PKG_ROOT, 'skills');
+  if (!fs.existsSync(skillsDir)) throw new Error('skills/ not found');
+  const skills = fs.readdirSync(skillsDir).filter(d =>
+    fs.statSync(path.join(skillsDir, d)).isDirectory()
+  );
+  return `${skills.length} skills (${skills.join(', ')})`;
+}) && ok;
+
+if (ok) {
+  console.log('\n  All checks passed.\n');
+} else {
+  console.log('\n  Some checks failed — the plugin may not work correctly.');
+  console.log('  Run "npx eacn diagnose" for details.\n');
+}
+
+console.log('Next steps:');
+console.log('  npx eacn setup    — install into OpenClaw');
+console.log('  npx eacn diagnose — run full diagnostics\n');