wispy-cli 1.2.3 → 1.4.0

package/core/migrate.mjs

@@ -0,0 +1,357 @@
+/**
+ * core/migrate.mjs — Migration tool for importing from OpenClaw
+ *
+ * Helps users switch from OpenClaw to Wispy by importing:
+ *   - Memories (MEMORY.md → ~/.wispy/memory/)
+ *   - Workspace files (SOUL.md, USER.md, IDENTITY.md → user-model)
+ *   - Cron jobs (openclaw cron format → wispy cron format)
+ *   - Channel configs (telegram token, etc.)
+ *
+ * SAFE: Read-only from OpenClaw. Copies to Wispy, never modifies OpenClaw.
+ */
+
+import { readFile, writeFile, mkdir, readdir, access, stat } from "node:fs/promises";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+
+const OPENCLAW_DIR = join(homedir(), ".openclaw");
+const OPENCLAW_WORKSPACE = join(OPENCLAW_DIR, "workspace");
+
+export class OpenClawMigrator {
+  constructor(wispyDir) {
+    this.wispyDir = wispyDir;
+    this.report = {
+      detected: false,
+      memories: [],
+      userModel: [],
+      cronJobs: [],
+      channels: [],
+      skipped: [],
+      errors: [],
+    };
+  }
+
+  // ── Detection ─────────────────────────────────────────────────────────────────
+
+  async detect() {
+    try {
+      await access(OPENCLAW_DIR);
+      this.report.detected = true;
+      return true;
+    } catch {
+      this.report.detected = false;
+      return false;
+    }
+  }
+
+  // ── Main migration entry ──────────────────────────────────────────────────────
+
+  /**
+   * Run full migration.
+   * @param {object} opts
+   * @param {boolean} opts.dryRun  — if true, only report what would be migrated
+   * @param {boolean} opts.memoryOnly  — if true, only migrate memories
+   */
+  async migrate(opts = {}) {
+    const { dryRun = false, memoryOnly = false } = opts;
+
+    const detected = await this.detect();
+    if (!detected) {
+      return {
+        success: false,
+        error: `OpenClaw not found at ${OPENCLAW_DIR}`,
+        report: this.report,
+      };
+    }
+
+    // Migrate memories
+    await this._migrateMemories(dryRun);
+
+    if (!memoryOnly) {
+      await this._migrateWorkspaceFiles(dryRun);
+      await this._migrateCronJobs(dryRun);
+      await this._migrateChannels(dryRun);
+    }
+
+    return {
+      success: true,
+      dryRun,
+      report: this.report,
+    };
+  }
+
+  // ── Memory migration ──────────────────────────────────────────────────────────
+
+  async _migrateMemories(dryRun) {
+    const memoryDir = join(this.wispyDir, "memory");
+
+    // Check for MEMORY.md in workspace root
+    const memoryMdPath = join(OPENCLAW_WORKSPACE, "MEMORY.md");
+    try {
+      const content = await readFile(memoryMdPath, "utf8");
+      if (content.trim()) {
+        const dest = join(memoryDir, "openclaw-import.md");
+        if (!dryRun) {
+          await mkdir(memoryDir, { recursive: true });
+          await writeFile(dest, `# Imported from OpenClaw MEMORY.md\n\n${content}`, "utf8");
+        }
+        this.report.memories.push({ source: memoryMdPath, dest, action: "copy" });
+      }
+    } catch { /* No MEMORY.md — skip */ }
+
+    // Check for memory/ subdirectory
+    const openclawMemoryDir = join(OPENCLAW_WORKSPACE, "memory");
+    try {
+      const files = await readdir(openclawMemoryDir);
+      for (const file of files) {
+        if (!file.endsWith(".md") && !file.endsWith(".json")) continue;
+        const src = join(openclawMemoryDir, file);
+        const dest = join(memoryDir, `openclaw-${file}`);
+        try {
+          const content = await readFile(src, "utf8");
+          if (content.trim()) {
+            if (!dryRun) {
+              await mkdir(memoryDir, { recursive: true });
+              await writeFile(dest, content, "utf8");
+            }
+            this.report.memories.push({ source: src, dest, action: "copy" });
+          }
+        } catch (err) {
+          this.report.errors.push(`Memory file ${file}: ${err.message}`);
+        }
+      }
+    } catch { /* No memory directory */ }
+  }
+
+  // ── Workspace files → user model ──────────────────────────────────────────────
+
+  async _migrateWorkspaceFiles(dryRun) {
+    const filesToProcess = [
+      { name: "USER.md", type: "user" },
+      { name: "IDENTITY.md", type: "identity" },
+      { name: "SOUL.md", type: "soul" },
+    ];
+
+    for (const { name, type } of filesToProcess) {
+      const src = join(OPENCLAW_WORKSPACE, name);
+      try {
+        const content = await readFile(src, "utf8");
+        if (!content.trim()) continue;
+
+        // Extract useful info and save to wispy memory
+        const dest = join(this.wispyDir, "memory", `openclaw-${name.toLowerCase()}`);
+        if (!dryRun) {
+          await mkdir(join(this.wispyDir, "memory"), { recursive: true });
+          await writeFile(dest, `# Imported from OpenClaw ${name}\n\n${content}`, "utf8");
+        }
+        this.report.userModel.push({ source: src, dest, type, action: "copy" });
+
+        // Parse USER.md for structured data
+        if (type === "user" && !dryRun) {
+          await this._importUserMd(content);
+        }
+      } catch { /* File doesn't exist, skip */ }
+    }
+  }
+
+  async _importUserMd(content) {
+    // Extract structured fields from USER.md
+    const userModelPath = join(this.wispyDir, "user-model.json");
+
+    let model = {};
+    try {
+      model = JSON.parse(await readFile(userModelPath, "utf8"));
+    } catch {
+      model = { basics: {}, preferences: {}, patterns: { peakHours: [], avgSessionLength: 0, commonTasks: [], totalSessions: 0, totalMessages: 0 } };
+    }
+
+    // Simple regex extraction
+    const nameMatch = content.match(/\*\*Name:\*\*\s*(.+)/);
+    if (nameMatch && !model.basics?.name) {
+      const name = nameMatch[1].replace(/\(.+\)/, "").trim();
+      model.basics = model.basics ?? {};
+      model.basics.name = name;
+    }
+
+    const tzMatch = content.match(/\*\*Timezone:\*\*\s*(.+)/);
+    if (tzMatch) {
+      model.basics = model.basics ?? {};
+      model.basics.timezone = tzMatch[1].trim();
+    }
+
+    // Korean name usually indicates Korean language preference
+    if (content.includes("민서") || content.includes("Korean") || content.toLowerCase().includes("asia/seoul")) {
+      model.preferences = model.preferences ?? {};
+      if (!model.preferences.communicationLanguage) {
+        model.preferences.communicationLanguage = "Korean";
+        model.basics.language = "ko";
+      }
+    }
+
+    // OS hints
+    if (content.includes("MacBook") || content.includes("macOS")) {
+      model.basics = model.basics ?? {};
+      model.basics.os = "macOS";
+    }
+
+    model.updatedAt = new Date().toISOString();
+    await mkdir(this.wispyDir, { recursive: true });
+    await writeFile(userModelPath, JSON.stringify(model, null, 2) + "\n", "utf8");
+  }
+
+  // ── Cron job migration ───────────────────────────────────────────────────────
+
+  async _migrateCronJobs(dryRun) {
+    // OpenClaw cron config locations
+    const candidates = [
+      join(OPENCLAW_DIR, "cron.json"),
+      join(OPENCLAW_DIR, "config", "cron.json"),
+      join(OPENCLAW_WORKSPACE, "cron.json"),
+    ];
+
+    for (const src of candidates) {
+      try {
+        const raw = await readFile(src, "utf8");
+        const openclawCron = JSON.parse(raw);
+
+        // Convert OpenClaw cron format to Wispy cron format
+        const wispyCronPath = join(this.wispyDir, "cron.json");
+        let wispyCron = [];
+        try {
+          wispyCron = JSON.parse(await readFile(wispyCronPath, "utf8"));
+        } catch { /* empty */ }
+
+        const converted = this._convertCronFormat(openclawCron);
+        const toAdd = converted.filter(j =>
+          !wispyCron.some(existing => existing.name === j.name)
+        );
+
+        if (toAdd.length > 0) {
+          if (!dryRun) {
+            await mkdir(this.wispyDir, { recursive: true });
+            await writeFile(wispyCronPath, JSON.stringify([...wispyCron, ...toAdd], null, 2) + "\n", "utf8");
+          }
+          for (const job of toAdd) {
+            this.report.cronJobs.push({ source: src, job: job.name, action: "import" });
+          }
+        }
+        break; // Only process first found
+      } catch { /* Not found or parse error */ }
+    }
+  }
+
+  _convertCronFormat(openclawCron) {
+    // OpenClaw cron is an array of job objects
+    const jobs = Array.isArray(openclawCron) ? openclawCron : (openclawCron.jobs ?? []);
+    return jobs.map(job => ({
+      name: job.name ?? job.id ?? `imported-${Date.now()}`,
+      schedule: job.schedule ?? job.cron ?? "0 9 * * *",
+      prompt: job.prompt ?? job.task ?? job.message ?? "Run imported cron job",
+      enabled: job.enabled !== false,
+      importedFrom: "openclaw",
+    }));
+  }
+
+  // ── Channel config migration ──────────────────────────────────────────────────
+
+  async _migrateChannels(dryRun) {
+    // Look for OpenClaw channel configs
+    const configCandidates = [
+      join(OPENCLAW_DIR, "openclaw.json"),
+      join(OPENCLAW_DIR, "config.json"),
+      join(OPENCLAW_DIR, "config", "openclaw.json"),
+    ];
+
+    for (const src of configCandidates) {
+      try {
+        const raw = await readFile(src, "utf8");
+        const config = JSON.parse(raw);
+
+        const channelsPath = join(this.wispyDir, "channels.json");
+        let wispyChannels = {};
+        try {
+          wispyChannels = JSON.parse(await readFile(channelsPath, "utf8"));
+        } catch { /* empty */ }
+
+        // Extract Telegram config
+        const telegramToken = config.telegram?.token
+          ?? config.channels?.telegram?.token
+          ?? config.plugins?.telegram?.token;
+
+        if (telegramToken && !wispyChannels.telegram) {
+          wispyChannels.telegram = { token: telegramToken };
+          this.report.channels.push({ channel: "telegram", action: "import" });
+        }
+
+        // Extract Discord config
+        const discordToken = config.discord?.token
+          ?? config.channels?.discord?.token;
+
+        if (discordToken && !wispyChannels.discord) {
+          wispyChannels.discord = { token: discordToken };
+          this.report.channels.push({ channel: "discord", action: "import" });
+        }
+
+        if (this.report.channels.length > 0 && !dryRun) {
+          await mkdir(this.wispyDir, { recursive: true });
+          await writeFile(channelsPath, JSON.stringify(wispyChannels, null, 2) + "\n", "utf8");
+        }
+
+        break; // Only process first found
+      } catch { /* Not found */ }
+    }
+  }
+
+  // ── Report formatting ─────────────────────────────────────────────────────────
+
+  formatReport() {
+    const r = this.report;
+    const lines = [];
+
+    if (!r.detected) {
+      return `❌ OpenClaw not found at ${OPENCLAW_DIR}`;
+    }
+
+    lines.push(`✅ OpenClaw detected at ${OPENCLAW_DIR}`);
+    lines.push("");
+
+    if (r.memories.length > 0) {
+      lines.push(`📝 Memories (${r.memories.length}):`);
+      for (const m of r.memories) {
+        lines.push(`  ${m.action}: ${basename(m.source)} → ${basename(m.dest)}`);
+      }
+    } else {
+      lines.push("📝 Memories: none found");
+    }
+
+    if (r.userModel.length > 0) {
+      lines.push(`👤 User profile files (${r.userModel.length}):`);
+      for (const u of r.userModel) {
+        lines.push(`  ${u.action}: ${u.source.replace(homedir(), "~")}`);
+      }
+    }
+
+    if (r.cronJobs.length > 0) {
+      lines.push(`⏰ Cron jobs (${r.cronJobs.length}):`);
+      for (const j of r.cronJobs) {
+        lines.push(`  import: ${j.job}`);
+      }
+    }
+
+    if (r.channels.length > 0) {
+      lines.push(`📡 Channels (${r.channels.length}):`);
+      for (const c of r.channels) {
+        lines.push(`  import: ${c.channel}`);
+      }
+    }
+
+    if (r.errors.length > 0) {
+      lines.push(`⚠️ Errors (${r.errors.length}):`);
+      for (const e of r.errors) {
+        lines.push(`  ${e}`);
+      }
+    }
+
+    return lines.join("\n");
+  }
+}

package/core/server.mjs

@@ -7,11 +7,71 @@
 
 import { createServer } from "node:http";
 import path from "node:path";
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { randomBytes, createHmac } from "node:crypto";
+import { readFile, writeFile, mkdir, readdir, stat } from "node:fs/promises";
+import { randomBytes, createHmac, createHash } from "node:crypto";
 
 import { WISPY_DIR } from "./config.mjs";
 
+// ── Sync helpers ──────────────────────────────────────────────────────────────
+
+const SYNC_PATTERNS = [
+  (f) => f.startsWith("memory/") && f.endsWith(".md"),
+  (f) => f.startsWith("sessions/") && f.endsWith(".json"),
+  (f) => f === "cron/jobs.json",
+  (f) => /^workstreams\/[^/]+\/work\.md$/.test(f),
+  (f) => f === "permissions.json",
+];
+
+function isSyncable(relPath) {
+  return SYNC_PATTERNS.some(fn => fn(relPath));
+}
+
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+
+function isPathSafe(relPath) {
+  // Reject absolute paths and path traversal
+  if (path.isAbsolute(relPath)) return false;
+  if (relPath.includes("..")) return false;
+  if (relPath.includes("\0")) return false;
+  return true;
+}
+
+async function scanSyncableFiles(baseDir) {
+  const entries = [];
+  await _scanDir(baseDir, baseDir, entries);
+  return entries;
+}
+
+async function _scanDir(baseDir, dir, entries) {
+  let items;
+  try {
+    items = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const item of items) {
+    const fullPath = path.join(dir, item.name);
+    const relPath = path.relative(baseDir, fullPath).replace(/\\/g, "/");
+    if (item.isDirectory()) {
+      if (["node_modules", ".git", ".npm"].includes(item.name)) continue;
+      await _scanDir(baseDir, fullPath, entries);
+    } else if (item.isFile() && isSyncable(relPath)) {
+      try {
+        const content = await readFile(fullPath);
+        const fileStat = await stat(fullPath);
+        entries.push({
+          path: relPath,
+          hash: sha256(content),
+          modifiedAt: fileStat.mtime.toISOString(),
+          size: content.length,
+        });
+      } catch { /* skip */ }
+    }
+  }
+}
+
 const SERVER_CONFIG_FILE = path.join(WISPY_DIR, "server.json");
 const DEFAULT_PORT = 18790;
 const DEFAULT_HOST = "127.0.0.1";
@@ -335,6 +395,96 @@ export class WispyServer {
       }
     }
 
+    // ── Sync ────────────────────────────────────────────────────────────────
+
+    // GET /api/sync/manifest — list all syncable files with hash + mtime
+    if (pathname === "/api/sync/manifest" && method === "GET") {
+      const files = await scanSyncableFiles(WISPY_DIR);
+      return jsonResponse(res, 200, { files });
+    }
+
+    // GET /api/sync/file?path=<relPath> — download a file
+    if (pathname === "/api/sync/file" && method === "GET") {
+      const relPath = url.searchParams.get("path");
+      if (!relPath) return errorResponse(res, 400, "path required");
+      if (!isPathSafe(relPath)) return errorResponse(res, 400, "invalid path");
+      if (!isSyncable(relPath)) return errorResponse(res, 400, "path not syncable");
+
+      const fullPath = path.join(WISPY_DIR, relPath);
+      try {
+        const content = await readFile(fullPath);
+        const fileStat = await stat(fullPath);
+        return jsonResponse(res, 200, {
+          path: relPath,
+          content: content.toString("base64"),
+          encoding: "base64",
+          modifiedAt: fileStat.mtime.toISOString(),
+          hash: sha256(content),
+          size: content.length,
+        });
+      } catch {
+        return errorResponse(res, 404, "File not found");
+      }
+    }
+
+    // POST /api/sync/file — upload a file
+    if (pathname === "/api/sync/file" && method === "POST") {
+      const body = await readBody(req);
+      const { path: relPath, content, encoding = "base64", modifiedAt } = body;
+      if (!relPath || content == null) return errorResponse(res, 400, "path and content required");
+      if (!isPathSafe(relPath)) return errorResponse(res, 400, "invalid path");
+      if (!isSyncable(relPath)) return errorResponse(res, 400, "path not syncable");
+
+      const fullPath = path.join(WISPY_DIR, relPath);
+      await mkdir(path.dirname(fullPath), { recursive: true });
+      const buf = Buffer.from(content, encoding === "base64" ? "base64" : "utf8");
+      await writeFile(fullPath, buf);
+      if (modifiedAt) {
+        const mtime = new Date(modifiedAt);
+        const { utimes } = await import("node:fs/promises");
+        await utimes(fullPath, mtime, mtime).catch(() => {});
+      }
+      return jsonResponse(res, 200, { success: true, path: relPath, size: buf.length });
+    }
+
+    // POST /api/sync/bulk — upload multiple files at once
+    if (pathname === "/api/sync/bulk" && method === "POST") {
+      const body = await readBody(req);
+      const files = body.files ?? [];
+      if (!Array.isArray(files)) return errorResponse(res, 400, "files must be an array");
+
+      const results = [];
+      for (const file of files) {
+        const { path: relPath, content, encoding = "base64", modifiedAt } = file;
+        if (!relPath || content == null) {
+          results.push({ path: relPath, success: false, error: "missing path or content" });
+          continue;
+        }
+        if (!isPathSafe(relPath) || !isSyncable(relPath)) {
+          results.push({ path: relPath, success: false, error: "invalid or non-syncable path" });
+          continue;
+        }
+        try {
+          const fullPath = path.join(WISPY_DIR, relPath);
+          await mkdir(path.dirname(fullPath), { recursive: true });
+          const buf = Buffer.from(content, encoding === "base64" ? "base64" : "utf8");
+          await writeFile(fullPath, buf);
+          if (modifiedAt) {
+            const mtime = new Date(modifiedAt);
+            const { utimes } = await import("node:fs/promises");
+            await utimes(fullPath, mtime, mtime).catch(() => {});
+          }
+          results.push({ path: relPath, success: true, size: buf.length });
+        } catch (err) {
+          results.push({ path: relPath, success: false, error: err.message });
+        }
+      }
+
+      const succeeded = results.filter(r => r.success).length;
+      const failed = results.filter(r => !r.success).length;
+      return jsonResponse(res, 200, { success: failed === 0, received: files.length, succeeded, failed, results });
+    }
+
     // ── Audit ───────────────────────────────────────────────────────────────
     if (pathname === "/api/audit" && method === "GET") {
       const filter = {};

package/core/session.mjs

@@ -116,6 +116,7 @@ export class SessionManager {
 
   /**
    * Save a session to disk.
+   * If auto-sync is enabled, pushes the file to remote (non-blocking).
    */
   async save(id) {
     const session = this._sessions.get(id);
@@ -123,6 +124,13 @@ export class SessionManager {
     await mkdir(SESSIONS_DIR, { recursive: true });
     const filePath = path.join(SESSIONS_DIR, `${id}.json`);
     await writeFile(filePath, JSON.stringify(session.toJSON(), null, 2) + "\n", "utf8");
+
+    // Auto-sync: push to remote if configured (fire-and-forget)
+    try {
+      const { getSyncManager } = await import("./sync.mjs");
+      const syncMgr = await getSyncManager();
+      if (syncMgr?.auto) syncMgr.pushFile(filePath);
+    } catch { /* sync is optional */ }
   }
 
   /**