@co-engram/openclaw 0.1.0

package/scripts/setup.mjs

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+/**
+ * Co-Engram OpenClaw plugin 一键 setup
+ *
+ * 行为(idempotent,可重复跑):
+ *   1. 读取 ~/.openclaw/openclaw.json(不存在则报错并指引 `openclaw onboard`)
+ *   2. 在 plugins.entries.co-engram.config 下 merge 推荐默认值
+ *      - 保留用户已显式设置的字段
+ *      - 仅在缺失时填入推荐值
+ *   3. 把 memory exclusive slot 设为 "co-engram"(自动让 memory-core 失效)
+ *   4. 备份原文件到 <path>.bak.<timestamp>
+ *   5. 默认 dry-run,需 --yes 才落盘;--restart 顺带 openclaw gateway restart
+ *
+ * 用法:
+ *   pnpm --filter @co-engram/openclaw setup              # dry-run,只打印 diff
+ *   pnpm --filter @co-engram/openclaw setup --yes        # 落盘
+ *   pnpm --filter @co-engram/openclaw setup --yes --restart  # 落盘 + 重启
+ *   npx @co-engram/openclaw setup --yes --restart        # 通过 bin
+ *
+ * @module @co-engram/openclaw/scripts/setup
+ */
+import { readFileSync, writeFileSync, existsSync, copyFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import process from "node:process";
+
+const OPENCLAW_CONFIG_PATH = join(homedir(), ".openclaw", "openclaw.json");
+
+/** 推荐默认配置(仅在用户未显式设置时写入) */
+const RECOMMENDED_CONFIG = {
+  language: "zh",
+  startMaintenance: true,
+  startViewer: true,
+  auditEnabled: true,
+};
+
+const PLUGIN_ID = "co-engram";
+
+function parseArgs(argv) {
+  const flags = {
+    yes: false,
+    restart: false,
+    configPath: OPENCLAW_CONFIG_PATH,
+  };
+  for (const arg of argv.slice(2)) {
+    if (arg === "--yes" || arg === "-y") flags.yes = true;
+    else if (arg === "--restart") flags.restart = true;
+    else if (arg.startsWith("--config="))
+      flags.configPath = arg.slice("--config=".length);
+    else if (arg === "--help" || arg === "-h") {
+      printHelp();
+      process.exit(0);
+    }
+  }
+  return flags;
+}
+
+function printHelp() {
+  process.stdout.write(`co-engram openclaw setup
+
+Usage:
+  co-engram-openclaw-setup [options]
+
+Options:
+  --yes, -y        Apply changes (default: dry-run, only print diff)
+  --restart        Run \`openclaw gateway restart\` after applying
+  --config=<path>  Override openclaw.json path (default: ~/.openclaw/openclaw.json)
+  --help, -h       Show this help
+
+Recommended config written to plugins.entries.co-engram.config (only when missing):
+${JSON.stringify(RECOMMENDED_CONFIG, null, 2)
+  .split("\n")
+  .map((l) => "  " + l)
+  .join("\n")}
+`);
+}
+
+function readConfig(path) {
+  if (!existsSync(path)) {
+    process.stderr.write(`[setup] Config not found: ${path}\n`);
+    process.stderr.write(
+      `[setup] Run \`openclaw onboard\` first to initialize OpenClaw.\n`,
+    );
+    process.exit(1);
+  }
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+
+function deepMergeMissing(target, defaults) {
+  const applied = {};
+  for (const [k, v] of Object.entries(defaults)) {
+    if (target[k] === undefined) {
+      target[k] = v;
+      applied[k] = { from: undefined, to: v };
+    }
+    // 已存在的值保留不动(包括 false / 0 / '')
+  }
+  return applied;
+}
+
+function applyChanges(config) {
+  config.plugins ??= {};
+  config.plugins.entries ??= {};
+  config.plugins.slots ??= {};
+
+  const entry = (config.plugins.entries[PLUGIN_ID] ??= { enabled: true });
+  entry.enabled = entry.enabled !== false; // 默认 true,但保留显式 false
+  const userConfig = (entry.config ??= {});
+
+  const applied = deepMergeMissing(userConfig, RECOMMENDED_CONFIG);
+
+  // memory exclusive slot → co-engram(让 memory-core 自动 disable)
+  let slotChanged = false;
+  if (config.plugins.slots.memory !== PLUGIN_ID) {
+    slotChanged = {
+      from: config.plugins.slots.memory,
+      to: PLUGIN_ID,
+    };
+    config.plugins.slots.memory = PLUGIN_ID;
+  }
+
+  return { applied, slotChanged };
+}
+
+function findOpenclawCli() {
+  // 优先找 co-claw bundled CLI
+  const candidates = [
+    "/opt/Co-Claw/resources/app-data/coclaw/openclaw.mjs",
+    process.env.HOME + "/.coclaw/nodejs/bin/node", // 备用 node
+  ];
+  for (const c of candidates) {
+    if (existsSync(c)) return c;
+  }
+  return null;
+}
+
+function restartGateway() {
+  const cli = findOpenclawCli();
+  if (!cli) {
+    process.stderr.write(`[setup] openclaw CLI not found; skip restart\n`);
+    return false;
+  }
+  process.stdout.write(`[setup] Restarting gateway via ${cli}\n`);
+  const result = spawnSync("node", [cli, "gateway", "restart"], {
+    stdio: "inherit",
+    timeout: 30000,
+  });
+  return result.status === 0;
+}
+
+function main() {
+  const flags = parseArgs(process.argv);
+  const config = readConfig(flags.configPath);
+  const before = JSON.stringify(config, null, 2);
+  const { applied, slotChanged } = applyChanges(config);
+  const after = JSON.stringify(config, null, 2);
+  const changed = Object.keys(applied).length > 0 || slotChanged;
+
+  if (!changed) {
+    process.stdout.write(`[setup] Already up to date: ${flags.configPath}\n`);
+    if (flags.restart) restartGateway();
+    return;
+  }
+
+  process.stdout.write(`[setup] Planned changes to ${flags.configPath}:\n`);
+  for (const [k, v] of Object.entries(applied)) {
+    process.stdout.write(
+      `  plugins.entries.${PLUGIN_ID}.config.${k}: <missing> → ${JSON.stringify(v.to)}\n`,
+    );
+  }
+  if (slotChanged) {
+    process.stdout.write(
+      `  plugins.slots.memory: ${JSON.stringify(slotChanged.from)} → ${JSON.stringify(slotChanged.to)}\n`,
+    );
+  }
+
+  if (!flags.yes) {
+    process.stdout.write(
+      `\n[setup] Dry-run only. Re-run with --yes to apply.\n`,
+    );
+    return;
+  }
+
+  const ts = new Date().toISOString().replace(/[:.]/g, "-");
+  const backup = `${flags.configPath}.bak.${ts}`;
+  copyFileSync(flags.configPath, backup);
+  process.stdout.write(`[setup] Backup: ${backup}\n`);
+
+  writeFileSync(flags.configPath, after + "\n", "utf8");
+  process.stdout.write(`[setup] Applied: ${flags.configPath}\n`);
+
+  syncWorkspaceDeps();
+
+  if (flags.restart) {
+    restartGateway();
+  } else {
+    process.stdout.write(
+      `\n[setup] Run \`openclaw gateway restart\` to load the new config.\n`,
+    );
+  }
+}
+
+/**
+ * 调用同目录的 sync-deps.mjs,把 workspace 依赖从 pnpm symlink 替换为实拷贝
+ *
+ * 失败不抛错,只 stderr 提示——setup 仍算成功(用户可能从已发布 npm tarball 安装,
+ * 此时无 symlink 需要处理)。
+ */
+function syncWorkspaceDeps() {
+  const scriptPath = join(
+    dirname(fileURLToPath(import.meta.url)),
+    "sync-deps.mjs",
+  );
+  if (!existsSync(scriptPath)) {
+    process.stderr.write(
+      `[setup] sync-deps.mjs not found at ${scriptPath}; skipping workspace dep sync\n`,
+    );
+    return false;
+  }
+  process.stdout.write(
+    `[setup] Syncing workspace deps (pnpm symlink → real copy)\n`,
+  );
+  const result = spawnSync("node", [scriptPath], {
+    stdio: "inherit",
+    timeout: 60000,
+  });
+  return result.status === 0;
+}
+
+main();

package/scripts/sync-deps.mjs

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+/**
+ * 把 openclaw-plugin 的 workspace 依赖从 pnpm symlink 替换为实际拷贝。
+ *
+ * 背景:openclaw 安装插件时会扫描 node_modules,拒绝包含指向 install root 外的
+ * symlink(`manifest dependency scan found node_modules symlink target outside
+ * install root`)。pnpm workspace 默认用 symlink,所以需要这一步把
+ * @co-engram/core / @co-engram/viewer / yaml / zod / ulid 等运行时依赖"实拷贝"。
+ *
+ * 行为(idempotent,可重复跑):
+ *   1. 对每个目标包:resolve 真实位置(createRequire + require.resolve)
+ *   2. 删除 openclaw-plugin/node_modules/<pkg> 当前内容(可能是 symlink)
+ *   3. fs.cpSync 真实位置 → node_modules/<pkg>(排除嵌套 node_modules / .git / 测试文件)
+ *   4. 删除拷贝结果中的嵌套 node_modules(避免 openclaw 扫描器递归解析)
+ *
+ * 用法:
+ *   pnpm --filter @co-engram/openclaw sync-deps        # 标准用法
+ *   node ./scripts/sync-deps.mjs --check               # 只检查,不修改
+ *   node ./scripts/sync-deps.mjs --force               # 强制重做(即使已是实拷贝)
+ *
+ * @module @co-engram/openclaw/scripts/sync-deps
+ */
+import { createRequire } from "node:module";
+import {
+  cpSync,
+  existsSync,
+  lstatSync,
+  readdirSync,
+  readFileSync,
+  readlinkSync,
+  rmSync,
+  statSync,
+} from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PKG_ROOT = resolve(__dirname, "..");
+const NM = resolve(PKG_ROOT, "node_modules");
+
+/** 需要实拷贝的运行时依赖(直接 + 传递) */
+const TARGETS = ["@co-engram/core", "@co-engram/viewer", "yaml", "zod", "ulid"];
+
+/** 拷贝时跳过的目录名 */
+const SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  ".cache",
+  "test",
+  "tests",
+  "__tests__",
+  ".tshy",
+  ".tshy-build",
+]);
+
+/** 拷贝时跳过的文件后缀 */
+const SKIP_SUFFIXES = [
+  ".test.ts",
+  ".test.js",
+  ".test.d.ts",
+  ".spec.ts",
+  ".spec.js",
+  ".tsbuildinfo",
+  ".map",
+];
+
+function parseArgs(argv) {
+  const flags = { check: false, force: false };
+  for (const arg of argv.slice(2)) {
+    if (arg === "--check") flags.check = true;
+    else if (arg === "--force") flags.force = true;
+    else if (arg === "--help" || arg === "-h") {
+      process.stdout.write(`co-engram openclaw sync-deps
+
+Usage:
+  sync-deps [options]
+
+Options:
+  --check   Only print current state, do not modify anything
+  --force   Re-copy even if target is already a real directory
+  --help    Show this help
+
+Targets (copied from pnpm symlink → real files):
+${TARGETS.map((t) => `  - ${t}`).join("\n")}
+`);
+      process.exit(0);
+    }
+  }
+  return flags;
+}
+
+/** 通过读 node_modules/<pkg>/package.json 找到包根目录(穿透 pnpm symlink) */
+function resolvePackageRoot(pkgName) {
+  const directPath = join(NM, pkgName);
+  if (!existsSync(directPath)) return null;
+
+  // 处理 symlink 情况:readlinksync 取 target
+  const stat = lstatSync(directPath);
+  let realPath;
+  if (stat.isSymbolicLink()) {
+    realPath = readlinkSync(directPath);
+    // 相对 symlink:相对于 symlink 父目录解析
+    if (!realPath.startsWith("/")) {
+      realPath = resolve(dirname(directPath), realPath);
+    }
+  } else {
+    // 已经是实拷贝,直接用
+    realPath = directPath;
+  }
+
+  // 验证 realPath 下有 package.json 且 name 匹配
+  const pkgJsonPath = join(realPath, "package.json");
+  if (!existsSync(pkgJsonPath)) return null;
+  try {
+    const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+    if (pkg.name === pkgName) return realPath;
+  } catch {}
+  return null;
+}
+
+/** 判断 node_modules/<pkg> 当前是否已经是实拷贝(非 symlink 且非空) */
+function isRealCopy(pkgName) {
+  const target = join(NM, pkgName);
+  if (!existsSync(target)) return false;
+  const stat = lstatSync(target);
+  return stat.isDirectory() && !stat.isSymbolicLink();
+}
+
+/** 过滤掉测试文件和构建缓存 */
+function filterCopy(src, dest) {
+  const base = src.split("/").pop();
+  if (SKIP_DIRS.has(base)) return false;
+  for (const suf of SKIP_SUFFIXES) {
+    if (src.endsWith(suf)) return false;
+  }
+  return true;
+}
+
+/** 拷贝后清理嵌套 node_modules(.pnpm 有时通过 dependencies 嵌入) */
+function cleanNestedNodeModules(rootPath) {
+  if (!existsSync(rootPath)) return;
+  const stack = [rootPath];
+  while (stack.length > 0) {
+    const cur = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(cur, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const ent of entries) {
+      if (ent.name === "node_modules" && ent.isDirectory()) {
+        const nested = join(cur, ent.name);
+        rmSync(nested, { recursive: true, force: true });
+        process.stdout.write(
+          `    cleaned nested: ${relative(PKG_ROOT, nested)}\n`,
+        );
+        continue;
+      }
+      if (ent.isDirectory()) {
+        stack.push(join(cur, ent.name));
+      }
+    }
+  }
+}
+
+function syncOne(pkgName, { check, force }) {
+  const target = join(NM, pkgName);
+  const status = { pkg: pkgName, action: "noop", reason: "" };
+
+  const realPath = resolvePackageRoot(pkgName);
+  if (!realPath) {
+    status.action = "skip";
+    status.reason = "cannot resolve (not installed?)";
+    return status;
+  }
+
+  if (check) {
+    status.action = isRealCopy(pkgName) ? "real-copy" : "symlink-or-missing";
+    status.reason = `real=${realPath}`;
+    return status;
+  }
+
+  if (isRealCopy(pkgName)) {
+    // 已经是实拷贝:无需重做。
+    // --force 对实拷贝无效,因为 resolvePackageRoot 返回的 realPath 就是 target 自身,
+    // rm 后 cp 会 ENOENT。若需重做,先 `pnpm install` 恢复 symlink 再 sync。
+    status.action = "noop";
+    status.reason = force
+      ? "already real-copy (force-noop; run `pnpm install` first to redo)"
+      : "already real-copy";
+    return status;
+  }
+
+  // 删除现有(symlink 或目录)
+  if (existsSync(target)) {
+    rmSync(target, { recursive: true, force: true });
+  }
+
+  // 实拷贝
+  cpSync(realPath, target, {
+    recursive: true,
+    filter: filterCopy,
+    dereference: true,
+  });
+  // 清理嵌套 node_modules
+  cleanNestedNodeModules(target);
+
+  status.action = "copied";
+  status.reason = `from ${relative(PKG_ROOT, realPath)}`;
+  return status;
+}
+
+function main() {
+  const flags = parseArgs(process.argv);
+  process.stdout.write(
+    `[sync-deps] mode=${flags.check ? "check" : flags.force ? "force" : "sync"} pkg=${PKG_ROOT}\n`,
+  );
+  let copied = 0;
+  let skipped = 0;
+  let failed = 0;
+  for (const pkg of TARGETS) {
+    const r = syncOne(pkg, flags);
+    const tag =
+      r.action === "copied"
+        ? "✓"
+        : r.action === "real-copy"
+          ? "="
+          : r.action === "symlink-or-missing"
+            ? "!"
+            : r.action === "skip"
+              ? "x"
+              : "-";
+    process.stdout.write(
+      `  ${tag} ${pkg.padEnd(20)} ${r.action}  ${r.reason}\n`,
+    );
+    if (r.action === "copied") copied++;
+    else if (r.action === "skip") failed++;
+    else if (r.action === "symlink-or-missing") skipped++;
+  }
+  process.stdout.write(
+    `[sync-deps] done: ${copied} copied, ${skipped} symlink-or-missing, ${failed} skip\n`,
+  );
+}
+
+main();