ei-tui 1.6.3 → 1.6.4

package/src/core/integration-sync-manager.ts

@@ -0,0 +1,482 @@
+import { StateManager } from "./state-manager.js";
+import type { Ei_Interface, HumanEntity } from "./types.js";
+import type { Storage } from "../storage/interface.js";
+
+const DEFAULT_OPENCODE_POLLING_MS = 60000;
+const DEFAULT_CLAUDE_CODE_POLLING_MS = 60000;
+const DEFAULT_CURSOR_POLLING_MS = 60000;
+const DEFAULT_CODEX_POLLING_MS = 60000;
+const DEFAULT_PI_POLLING_MS = 60000;
+
+export class IntegrationSyncManager {
+  private lastOpenCodeSync = 0;
+  private openCodeImportInProgress = false;
+  private lastClaudeCodeSync = 0;
+  private claudeCodeImportInProgress = false;
+  private lastCursorSync = 0;
+  private cursorImportInProgress = false;
+  private lastCodexSync = 0;
+  private codexImportInProgress = false;
+  private lastPiSync = 0;
+  private piImportInProgress = false;
+  private lastSlackSync = 0;
+  private slackImportInProgress = false;
+  private personaHistoryImportInProgress = false;
+
+  constructor(
+    private stateManager: StateManager,
+    private isTUI: boolean,
+    private storage: Storage | null,
+    private importAbortController: AbortController,
+    private ei: Ei_Interface,
+  ) {}
+
+  resetImportFlags(): void {
+    if (this.openCodeImportInProgress) {
+      console.log("[IntegrationSyncManager] Clearing openCodeImportInProgress flag");
+      this.openCodeImportInProgress = false;
+    }
+    if (this.claudeCodeImportInProgress) {
+      console.log("[IntegrationSyncManager] Clearing claudeCodeImportInProgress flag");
+      this.claudeCodeImportInProgress = false;
+    }
+    if (this.cursorImportInProgress) {
+      console.log("[IntegrationSyncManager] Clearing cursorImportInProgress flag");
+      this.cursorImportInProgress = false;
+    }
+    if (this.codexImportInProgress) {
+      console.log("[IntegrationSyncManager] Clearing codexImportInProgress flag");
+      this.codexImportInProgress = false;
+    }
+    if (this.piImportInProgress) {
+      console.log("[IntegrationSyncManager] Clearing piImportInProgress flag");
+      this.piImportInProgress = false;
+    }
+    if (this.slackImportInProgress) {
+      console.log("[IntegrationSyncManager] Clearing slackImportInProgress flag");
+      this.slackImportInProgress = false;
+    }
+  }
+
+  updateAbortController(controller: AbortController): void {
+    this.importAbortController = controller;
+  }
+
+  async checkAll(human: HumanEntity, now: number): Promise<void> {
+    if (
+      this.isTUI &&
+      human.settings?.opencode?.integration &&
+      this.stateManager.queue_length() === 0
+    ) {
+      await this.checkAndSyncOpenCode(human, now);
+    }
+
+    if (this.isTUI && human.settings?.backup?.enabled) {
+      await this.checkAndRunRollingBackup(human, now);
+    }
+
+    if (
+      this.isTUI &&
+      human.settings?.claudeCode?.integration &&
+      this.stateManager.queue_length() === 0
+    ) {
+      await this.checkAndSyncClaudeCode(human, now);
+    }
+
+    if (
+      this.isTUI &&
+      human.settings?.cursor?.integration &&
+      this.stateManager.queue_length() === 0
+    ) {
+      await this.checkAndSyncCursor(human, now);
+    }
+
+    if (
+      this.isTUI &&
+      human.settings?.codex?.integration &&
+      this.stateManager.queue_length() === 0
+    ) {
+      await this.checkAndSyncCodex(human, now);
+    }
+
+    if (
+      this.isTUI &&
+      human.settings?.pi?.integration &&
+      this.stateManager.queue_length() === 0
+    ) {
+      await this.checkAndSyncPi(human, now);
+    }
+
+    if (
+      this.isTUI &&
+      human.settings?.personaHistory?.integration &&
+      !human.settings.personaHistory.complete &&
+      this.stateManager.queue_length() === 0
+    ) {
+      await this.checkAndSyncPersonaHistory(human);
+    }
+
+    if (
+      this.isTUI &&
+      Object.values(human.settings?.slack?.workspaces ?? {}).some(ws => ws.integration && ws.auth) &&
+      this.stateManager.queue_length() === 0
+    ) {
+      await this.checkAndSyncSlack(human, now);
+    }
+  }
+
+  private async checkAndRunRollingBackup(human: HumanEntity, now: number): Promise<void> {
+    if (!this.storage) return;
+    const cfg = human.settings!.backup!;
+    const intervalMs = cfg.interval_ms ?? 3_600_000;
+    const maxBackups = cfg.max_backups ?? 24;
+    const lastBackup = cfg.last_backup ? new Date(cfg.last_backup).getTime() : 0;
+
+    if (now - lastBackup < intervalMs) return;
+
+    this.stateManager.setHuman({
+      ...this.stateManager.getHuman(),
+      settings: {
+        ...this.stateManager.getHuman().settings,
+        backup: { ...cfg, last_backup: new Date(now).toISOString() },
+      },
+    });
+
+    const state = this.stateManager.getStorageState();
+    try {
+      await this.storage.saveRollingBackup(state, maxBackups);
+      console.log(`[Processor] Rolling backup saved (max=${maxBackups})`);
+    } catch (err) {
+      console.warn(`[Processor] Rolling backup failed:`, err);
+    }
+  }
+
+  private async checkAndSyncOpenCode(human: HumanEntity, now: number): Promise<void> {
+    if (this.openCodeImportInProgress) {
+      return;
+    }
+
+    const opencode = human.settings?.opencode;
+    const pollingInterval = opencode?.polling_interval_ms ?? DEFAULT_OPENCODE_POLLING_MS;
+    const lastSync = opencode?.last_sync ? new Date(opencode.last_sync).getTime() : 0;
+    const timeSinceSync = now - lastSync;
+
+    if (timeSinceSync < pollingInterval && this.lastOpenCodeSync > 0) {
+      return;
+    }
+
+    this.lastOpenCodeSync = now;
+    const syncTimestamp = new Date().toISOString();
+    this.stateManager.setHuman({
+      ...this.stateManager.getHuman(),
+      settings: {
+        ...this.stateManager.getHuman().settings,
+        opencode: {
+          ...opencode,
+          last_sync: syncTimestamp,
+        },
+      },
+    });
+
+    this.openCodeImportInProgress = true;
+    import("../integrations/opencode/importer.js")
+      .then(({ importOpenCodeSessions }) =>
+        importOpenCodeSessions({
+          stateManager: this.stateManager,
+          interface: this.ei,
+          signal: this.importAbortController.signal,
+        })
+      )
+      .then((result) => {
+        if (result.sessionsProcessed > 0) {
+          console.log(
+            `[Processor] OpenCode sync complete: ${result.sessionsProcessed} sessions, ` +
+              `${result.messagesImported} messages imported, ` +
+              `${result.extractionScansQueued} extraction scans queued`
+          );
+        }
+      })
+      .catch((err) => {
+        console.warn(`[Processor] OpenCode sync failed:`, err);
+      })
+      .finally(() => {
+        this.openCodeImportInProgress = false;
+      });
+  }
+
+  private async checkAndSyncClaudeCode(human: HumanEntity, now: number): Promise<void> {
+    if (this.claudeCodeImportInProgress) {
+      return;
+    }
+
+    const claudeCode = human.settings?.claudeCode;
+    const pollingInterval = claudeCode?.polling_interval_ms ?? DEFAULT_CLAUDE_CODE_POLLING_MS;
+    const lastSync = claudeCode?.last_sync ? new Date(claudeCode.last_sync).getTime() : 0;
+    const timeSinceSync = now - lastSync;
+
+    if (timeSinceSync < pollingInterval && this.lastClaudeCodeSync > 0) {
+      return;
+    }
+
+    this.lastClaudeCodeSync = now;
+    const syncTimestamp = new Date().toISOString();
+    this.stateManager.setHuman({
+      ...this.stateManager.getHuman(),
+      settings: {
+        ...this.stateManager.getHuman().settings,
+        claudeCode: {
+          ...claudeCode,
+          last_sync: syncTimestamp,
+        },
+      },
+    });
+
+    this.claudeCodeImportInProgress = true;
+    import("../integrations/claude-code/importer.js")
+      .then(({ importClaudeCodeSessions }) =>
+        importClaudeCodeSessions({
+          stateManager: this.stateManager,
+          interface: this.ei,
+          signal: this.importAbortController.signal,
+        })
+      )
+      .then((result) => {
+        if (result.sessionsProcessed > 0) {
+          console.log(
+            `[Processor] Claude Code sync complete: ${result.sessionsProcessed} sessions, ` +
+              `${result.messagesImported} messages imported, ` +
+              `${result.extractionScansQueued} extraction scans queued`
+          );
+        }
+      })
+      .catch((err) => {
+        console.warn(`[Processor] Claude Code sync failed:`, err);
+      })
+      .finally(() => {
+        this.claudeCodeImportInProgress = false;
+      });
+  }
+
+  private async checkAndSyncCursor(human: HumanEntity, now: number): Promise<void> {
+    if (this.cursorImportInProgress) {
+      return;
+    }
+
+    const cursor = human.settings?.cursor;
+    const pollingInterval = cursor?.polling_interval_ms ?? DEFAULT_CURSOR_POLLING_MS;
+    const lastSync = cursor?.last_sync ? new Date(cursor.last_sync).getTime() : 0;
+    const timeSinceSync = now - lastSync;
+
+    if (timeSinceSync < pollingInterval && this.lastCursorSync > 0) {
+      return;
+    }
+
+    this.lastCursorSync = now;
+    const syncTimestamp = new Date().toISOString();
+    this.stateManager.setHuman({
+      ...this.stateManager.getHuman(),
+      settings: {
+        ...this.stateManager.getHuman().settings,
+        cursor: {
+          ...cursor,
+          last_sync: syncTimestamp,
+        },
+      },
+    });
+
+    this.cursorImportInProgress = true;
+    import("../integrations/cursor/importer.js")
+      .then(({ importCursorSessions }) =>
+        importCursorSessions({
+          stateManager: this.stateManager,
+          interface: this.ei,
+          signal: this.importAbortController.signal,
+        })
+      )
+      .then((result) => {
+        if (result.sessionsProcessed > 0) {
+          console.log(
+            `[Processor] Cursor sync complete: ${result.sessionsProcessed} sessions, ` +
+              `${result.messagesImported} messages imported, ` +
+              `${result.extractionScansQueued} extraction scans queued`
+          );
+        }
+      })
+      .catch((err) => {
+        console.warn(`[Processor] Cursor sync failed:`, err);
+      })
+      .finally(() => {
+        this.cursorImportInProgress = false;
+      });
+  }
+
+  private async checkAndSyncCodex(human: HumanEntity, now: number): Promise<void> {
+    if (this.codexImportInProgress) {
+      return;
+    }
+
+    const codex = human.settings?.codex;
+    const pollingInterval = codex?.polling_interval_ms ?? DEFAULT_CODEX_POLLING_MS;
+    const lastSync = codex?.last_sync ? new Date(codex.last_sync).getTime() : 0;
+    const timeSinceSync = now - lastSync;
+
+    if (timeSinceSync < pollingInterval && this.lastCodexSync > 0) {
+      return;
+    }
+
+    this.lastCodexSync = now;
+    const syncTimestamp = new Date().toISOString();
+    const currentHuman = this.stateManager.getHuman();
+    this.stateManager.setHuman({
+      ...currentHuman,
+      settings: {
+        ...currentHuman.settings,
+        codex: {
+          ...codex,
+          last_sync: syncTimestamp,
+        },
+      },
+    });
+
+    this.codexImportInProgress = true;
+    import("../integrations/codex/importer.js")
+      .then(({ importCodexSessions }) =>
+        importCodexSessions({
+          stateManager: this.stateManager,
+          interface: this.ei,
+          signal: this.importAbortController.signal,
+        })
+      )
+      .then((result) => {
+        if (result.sessionsProcessed > 0) {
+          console.log(
+            `[Processor] Codex sync complete: ${result.sessionsProcessed} sessions, ` +
+              `${result.messagesImported} messages imported, ` +
+              `${result.extractionScansQueued} extraction scans queued`
+          );
+        }
+      })
+      .catch((err) => {
+        console.warn(`[Processor] Codex sync failed:`, err);
+      })
+      .finally(() => {
+        this.codexImportInProgress = false;
+      });
+  }
+
+  private async checkAndSyncPi(human: HumanEntity, now: number): Promise<void> {
+    if (this.piImportInProgress) {
+      return;
+    }
+
+    const pi = human.settings?.pi;
+    const pollingInterval = pi?.polling_interval_ms ?? DEFAULT_PI_POLLING_MS;
+    const lastSync = pi?.last_sync ? new Date(pi.last_sync).getTime() : 0;
+    const timeSinceSync = now - lastSync;
+
+    if (timeSinceSync < pollingInterval && this.lastPiSync > 0) {
+      return;
+    }
+
+    this.lastPiSync = now;
+    const syncTimestamp = new Date().toISOString();
+    const currentHuman = this.stateManager.getHuman();
+    this.stateManager.setHuman({
+      ...currentHuman,
+      settings: {
+        ...currentHuman.settings,
+        pi: {
+          ...pi,
+          last_sync: syncTimestamp,
+        },
+      },
+    });
+
+    this.piImportInProgress = true;
+    import("../integrations/pi/importer.js")
+      .then(({ importPiSessions }) =>
+        importPiSessions({
+          stateManager: this.stateManager,
+          interface: this.ei,
+          signal: this.importAbortController.signal,
+        })
+      )
+      .then((result) => {
+        if (result.sessionsProcessed > 0) {
+          console.log(
+            `[Processor] Pi sync complete: ${result.sessionsProcessed} sessions, ` +
+              `${result.messagesImported} messages imported, ` +
+              `${result.extractionScansQueued} extraction scans queued`
+          );
+        }
+      })
+      .catch((err) => {
+        console.warn(`[Processor] Pi sync failed:`, err);
+      })
+      .finally(() => {
+        this.piImportInProgress = false;
+      });
+  }
+
+  private async checkAndSyncSlack(human: HumanEntity, now: number): Promise<void> {
+    if (this.slackImportInProgress) return;
+
+    const slack = human.settings?.slack;
+    const pollingInterval = slack?.polling_interval_ms ?? 60_000;
+
+    if (now - this.lastSlackSync < pollingInterval && this.lastSlackSync > 0) return;
+
+    this.lastSlackSync = now;
+
+    this.slackImportInProgress = true;
+    import("../integrations/slack/importer.js")
+      .then(({ importSlackChannel }) =>
+        importSlackChannel({
+          stateManager: this.stateManager,
+          interface: this.ei,
+          signal: this.importAbortController.signal,
+        })
+      )
+      .then((result) => {
+        if (result.channelProcessed) {
+          console.log(
+            `[Processor] Slack sync: #${result.channelProcessed} — ` +
+            `${result.messagesImported} messages, ${result.threadsProcessed} threads, ` +
+            `${result.scansQueued} scans queued`
+          );
+        }
+      })
+      .catch((err) => {
+        const msg = err instanceof Error ? err.message : JSON.stringify(err);
+        const stack = err instanceof Error ? err.stack : undefined;
+        console.warn(`[Processor] Slack sync failed: ${msg}${stack ? `\n${stack}` : ''}`);
+      })
+      .finally(() => {
+        this.slackImportInProgress = false;
+      });
+  }
+
+  private async checkAndSyncPersonaHistory(_human: HumanEntity): Promise<void> {
+    if (this.personaHistoryImportInProgress) return;
+
+    this.personaHistoryImportInProgress = true;
+    import("../integrations/persona-history/importer.js")
+      .then(({ importPersonaHistory }) =>
+        importPersonaHistory({ stateManager: this.stateManager })
+      )
+      .then((result) => {
+        if (result.scansQueued > 0) {
+          console.log(
+            `[Processor] PersonaHistory: ${result.scansQueued} scans queued` +
+            (result.complete ? " — import complete" : "")
+          );
+        }
+      })
+      .catch((err) => {
+        console.warn(`[Processor] PersonaHistory sync failed:`, err);
+      })
+      .finally(() => {
+        this.personaHistoryImportInProgress = false;
+      });
+  }
+}

package/src/core/message-manager.ts

@@ -25,6 +25,7 @@ import {
 } from "./orchestrators/index.js";
 import { buildChatMessageContent } from "../prompts/message-utils.js";
 import { filterMessagesForContext } from "./context-utils.js";
+import { qualifyEiMessage } from "./utils/message-id.js";
 
 // =============================================================================
 // MESSAGE QUERIES
@@ -149,7 +150,7 @@ export async function sendMessage(
   clearPendingRequestsFor(sm, qp, currentRequest, personaId);
 
   const message: Message = {
-    id: crypto.randomUUID(),
+    id: qualifyEiMessage(crypto.randomUUID()),
     role: "human",
     content: content ?? undefined,
     silence_reason: content ? undefined : (silenceReason ?? "passed"),