wispy-cli 1.2.2 → 1.3.0

package/bin/wispy.mjs

@@ -22,8 +22,33 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 const args = process.argv.slice(2);
 
+// ── setup / init sub-command ──────────────────────────────────────────────────
+if (args[0] === "setup" || args[0] === "init") {
+  const { OnboardingWizard } = await import(
+    path.join(__dirname, "..", "core", "onboarding.mjs")
+  );
+  const wizard = new OnboardingWizard();
+  const sub = args[1]; // e.g. "provider", "channels", "security"
+  if (sub && sub !== "wizard") {
+    await wizard.runStep(sub);
+  } else {
+    await wizard.run();
+  }
+  process.exit(0);
+}
+
 // ── status sub-command ────────────────────────────────────────────────────────
 if (args[0] === "status") {
+  // Try the enhanced status from onboarding.mjs first
+  try {
+    const { printStatus } = await import(
+      path.join(__dirname, "..", "core", "onboarding.mjs")
+    );
+    await printStatus();
+    process.exit(0);
+  } catch {}
+
+  // Fallback: original status (remote check)
   const { readFile } = await import("node:fs/promises");
   const { homedir } = await import("node:os");
   const { join } = await import("node:path");
@@ -131,6 +156,135 @@ if (args[0] === "disconnect") {
   process.exit(0);
 }
 
+// ── sync sub-command ──────────────────────────────────────────────────────────
+if (args[0] === "sync") {
+  const { SyncManager } = await import(
+    path.join(__dirname, "..", "core", "sync.mjs")
+  );
+
+  const sub = args[1]; // push | pull | status | auto | (undefined = bidirectional)
+
+  const green  = (s) => `\x1b[32m${s}\x1b[0m`;
+  const red    = (s) => `\x1b[31m${s}\x1b[0m`;
+  const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+  const cyan   = (s) => `\x1b[36m${s}\x1b[0m`;
+  const bold   = (s) => `\x1b[1m${s}\x1b[0m`;
+  const dim    = (s) => `\x1b[2m${s}\x1b[0m`;
+
+  // Parse flags
+  const strategyIdx = args.indexOf("--strategy");
+  const strategy = strategyIdx !== -1 ? args[strategyIdx + 1] : null;
+  const memoryOnly   = args.includes("--memory-only");
+  const sessionsOnly = args.includes("--sessions-only");
+  const remoteUrlIdx = args.indexOf("--remote");
+  const remoteUrlArg = remoteUrlIdx !== -1 ? args[remoteUrlIdx + 1] : null;
+  const tokenIdx = args.indexOf("--token");
+  const tokenArg = tokenIdx !== -1 ? args[tokenIdx + 1] : null;
+
+  // Load config (or use overrides)
+  const cfg = await SyncManager.loadConfig();
+  const remoteUrl = remoteUrlArg ?? cfg.remoteUrl;
+  const token     = tokenArg ?? cfg.token;
+
+  // ── auto enable/disable ──
+  if (sub === "auto") {
+    const enable  = !args.includes("--off");
+    const disable = args.includes("--off");
+    if (disable) {
+      await SyncManager.disableAuto();
+      console.log(`\n${yellow("⏸")}  Auto-sync ${bold("disabled")}.\n`);
+    } else if (!remoteUrl) {
+      console.log(`\n${red("✗")} No remote URL configured.`);
+      console.log(dim(`   Use: wispy sync auto --remote https://vps.com:18790 --token <token>\n`));
+      process.exit(1);
+    } else {
+      await SyncManager.enableAuto(remoteUrl, token ?? "");
+      console.log(`\n${green("✓")}  Auto-sync ${bold("enabled")}.`);
+      console.log(`   Remote: ${cyan(remoteUrl)}`);
+      console.log(dim("   Sessions and memory will be synced automatically.\n"));
+    }
+    process.exit(0);
+  }
+
+  // ── status ──
+  if (sub === "status") {
+    if (!remoteUrl) {
+      console.log(`\n${red("✗")} No remote configured. Set via sync.json or --remote flag.\n`);
+      process.exit(1);
+    }
+    console.log(`\n🔄 ${bold("Sync Status")}\n`);
+    console.log(`   Remote: ${cyan(remoteUrl)}`);
+    const mgr = new SyncManager({ remoteUrl, token, strategy: strategy ?? "newer-wins" });
+    const s = await mgr.status(remoteUrl, token);
+    console.log(`   Connection: ${s.reachable ? green("✅ reachable") : red("✗ unreachable")}\n`);
+
+    const fmt = (label, info) => {
+      const parts = [];
+      if (info.localOnly > 0)  parts.push(`${yellow(info.localOnly + " local only")}`);
+      if (info.remoteOnly > 0) parts.push(`${cyan(info.remoteOnly + " remote only")}`);
+      if (info.inSync > 0)     parts.push(`${green(info.inSync + " in sync")}`);
+      console.log(`   ${bold(label.padEnd(14))} ${parts.join(", ") || dim("(empty)")}`);
+    };
+    fmt("Memory:",     s.memory);
+    fmt("Sessions:",   s.sessions);
+    fmt("Cron:",       s.cron);
+    fmt("Workstreams:",s.workstreams);
+    fmt("Permissions:",s.permissions);
+
+    const needPull = (s.memory.remoteOnly + s.sessions.remoteOnly + s.cron.remoteOnly + s.workstreams.remoteOnly + s.permissions.remoteOnly);
+    const needPush = (s.memory.localOnly + s.sessions.localOnly + s.cron.localOnly + s.workstreams.localOnly + s.permissions.localOnly);
+    if (needPull > 0 || needPush > 0) {
+      console.log(`\n   Action needed: ${needPull > 0 ? `pull ${yellow(needPull)} file(s)` : ""} ${needPush > 0 ? `push ${yellow(needPush)} file(s)` : ""}`.trimEnd());
+      console.log(dim("   Run 'wispy sync' to synchronize."));
+    } else {
+      console.log(`\n   ${green("✓")} Everything in sync!`);
+    }
+    console.log("");
+    process.exit(0);
+  }
+
+  // For push/pull/sync we need a remote URL
+  if (!remoteUrl) {
+    console.log(`\n${red("✗")} No remote configured.`);
+    console.log(dim("   Set remoteUrl in ~/.wispy/sync.json or use --remote <url>\n"));
+    process.exit(1);
+  }
+
+  const opts = { strategy: strategy ?? cfg.strategy ?? "newer-wins", memoryOnly, sessionsOnly };
+  const mgr = new SyncManager({ remoteUrl, token, ...opts });
+
+  if (sub === "push") {
+    console.log(`\n📤 ${bold("Pushing")} to ${cyan(remoteUrl)}...`);
+    const result = await mgr.push(remoteUrl, token, opts);
+    console.log(`   Pushed:  ${green(result.pushed)}`);
+    console.log(`   Skipped: ${dim(result.skipped)}`);
+    if (result.errors.length) result.errors.forEach(e => console.log(`   ${red("✗")} ${e}`));
+    console.log(`\n${result.errors.length === 0 ? green("✓ Done") : yellow("⚠ Done with errors")}.\n`);
+
+  } else if (sub === "pull") {
+    console.log(`\n📥 ${bold("Pulling")} from ${cyan(remoteUrl)}...`);
+    const result = await mgr.pull(remoteUrl, token, opts);
+    console.log(`   Pulled:    ${green(result.pulled)}`);
+    console.log(`   Skipped:   ${dim(result.skipped)}`);
+    if (result.conflicts) console.log(`   Conflicts: ${yellow(result.conflicts)} (saved as .conflict-* files)`);
+    if (result.errors.length) result.errors.forEach(e => console.log(`   ${red("✗")} ${e}`));
+    console.log(`\n${result.errors.length === 0 ? green("✓ Done") : yellow("⚠ Done with errors")}.\n`);
+
+  } else {
+    // Bidirectional sync (default)
+    console.log(`\n🔄 ${bold("Syncing")} with ${cyan(remoteUrl)}...`);
+    const result = await mgr.sync(remoteUrl, token, opts);
+    console.log(`   Pushed:    ${green(result.pushed)}`);
+    console.log(`   Pulled:    ${green(result.pulled)}`);
+    console.log(`   Skipped:   ${dim(result.skipped)}`);
+    if (result.conflicts) console.log(`   Conflicts: ${yellow(result.conflicts)} (saved as .conflict-* files)`);
+    if (result.errors.length) result.errors.forEach(e => console.log(`   ${red("✗")} ${e}`));
+    console.log(`\n${result.errors.length === 0 ? green("✓ Done") : yellow("⚠ Done with errors")}.\n`);
+  }
+
+  process.exit(0);
+}
+
 // ── deploy sub-command ────────────────────────────────────────────────────────
 if (args[0] === "deploy") {
   const { DeployManager } = await import(
@@ -775,6 +929,32 @@ if (serveMode || telegramMode || discordMode || slackMode) {
   await new Promise(() => {}); // keep alive
 }
 
+// ── First-run detection (before TUI or REPL) ──────────────────────────────────
+// Only trigger onboarding for interactive modes (not flags like --serve, channel, etc.)
+const isInteractiveStart = !args.some(a =>
+  ["--serve", "--telegram", "--discord", "--slack", "--server",
+   "status", "setup", "init", "connect", "disconnect", "deploy",
+   "cron", "audit", "log", "server", "node", "channel", "sync"].includes(a)
+);
+
+if (isInteractiveStart) {
+  try {
+    const { isFirstRun } = await import(
+      path.join(__dirname, "..", "core", "config.mjs")
+    );
+    if (await isFirstRun()) {
+      const { OnboardingWizard } = await import(
+        path.join(__dirname, "..", "core", "onboarding.mjs")
+      );
+      const wizard = new OnboardingWizard();
+      await wizard.run();
+      // After onboarding, continue to REPL or TUI
+    }
+  } catch {
+    // If onboarding fails for any reason, continue normally
+  }
+}
+
 // ── TUI mode ──────────────────────────────────────────────────────────────────
 const tuiMode = args.includes("--tui");
 

package/core/config.mjs

@@ -58,6 +58,18 @@ export async function saveConfig(config) {
   await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf8");
 }
 
+/**
+ * Returns true if no config exists or onboarded flag is not set.
+ */
+export async function isFirstRun() {
+  try {
+    const cfg = await loadConfig();
+    return !cfg.onboarded;
+  } catch {
+    return true;
+  }
+}
+
 export async function detectProvider() {
   // 1. WISPY_PROVIDER env override
   const forced = process.env.WISPY_PROVIDER;

package/core/engine.mjs

@@ -24,6 +24,7 @@ import { SubAgentManager } from "./subagents.mjs";
 import { PermissionManager } from "./permissions.mjs";
 import { AuditLog, EVENT_TYPES } from "./audit.mjs";
 import { Harness } from "./harness.mjs";
+import { SyncManager, getSyncManager } from "./sync.mjs";
 
 const MAX_TOOL_ROUNDS = 10;
 const MAX_CONTEXT_CHARS = 40_000;
@@ -40,6 +41,7 @@ export class WispyEngine {
     this.permissions = new PermissionManager(config.permissions ?? {});
     this.audit = new AuditLog(WISPY_DIR);
     this.harness = new Harness(this.tools, this.permissions, this.audit, config);
+    this.sync = null; // SyncManager, initialized lazily
     this._initialized = false;
     this._workMdContent = null;
     this._workMdLoaded = false;
@@ -93,6 +95,15 @@ export class WispyEngine {
       this.tools.registerMCP(this.mcpManager);
     }
 
+    // Initialize sync manager (if configured)
+    try {
+      this.sync = await getSyncManager();
+      // Auto-sync on startup: pull any new data from remote
+      if (this.sync?.auto && this.sync.remoteUrl) {
+        this.sync.pull(this.sync.remoteUrl, this.sync.token).catch(() => {});
+      }
+    } catch { /* sync is optional */ }
+
     this._initialized = true;
     return this;
   }

package/core/index.mjs

@@ -9,7 +9,8 @@ export { SessionManager, Session, sessionManager } from "./session.mjs";
 export { ProviderRegistry } from "./providers.mjs";
 export { ToolRegistry } from "./tools.mjs";
 export { MCPClient, MCPManager, ensureDefaultMcpConfig } from "./mcp.mjs";
-export { loadConfig, saveConfig, detectProvider, PROVIDERS, WISPY_DIR, MCP_CONFIG_PATH, SESSIONS_DIR, CONVERSATIONS_DIR, MEMORY_DIR } from "./config.mjs";
+export { loadConfig, saveConfig, detectProvider, isFirstRun, PROVIDERS, WISPY_DIR, CONFIG_PATH, MCP_CONFIG_PATH, SESSIONS_DIR, CONVERSATIONS_DIR, MEMORY_DIR } from "./config.mjs";
+export { OnboardingWizard, isFirstRun as checkFirstRun, printStatus } from "./onboarding.mjs";
 export { MemoryManager } from "./memory.mjs";
 export { CronManager } from "./cron.mjs";
 export { SubAgentManager, SubAgent } from "./subagents.mjs";
@@ -19,3 +20,4 @@ export { WispyServer } from "./server.mjs";
 export { NodeManager, CAPABILITIES } from "./nodes.mjs";
 export { Harness, Receipt, HarnessResult, computeUnifiedDiff } from "./harness.mjs";
 export { DeployManager } from "./deploy.mjs";
+export { SyncManager, getSyncManager, sha256 } from "./sync.mjs";

package/core/memory.mjs

@@ -39,7 +39,8 @@ export class MemoryManager {
   }
 
   /**
-   * Save (overwrite) a memory file
+   * Save (overwrite) a memory file.
+   * If auto-sync is enabled, pushes the file to remote (non-blocking).
    */
   async save(key, content, metadata = {}) {
     await this._ensureDir();
@@ -55,6 +56,14 @@ export class MemoryManager {
       : `_Last updated: ${ts}_\n\n`;
 
     await writeFile(filePath, header + content, "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 */ }
+
     return { key, path: filePath };
   }