ei-tui 1.6.4 → 1.6.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ei-tui",
-  "version": "1.6.4",
+  "version": "1.6.6",
   "author": "Flare576",
   "repository": {
     "type": "git",
@@ -63,7 +63,7 @@
     "@opentui/core": "^0.1.79",
     "@opentui/solid": "^0.1.79",
     "fastembed": "^2.1.0",
-    "solid-js": "1.9.9",
+    "solid-js": "^1.9.9",
     "yaml": "^2.8.2"
   }
 }

package/src/cli/README.md

@@ -16,6 +16,7 @@ ei --persona "Beta" --recent           # Most recently mentioned items Beta has
 ei --id <id>                   # Look up entity by ID — or fetch a message by FQ ID
 echo <id> | ei --id            # Look up entity by ID from stdin
 ei --install                   # Wire Ei into Claude Code, Cursor, Codex, and OpenCode (MCP + hooks + persona plugin)
+ei --sync                      # Pull latest state from remote sync server into state.backup.json (no TUI required)
 ei mcp                         # Start the Ei MCP stdio server (for Claude Code/Cursor/Codex)
 ```
 
@@ -133,3 +134,15 @@ All search commands return arrays. Each result includes a `type` field.
 **Persona**: `{ type, id, display_name, short_description, model, base_prompt, traits[], topics[] }`
 
 **ID lookup** (`lookup: true`): single object (not an array) with the same shape.
+
+## Quick Sync
+
+Sometimes you want your latest Ei profile available on a machine without running the full TUI — especially if the TUI is already running on another machine.
+
+```sh
+ei --sync
+```
+
+Pulls the latest state from your remote sync server and saves it to `state.backup.json`. Works the same credential hierarchy as the TUI: reads from `state.backup.json` first, falls back to `EI_SYNC_USERNAME` / `EI_SYNC_PASSPHRASE` environment variables if not present.
+
+Will abort (with a clear error) if `state.json` already exists on this machine — that means Ei has run here and a conflict resolution step would be needed on next launch.

package/src/cli.ts

@@ -70,6 +70,7 @@ Options:
   --source, -s        Filter to entities from a specific source (prefix match, e.g. "cursor", "codex:my-machine", "opencode:my-machine:ses_abc123")
   --id                Look up entity by ID (accepts value or stdin)
   --install           Register Ei with Claude Code, Cursor, Codex, and OpenCode (MCP + context hooks where supported)
+  --sync              Pull latest state from remote sync server into state.backup.json (no TUI required)
   --session <id>      Session ID to enrich the query with recent context (use with --hook-source)
   --hook-source <src> Source of the hook: "opencode-plugin" (OpenCode SQLite), "cursor", or "codex"
   --transcript <path> Path to a Claude Code JSONL transcript file for context enrichment
@@ -145,6 +146,86 @@ async function main(): Promise<void> {
     process.exit(0);
   }
 
+  if (args[0] === "--sync") {
+    const { getDataPath } = await import("./cli/retrieval.js");
+    const { RemoteSync } = await import("./storage/remote.js");
+    const { decodeAllEmbeddings, encodeAllEmbeddings } = await import("./storage/embeddings.js");
+    const { join } = await import("path");
+    const { readFile, writeFile, rename, mkdir } = await import("fs/promises");
+
+    const dataPath = getDataPath();
+    const statePath = join(dataPath, "state.json");
+    const lockPath = join(dataPath, "ei.lock");
+    const backupPath = join(dataPath, "state.backup.json");
+
+    // Fail if state.json exists — implies Ei ran here and a conflict would arise on next start
+    try {
+      await readFile(statePath);
+      process.stderr.write(
+        `\nei --sync aborted: state.json already exists at ${dataPath}\n\n` +
+        `This machine has local Ei data. Running --sync here would create a conflict\n` +
+        `the next time you start Ei.\n\n` +
+        `If you want to pull from remote anyway, delete state.json first.\n\n`
+      );
+      process.exit(1);
+    } catch { /* file doesn't exist — good */ }
+
+    // Fail if ei.lock exists with a live process — Ei is actively running
+    try {
+      const lockText = await readFile(lockPath, "utf-8");
+      const lock = JSON.parse(lockText) as { pid: number; started: string };
+      try {
+        process.kill(lock.pid, 0);
+        process.stderr.write(
+          `\nei --sync aborted: Ei is already running on this machine.\n` +
+          `  PID:     ${lock.pid}\n` +
+          `  Started: ${lock.started}\n\n` +
+          `Stop Ei before syncing.\n\n`
+        );
+        process.exit(1);
+      } catch { /* PID is dead — stale lock, proceed */ }
+    } catch { /* no lock file — good */ }
+
+    // Resolve sync credentials: prefer stored backup state, fall back to env vars
+    let username: string | undefined;
+    let passphrase: string | undefined;
+    try {
+      const backupText = await readFile(backupPath, "utf-8");
+      const backup = decodeAllEmbeddings(JSON.parse(backupText));
+      username = backup?.human?.settings?.sync?.username;
+      passphrase = backup?.human?.settings?.sync?.passphrase;
+    } catch { /* no backup — fall through to env vars */ }
+
+    username ??= process.env.EI_SYNC_USERNAME;
+    passphrase ??= process.env.EI_SYNC_PASSPHRASE;
+
+    if (!username || !passphrase) {
+      process.stderr.write(
+        `\nei --sync aborted: no sync credentials found.\n\n` +
+        `Set EI_SYNC_USERNAME and EI_SYNC_PASSPHRASE environment variables,\n` +
+        `or run Ei normally first to store credentials in state.backup.json.\n\n`
+      );
+      process.exit(1);
+    }
+
+    const remote = new RemoteSync();
+    await remote.configure({ username, passphrase });
+
+    const result = await remote.fetch();
+    if (!result.success || !result.state) {
+      process.stderr.write(`\nei --sync failed: ${result.error ?? "unknown error"}\n\n`);
+      process.exit(1);
+    }
+
+    await mkdir(dataPath, { recursive: true });
+    const tempPath = `${backupPath}.tmp.${Date.now()}`;
+    await writeFile(tempPath, JSON.stringify(encodeAllEmbeddings(result.state), null, 2), "utf-8");
+    await rename(tempPath, backupPath);
+
+    process.stdout.write(`\nei --sync complete. Remote state saved to state.backup.json.\n\n`);
+    process.exit(0);
+  }
+
   // Handle --id flag: look up entity by ID
   const idFlagIndex = args.indexOf("--id");
   if (idFlagIndex !== -1) {

package/tui/src/storage/file.ts

@@ -86,6 +86,12 @@ export class FileStorage implements Storage {
   }
 
 
+  async saveBackup(state: StorageState): Promise<void> {
+    await this.ensureDataDir();
+    const backupPath = join(this.dataPath, BACKUP_FILE);
+    await this.atomicWrite(backupPath, JSON.stringify(encodeAllEmbeddings(state), null, 2));
+  }
+
   /**
    * Read backup state without removing it.
    * Used to peek sync credentials from a previous session's backup.