ei-tui 1.6.1 → 1.6.3

package/src/core/types/llm.ts

@@ -25,7 +25,7 @@ export interface Message {
   _synthesis?: boolean;         // True if message was created by multi-message synthesis
   speaker_name?: string;       // Display name of actual speaker; set on room messages for clean hydration
 
-  external?: boolean;          // Set by integration importers (OpenCode, Cursor, Claude Code); invisible to LLM context
+  external?: boolean;          // Set by integration importers (OpenCode, Cursor, Claude Code, Codex); invisible to LLM context
 
 }
 

package/src/core/utils/message-id.ts

@@ -4,6 +4,7 @@
  *   opencode:${machine}:${session}:${nativeId}
  *   claudecode:${machine}:${session}:${nativeId}
  *   cursor:${machine}:${session}:${nativeId}
+ *   codex:${machine}:${session}:${nativeId}
  *   import:document:${slug}:${uuid}
  *   slack:${workspace}:${channel}:${ts}
  */
@@ -13,6 +14,8 @@ export type MessageIdIntegration =
   | "opencode"
   | "claudecode"
   | "cursor"
+  | "codex"
+  | "pi"
   | "import"
   | "slack"
   | "unknown"
@@ -67,6 +70,26 @@ export function parseMessageId(id: string): ParsedMessageId {
     }
   }
 
+  if (parts[0] === "codex" && parts.length >= 4) {
+    return {
+      integration: "codex",
+      machine: parts[1],
+      session: parts[2],
+      nativeId: parts.slice(3).join(":"),
+      raw: id,
+    }
+  }
+
+  if (parts[0] === "pi" && parts.length >= 4) {
+    return {
+      integration: "pi",
+      machine: parts[1],
+      session: parts[2],
+      nativeId: parts.slice(3).join(":"),
+      raw: id,
+    }
+  }
+
   if (parts[0] === "import" && parts[1] === "document" && parts.length >= 4) {
     return {
       integration: "import",
@@ -109,6 +132,14 @@ export function qualifyCursorMessage(machine: string, sessionId: string, nativeI
   return `cursor:${machine}:${sessionId}:${nativeId}`
 }
 
+export function qualifyCodexMessage(machine: string, sessionId: string, nativeId: string): string {
+  return `codex:${machine}:${sessionId}:${nativeId}`
+}
+
+export function qualifyPiMessage(machine: string, sessionId: string, nativeId: string): string {
+  return `pi:${machine}:${sessionId}:${nativeId}`
+}
+
 export function qualifyDocumentMessage(slug: string, uuid: string): string {
   return `import:document:${slug}:${uuid}`
 }

package/src/integrations/claude-code/importer.ts

@@ -1,11 +1,9 @@
 import type { StateManager } from "../../core/state-manager.js";
-import type { Ei_Interface, Message, ContextStatus, PersonaEntity, PersonaTrait } from "../../core/types.js";
+import type { Ei_Interface, Message, PersonaEntity, PersonaTrait } from "../../core/types.js";
 import { DEFAULT_SEED_TRAITS } from "../../core/constants/seed-traits.js";
-import type { IClaudeCodeReader, ClaudeCodeSession, ClaudeCodeMessage } from "./types.js";
-import {
-  CLAUDE_CODE_PERSONA_NAME,
-  MIN_SESSION_AGE_MS,
-} from "./types.js";
+import type { IClaudeCodeReader, ClaudeCodeSession } from "./types.js";
+import { CLAUDE_CODE_PERSONA_NAME } from "./types.js";
+import { MIN_SESSION_AGE_MS } from "../constants.js";
 import { ClaudeCodeReader } from "./reader.js";
 import {
   queueAllScans,
@@ -16,8 +14,10 @@ import {
   queueTopicRewritePhase,
 } from "../../core/orchestrators/ceremony.js";
 import { isProcessRunning } from "../process-check.js";
-import { getMachineId } from "../machine-id.js";
 import { qualifyClaudeCodeMessage } from "../../core/utils/message-id.js";
+import { getMachineId } from "../machine-id.js";
+import { convertToEiMessage, convertToPreMarkedEiMessage } from "../shared/message-converter.js";
+import { TWELVE_HOURS_MS } from "../constants.js";
 
 // =============================================================================
 // Export Types
@@ -41,30 +41,9 @@ export interface ClaudeCodeImporterOptions {
 // Utility Functions
 // =============================================================================
 
-const TWELVE_HOURS_MS = 43_200_000;
 const CLAUDE_CODE_GROUP = "Claude Code";
 
-function convertToEiMessage(msg: ClaudeCodeMessage, sessionId: string): Message {
-  return {
-    id: qualifyClaudeCodeMessage(getMachineId(), sessionId, msg.id),
-    role: msg.role === "user" ? "human" : "system",
-    content: msg.content,
-    timestamp: msg.timestamp,
-    read: true,
-    context_status: "default" as ContextStatus,
-    external: true,
-  };
-}
-
-function convertToPreMarkedEiMessage(msg: ClaudeCodeMessage, sessionId: string): Message {
-  return {
-    ...convertToEiMessage(msg, sessionId),
-    f: true,
-    t: true,
-    p: true,
-    e: true,
-  };
-}
+const qualify = qualifyClaudeCodeMessage;
 
 /**
  * Ensure the single "Claude Code" persona exists.
@@ -249,7 +228,7 @@ export async function importClaudeCodeSessions(
   for (const msg of messages) {
     const msgMs = new Date(msg.timestamp).getTime();
     const isOld = cutoffMs !== null && msgMs < cutoffMs;
-    const eiMsg = isOld ? convertToPreMarkedEiMessage(msg, targetSession.id) : convertToEiMessage(msg, targetSession.id);
+    const eiMsg = isOld ? convertToPreMarkedEiMessage(msg, targetSession.id, qualify) : convertToEiMessage(msg, targetSession.id, qualify);
     stateManager.messages_append(persona.id, eiMsg);
     result.messagesImported++;
     if (!isOld) toAnalyze.push(eiMsg);

package/src/integrations/claude-code/types.ts

@@ -139,7 +139,7 @@ export const CLAUDE_CODE_TOPIC_GROUPS = ["General", "Coding", "Claude Code"];
  * Minimum session age before we import it.
  * Mirrors OpenCode's 20-minute rule — gives the session time to "settle."
  */
-export const MIN_SESSION_AGE_MS = 20 * 60 * 1000;
+export { MIN_SESSION_AGE_MS } from "../constants.js";
 
 // ============================================================================
 // Human Settings Shape (mirrors OpenCodeSettings in core/types.ts)

package/src/integrations/codex/importer.ts

@@ -0,0 +1,237 @@
+import type { StateManager } from "../../core/state-manager.js";
+import type { Ei_Interface, Message, PersonaEntity, PersonaTrait } from "../../core/types.js";
+import { DEFAULT_SEED_TRAITS } from "../../core/constants/seed-traits.js";
+import {
+  queueAllScans,
+  type ExtractionContext,
+} from "../../core/orchestrators/human-extraction.js";
+import {
+  queuePersonRewritePhase,
+  queueTopicRewritePhase,
+} from "../../core/orchestrators/ceremony.js";
+import { qualifyCodexMessage } from "../../core/utils/message-id.js";
+import { convertToEiMessage, convertToPreMarkedEiMessage } from "../shared/message-converter.js";
+import { getMachineId } from "../machine-id.js";
+import { isProcessRunning } from "../process-check.js";
+import { CodexReader } from "./reader.js";
+import {
+  CODEX_PERSONA_NAME,
+  type CodexSession,
+  type ICodexReader,
+} from "./types.js";
+import { MIN_SESSION_AGE_MS, TWELVE_HOURS_MS } from "../constants.js";
+
+export interface CodexImportResult {
+  sessionsProcessed: number;
+  messagesImported: number;
+  personaCreated: boolean;
+  extractionScansQueued: number;
+}
+
+export interface CodexImporterOptions {
+  stateManager: StateManager;
+  interface?: Ei_Interface;
+  reader?: ICodexReader;
+  signal?: AbortSignal;
+}
+
+const CODEX_GROUP = "Codex";
+
+const qualify = qualifyCodexMessage;
+
+function ensureCodexPersona(
+  stateManager: StateManager,
+  eiInterface?: Ei_Interface
+): PersonaEntity {
+  const existing = stateManager.persona_getByName(CODEX_PERSONA_NAME);
+  if (existing) return existing;
+
+  const now = new Date().toISOString();
+  const seedTraits: PersonaTrait[] = DEFAULT_SEED_TRAITS.map((t) => ({
+    id: crypto.randomUUID(),
+    name: t.name,
+    description: t.description,
+    sentiment: t.sentiment,
+    strength: t.strength,
+    last_updated: now,
+  }));
+
+  const persona: PersonaEntity = {
+    id: crypto.randomUUID(),
+    display_name: CODEX_PERSONA_NAME,
+    entity: "system",
+    aliases: ["codex", "codex cli", "codex desktop", "openai codex"],
+    short_description: "Codex - OpenAI coding agent environment",
+    long_description:
+      "Codex is OpenAI's coding agent environment for working with local codebases, terminal commands, tools, and implementation tasks.",
+    group_primary: CODEX_GROUP,
+    groups_visible: [CODEX_GROUP],
+    traits: seedTraits,
+    topics: [],
+    is_paused: false,
+    is_archived: false,
+    is_static: false,
+    heartbeat_delay_ms: TWELVE_HOURS_MS,
+    last_heartbeat: now,
+    last_updated: now,
+  };
+
+  stateManager.persona_add(persona);
+  eiInterface?.onPersonaAdded?.();
+  return persona;
+}
+
+function updateProcessedState(
+  stateManager: StateManager,
+  session: CodexSession
+): void {
+  const human = stateManager.getHuman();
+  const lastMessageMs = new Date(session.lastMessageAt).getTime();
+  const extractionPoint = human.settings?.codex?.extraction_point;
+  const currentPointMs = extractionPoint ? new Date(extractionPoint).getTime() : 0;
+  const newPointMs = Math.max(currentPointMs, lastMessageMs);
+
+  const processedSessions = {
+    ...(human.settings?.codex?.processed_sessions ?? {}),
+    [session.id]: new Date().toISOString(),
+  };
+
+  stateManager.setHuman({
+    ...human,
+    settings: {
+      ...human.settings,
+      codex: {
+        ...human.settings?.codex,
+        extraction_point: new Date(newPointMs).toISOString(),
+        processed_sessions: processedSessions,
+      },
+    },
+  });
+}
+
+async function isCodexRunning(): Promise<boolean> {
+  return (await isProcessRunning("Codex")) || (await isProcessRunning("codex"));
+}
+
+export async function importCodexSessions(
+  options: CodexImporterOptions
+): Promise<CodexImportResult> {
+  const { stateManager, interface: eiInterface, signal } = options;
+  const reader = options.reader ?? new CodexReader();
+
+  const result: CodexImportResult = {
+    sessionsProcessed: 0,
+    messagesImported: 0,
+    personaCreated: false,
+    extractionScansQueued: 0,
+  };
+
+  const allSessions = await reader.getSessions();
+  if (signal?.aborted) return result;
+
+  const human = stateManager.getHuman();
+  const processedSessions = human.settings?.codex?.processed_sessions ?? {};
+  const now = Date.now();
+  const toolRunning = await isCodexRunning();
+
+  let targetSession: CodexSession | null = null;
+
+  for (const session of allSessions) {
+    const sessionLastMs = new Date(session.lastMessageAt).getTime();
+    const ageMs = now - sessionLastMs;
+
+    if (ageMs < MIN_SESSION_AGE_MS && toolRunning) continue;
+
+    const lastImported = processedSessions[session.id];
+    if (lastImported && sessionLastMs <= new Date(lastImported).getTime()) continue;
+
+    targetSession = session;
+    break;
+  }
+
+  if (!targetSession) {
+    console.log("[Codex] All sessions processed, nothing new to import");
+    return result;
+  }
+
+  if (signal?.aborted) return result;
+
+  console.log(
+    `[Codex] Processing session: "${targetSession.title}" ` +
+      `(last message: ${targetSession.lastMessageAt})`
+  );
+
+  const messages = targetSession.messages;
+  if (messages.length === 0) {
+    updateProcessedState(stateManager, targetSession);
+    return result;
+  }
+
+  if (signal?.aborted) return result;
+
+  const personaExistedBefore = stateManager.persona_getByName(CODEX_PERSONA_NAME) !== null;
+  const persona = ensureCodexPersona(stateManager, eiInterface);
+  result.personaCreated = !personaExistedBefore;
+
+  if (!personaExistedBefore) {
+    stateManager.persona_archive(persona.id);
+  } else {
+    const existingMsgs = stateManager.messages_get(persona.id);
+    const externalIds = existingMsgs.filter((m) => m.external === true).map((m) => m.id);
+    if (externalIds.length > 0) {
+      stateManager.messages_remove(persona.id, externalIds);
+    }
+  }
+
+  const cutoffIso = processedSessions[targetSession.id] ?? null;
+  const cutoffMs = cutoffIso ? new Date(cutoffIso).getTime() : null;
+  const toAnalyze: Message[] = [];
+
+  for (const msg of messages) {
+    const msgMs = new Date(msg.timestamp).getTime();
+    const isOld = cutoffMs !== null && msgMs < cutoffMs;
+    const eiMsg = isOld
+      ? convertToPreMarkedEiMessage(msg, targetSession.id, qualify)
+      : convertToEiMessage(msg, targetSession.id, qualify);
+
+    stateManager.messages_append(persona.id, eiMsg);
+    result.messagesImported++;
+    if (!isOld) toAnalyze.push(eiMsg);
+  }
+
+  stateManager.messages_sort(persona.id);
+  eiInterface?.onMessageAdded?.(persona.id);
+
+  if (toAnalyze.length > 0 && !signal?.aborted) {
+    const allInState = stateManager.messages_get(persona.id);
+    const analyzeIds = new Set(toAnalyze.map((m) => m.id));
+    const analyzeStartIndex = allInState.findIndex((m) => analyzeIds.has(m.id));
+    const contextMsgs = analyzeStartIndex > 0 ? allInState.slice(0, analyzeStartIndex) : [];
+
+    const context: ExtractionContext = {
+      personaId: persona.id,
+      channelDisplayName: persona.display_name,
+      messages_context: contextMsgs,
+      messages_analyze: toAnalyze,
+      sources: [`codex:${getMachineId()}:${targetSession.id}`],
+    };
+
+    queuePersonRewritePhase(stateManager);
+    queueTopicRewritePhase(stateManager);
+    queueAllScans(context, stateManager, {
+      extraction_model: human.settings?.codex?.extraction_model,
+      external_filter: "only",
+    });
+    result.extractionScansQueued += 4;
+  }
+
+  result.sessionsProcessed = 1;
+  updateProcessedState(stateManager, targetSession);
+
+  console.log(
+    `[Codex] Session complete: ${result.messagesImported} messages imported, ` +
+      `${result.extractionScansQueued} extraction scans queued`
+  );
+
+  return result;
+}

package/src/integrations/codex/index.ts

@@ -0,0 +1,11 @@
+export { CodexReader } from "./reader.js";
+export { importCodexSessions } from "./importer.js";
+export type { CodexImportResult, CodexImporterOptions } from "./importer.js";
+export type {
+  CodexMessage,
+  CodexMessageWindow,
+  CodexSession,
+  CodexSettings,
+  ICodexReader,
+} from "./types.js";
+export { CODEX_PERSONA_NAME } from "./types.js";

package/src/integrations/codex/reader.ts

@@ -0,0 +1,241 @@
+import type {
+  CodexMessage,
+  CodexMessageWindow,
+  CodexRolloutRecord,
+  CodexSession,
+  CodexThreadRow,
+  ICodexReader,
+} from "./types.js";
+
+const isBrowser = typeof document !== "undefined";
+
+let _join: typeof import("path").join;
+let _basename: typeof import("path").basename;
+let _readFile: typeof import("fs/promises").readFile;
+let _readdir: typeof import("fs/promises").readdir;
+let _stat: typeof import("fs/promises").stat;
+let _nodeModulesLoaded = false;
+
+async function ensureNodeModules(): Promise<boolean> {
+  if (isBrowser) return false;
+  if (_nodeModulesLoaded) return true;
+
+  const PATH_MODULE = "path";
+  const FS_MODULE = "fs/promises";
+
+  const pathMod = await import(/* @vite-ignore */ PATH_MODULE);
+  const fsMod = await import(/* @vite-ignore */ FS_MODULE);
+
+  _join = pathMod.join;
+  _basename = pathMod.basename;
+  _readFile = fsMod.readFile;
+  _readdir = fsMod.readdir;
+  _stat = fsMod.stat;
+  _nodeModulesLoaded = true;
+  return true;
+}
+
+function getDefaultCodexHome(): string {
+  if (!_join) return "";
+  return process.env.CODEX_HOME || _join(process.env.HOME || "~", ".codex");
+}
+
+function titleFromCwd(cwd: string): string {
+  if (!cwd) return "Codex Session";
+  const parts = cwd.replace(/\\/g, "/").split("/").filter(Boolean);
+  return parts[parts.length - 1] ?? cwd;
+}
+
+function timestampFromMs(value: number | null | undefined): string | null {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return null;
+  return new Date(value).toISOString();
+}
+
+function extractEventMessage(record: CodexRolloutRecord, lineIndex: number, sessionId: string): CodexMessage | null {
+  if (record.type !== "event_msg") return null;
+
+  const payload = record.payload ?? {};
+  const payloadType = payload.type;
+  if (payloadType !== "user_message" && payloadType !== "agent_message") return null;
+
+  const rawMessage = payload.message;
+  if (typeof rawMessage !== "string" || rawMessage.trim() === "") return null;
+
+  const timestamp = typeof record.timestamp === "string" && record.timestamp.trim()
+    ? record.timestamp
+    : new Date(0).toISOString();
+
+  return {
+    id: `evt_${lineIndex + 1}`,
+    sessionId,
+    role: payloadType === "user_message" ? "user" : "assistant",
+    content: rawMessage.trim(),
+    timestamp,
+  };
+}
+
+export function parseCodexRolloutMessages(text: string, sessionId: string): CodexMessage[] {
+  const messages: CodexMessage[] = [];
+  const lines = text.split("\n");
+
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed) continue;
+
+    let record: CodexRolloutRecord;
+    try {
+      record = JSON.parse(trimmed) as CodexRolloutRecord;
+    } catch {
+      continue;
+    }
+
+    const message = extractEventMessage(record, i, sessionId);
+    if (message) messages.push(message);
+  }
+
+  return messages.sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+}
+
+export class CodexReader implements ICodexReader {
+  private readonly codexHome?: string;
+
+  constructor(codexHome?: string) {
+    this.codexHome = codexHome;
+  }
+
+  async isAvailable(): Promise<boolean> {
+    if (!(await ensureNodeModules())) return false;
+    const dbPath = await this.findStateDbPath();
+    if (!dbPath) return false;
+
+    try {
+      return (await _stat(dbPath)).isFile();
+    } catch {
+      return false;
+    }
+  }
+
+  async getSessions(): Promise<CodexSession[]> {
+    if (!(await ensureNodeModules())) return [];
+
+    const dbPath = await this.findStateDbPath();
+    if (!dbPath) return [];
+
+    let db: import("bun:sqlite").Database;
+    try {
+      const { Database } = await import(/* @vite-ignore */ "bun:sqlite");
+      db = new Database(dbPath, { readonly: true });
+    } catch (err) {
+      console.warn("[CodexReader] failed to open state DB:", err);
+      return [];
+    }
+
+    let rows: CodexThreadRow[];
+    try {
+      rows = db.query("SELECT * FROM threads WHERE rollout_path IS NOT NULL AND rollout_path != ''").all() as CodexThreadRow[];
+    } catch (err) {
+      console.warn("[CodexReader] failed to read threads table:", err);
+      db.close();
+      return [];
+    }
+
+    db.close();
+
+    const sessions: CodexSession[] = [];
+    for (const row of rows) {
+      if (!row.id || !row.rollout_path) continue;
+      const session = await this.sessionFromThreadRow(row);
+      if (session) sessions.push(session);
+    }
+
+    return sessions.sort(
+      (a, b) => new Date(a.lastMessageAt).getTime() - new Date(b.lastMessageAt).getTime()
+    );
+  }
+
+  async getMessageById(
+    sessionId: string,
+    messageId: string,
+    before = 0,
+    after = 0
+  ): Promise<CodexMessageWindow | null> {
+    const sessions = await this.getSessions();
+    const session = sessions.find((s) => s.id === sessionId);
+    if (!session) return null;
+
+    const idx = session.messages.findIndex((m) => m.id === messageId);
+    if (idx === -1) return null;
+
+    return {
+      message: session.messages[idx],
+      before: session.messages.slice(Math.max(0, idx - before), idx),
+      after: session.messages.slice(idx + 1, idx + 1 + after),
+      session,
+    };
+  }
+
+  private async findStateDbPath(): Promise<string | null> {
+    const base = this.codexHome ?? getDefaultCodexHome();
+    let entries: string[];
+    try {
+      entries = await _readdir(base);
+    } catch {
+      return null;
+    }
+
+    const stateDbs = entries
+      .map((name) => {
+        const match = name.match(/^state_(\d+)\.sqlite$/);
+        return match ? { name, version: Number(match[1]) } : null;
+      })
+      .filter((entry): entry is { name: string; version: number } => entry !== null)
+      .sort((a, b) => b.version - a.version);
+
+    if (stateDbs.length > 0) return _join(base, stateDbs[0].name);
+    if (entries.includes("state.sqlite")) return _join(base, "state.sqlite");
+    return null;
+  }
+
+  private async sessionFromThreadRow(row: CodexThreadRow): Promise<CodexSession | null> {
+    const rolloutPath = row.rollout_path;
+    if (!rolloutPath) return null;
+
+    const messages = await this.readMessages(row.id, rolloutPath);
+    if (messages.length === 0) return null;
+
+    const first = messages[0];
+    const last = messages[messages.length - 1];
+    const title = row.title?.trim()
+      || row.first_user_message?.trim()
+      || titleFromCwd(row.cwd ?? "");
+
+    return {
+      id: row.id,
+      title,
+      cwd: row.cwd ?? "",
+      source: row.source ?? undefined,
+      threadSource: row.thread_source ?? undefined,
+      agentNickname: row.agent_nickname ?? undefined,
+      agentRole: row.agent_role ?? undefined,
+      agentPath: row.agent_path ?? undefined,
+      rolloutPath,
+      firstMessageAt: first.timestamp || timestampFromMs(row.created_at_ms) || timestampFromMs(row.created_at) || new Date(0).toISOString(),
+      lastMessageAt: last.timestamp || timestampFromMs(row.updated_at_ms) || timestampFromMs(row.updated_at) || new Date(0).toISOString(),
+      messages,
+    };
+  }
+
+  private async readMessages(sessionId: string, rolloutPath: string): Promise<CodexMessage[]> {
+    let text: string;
+    try {
+      text = await _readFile(rolloutPath, "utf-8");
+    } catch (err) {
+      console.warn(`[CodexReader] skipping missing rollout ${_basename(rolloutPath)}:`, err);
+      return [];
+    }
+
+    return parseCodexRolloutMessages(text, sessionId);
+  }
+}