ei-tui 0.1.3

package/tui/src/context/keyboard.tsx

@@ -0,0 +1,164 @@
+import {
+  createContext,
+  useContext,
+  createSignal,
+  type ParentComponent,
+  type Accessor,
+} from "solid-js";
+import { useKeyboard, useRenderer } from "@opentui/solid";
+import type { ScrollBoxRenderable, KeyEvent, TextareaRenderable, CliRenderer } from "@opentui/core";
+import type { PersonaSummary } from "../../../src/core/types.js";
+import { useEi } from "./ei";
+import { logger } from "../util/logger";
+
+export type Panel = "sidebar" | "messages" | "input";
+
+interface KeyboardContextValue {
+  focusedPanel: Accessor<Panel>;
+  setFocusedPanel: (panel: Panel) => void;
+  registerMessageScroll: (scrollbox: ScrollBoxRenderable) => void;
+  registerTextarea: (textarea: TextareaRenderable) => void;
+  registerEditorHandler: (handler: () => Promise<void>) => void;
+  sidebarVisible: Accessor<boolean>;
+  toggleSidebar: () => void;
+  exitApp: () => Promise<void>;
+  renderer: CliRenderer;
+}
+
+const KeyboardContext = createContext<KeyboardContextValue>();
+
+export const KeyboardProvider: ParentComponent = (props) => {
+  const [focusedPanel, setFocusedPanel] = createSignal<Panel>("input");
+  const [sidebarVisible, setSidebarVisible] = createSignal(true);
+  const renderer = useRenderer();
+  const { queueStatus, abortCurrentOperation, resumeQueue, personas, activePersonaId, selectPersona, saveAndExit, showNotification } = useEi();
+  
+  let messageScrollRef: ScrollBoxRenderable | null = null;
+  let textareaRef: TextareaRenderable | null = null;
+  let editorHandler: (() => Promise<void>) | null = null;
+
+  const registerMessageScroll = (scrollbox: ScrollBoxRenderable) => {
+    messageScrollRef = scrollbox;
+  };
+
+  const registerTextarea = (textarea: TextareaRenderable) => {
+    textareaRef = textarea;
+  };
+
+  const registerEditorHandler = (handler: () => Promise<void>) => {
+    editorHandler = handler;
+  };
+
+  const toggleSidebar = () => setSidebarVisible(!sidebarVisible());
+
+  const exitApp = async () => {
+    const result = await saveAndExit();
+    if (!result.success) {
+      showNotification(`Sync failed: ${result.error}. Use /quit force to exit anyway.`, "error");
+      return;
+    }
+    renderer.setTerminalTitle("");
+    renderer.destroy();
+    process.exit(0);
+  };
+
+  useKeyboard((event: KeyEvent) => {
+    if (event.name === "tab") {
+      event.preventDefault();
+      if (textareaRef && textareaRef.plainText.length > 0) return;
+      
+      const unarchived = personas().filter((p: PersonaSummary) => !p.is_archived);
+      if (unarchived.length <= 1) return;
+      
+      const current = activePersonaId();
+      const currentIndex = unarchived.findIndex((p: PersonaSummary) => p.id === current);
+      
+      let nextIndex: number;
+      if (event.shift) {
+        nextIndex = (currentIndex - 1 + unarchived.length) % unarchived.length;
+      } else {
+        nextIndex = (currentIndex + 1) % unarchived.length;
+      }
+      selectPersona(unarchived[nextIndex].id);
+      return;
+    }
+
+    if (event.name === "b" && event.ctrl) {
+      event.preventDefault();
+      toggleSidebar();
+      return;
+    }
+
+    if (event.name === "e" && event.ctrl) {
+      event.preventDefault();
+      if (editorHandler) {
+        void editorHandler();
+      }
+      return;
+    }
+
+    if (event.name === "c" && event.ctrl) {
+      event.preventDefault();
+      
+      if (textareaRef && textareaRef.plainText.length > 0) {
+        logger.info("Ctrl+C pressed - clearing input");
+        textareaRef.clear();
+      } else {
+        void exitApp();
+      }
+      return;
+    }
+
+    if (event.name === "escape") {
+      event.preventDefault();
+      const status = queueStatus();
+      
+      if (status.state === "busy") {
+        logger.info("Escape pressed - aborting current operation");
+        void abortCurrentOperation();
+      } else if (status.state === "paused") {
+        logger.info("Escape pressed - resuming queue");
+        void resumeQueue();
+      }
+      return;
+    }
+
+    if (!messageScrollRef) return;
+
+    const scrollAmount = messageScrollRef.height;
+    
+    if (event.name === "pageup") {
+      event.preventDefault();
+      messageScrollRef.scrollBy(-scrollAmount);
+    } else if (event.name === "pagedown") {
+      event.preventDefault();
+      messageScrollRef.scrollBy(scrollAmount);
+    }
+  });
+
+  const value: KeyboardContextValue = {
+    focusedPanel,
+    setFocusedPanel,
+    registerMessageScroll,
+    registerTextarea,
+    registerEditorHandler,
+    sidebarVisible,
+    toggleSidebar,
+    exitApp,
+    renderer,
+  };
+
+  return (
+    <KeyboardContext.Provider value={value}>
+      {props.children}
+    </KeyboardContext.Provider>
+  );
+};
+
+export const useKeyboardNav = () => {
+  const ctx = useContext(KeyboardContext);
+  if (!ctx) {
+    throw new Error("useKeyboardNav must be used within KeyboardProvider");
+  }
+  return ctx;
+};

package/tui/src/context/overlay.tsx

@@ -0,0 +1,53 @@
+import {
+  createContext,
+  useContext,
+  createSignal,
+  type ParentComponent,
+  type JSX,
+  type Accessor,
+} from "solid-js";
+import { logger } from "../util/logger";
+
+export type OverlayRenderer = (hideOverlay: () => void) => JSX.Element;
+
+interface OverlayContextValue {
+  overlayRenderer: Accessor<OverlayRenderer | null>;
+  showOverlay: (renderer: OverlayRenderer) => void;
+  hideOverlay: () => void;
+}
+
+const OverlayContext = createContext<OverlayContextValue>();
+
+export const OverlayProvider: ParentComponent = (props) => {
+  const [overlayRenderer, setOverlayRenderer] = createSignal<OverlayRenderer | null>(null);
+
+  const showOverlay = (renderer: OverlayRenderer) => {
+    logger.debug("[overlay] showOverlay called");
+    setOverlayRenderer(() => renderer);
+  };
+
+  const hideOverlay = () => {
+    logger.debug("[overlay] hideOverlay called");
+    setOverlayRenderer(null);
+  };
+
+  const value: OverlayContextValue = {
+    overlayRenderer,
+    showOverlay,
+    hideOverlay,
+  };
+
+  return (
+    <OverlayContext.Provider value={value}>
+      {props.children}
+    </OverlayContext.Provider>
+  );
+};
+
+export const useOverlay = () => {
+  const ctx = useContext(OverlayContext);
+  if (!ctx) {
+    throw new Error("useOverlay must be used within OverlayProvider");
+  }
+  return ctx;
+};

package/tui/src/index.tsx

@@ -0,0 +1,8 @@
+import { render } from "@opentui/solid";
+import { App } from "./app";
+
+render(App, {
+  exitOnCtrlC: false,
+  targetFps: 30,
+  useAlternateScreen: true,
+});

package/tui/src/storage/file.ts

@@ -0,0 +1,185 @@
+import type { StorageState } from "../../../src/core/types";
+import type { Storage } from "../../../src/storage/interface";
+import { join } from "path";
+import { mkdir, rename, unlink } from "fs/promises";
+
+const STATE_FILE = "state.json";
+const BACKUP_FILE = "state.backup.json";
+const LOCK_TIMEOUT_MS = 5000;
+const LOCK_RETRY_DELAY_MS = 50;
+
+export class FileStorage implements Storage {
+  private dataPath: string;
+
+  constructor(dataPath?: string) {
+    if (dataPath) {
+      this.dataPath = dataPath;
+    } else if (process.env.EI_DATA_PATH) {
+      this.dataPath = process.env.EI_DATA_PATH;
+    } else {
+      const xdgData = process.env.XDG_DATA_HOME || join(process.env.HOME || "~", ".local", "share");
+      this.dataPath = join(xdgData, "ei");
+    }
+  }
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      await this.ensureDataDir();
+      const testFile = join(this.dataPath, "__ei_storage_test__");
+      await Bun.write(testFile, "1");
+      await Bun.write(testFile, "");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async save(state: StorageState): Promise<void> {
+    await this.ensureDataDir();
+    const filePath = join(this.dataPath, STATE_FILE);
+    state.timestamp = new Date().toISOString();
+
+    await this.withLock(filePath, async () => {
+      try {
+        await this.atomicWrite(filePath, JSON.stringify(state, null, 2));
+      } catch (e) {
+        if (this.isQuotaError(e)) {
+          throw new Error("STORAGE_SAVE_FAILED: Disk quota exceeded");
+        }
+        throw e;
+      }
+    });
+  }
+
+  async load(): Promise<StorageState | null> {
+    const filePath = join(this.dataPath, STATE_FILE);
+    const file = Bun.file(filePath);
+    
+    if (await file.exists()) {
+      try {
+        const text = await file.text();
+        if (text) {
+          return JSON.parse(text) as StorageState;
+        }
+      } catch {
+        return null;
+      }
+    }
+
+    return null;
+  }
+
+  async moveToBackup(): Promise<void> {
+    const statePath = join(this.dataPath, STATE_FILE);
+    const backupPath = join(this.dataPath, BACKUP_FILE);
+    const stateFile = Bun.file(statePath);
+    
+    if (await stateFile.exists()) {
+      await rename(statePath, backupPath);
+    }
+  }
+
+
+  /**
+   * Read backup state without removing it.
+   * Used to peek sync credentials from a previous session's backup.
+   */
+  async loadBackup(): Promise<StorageState | null> {
+    const backupPath = join(this.dataPath, BACKUP_FILE);
+    const backupFile = Bun.file(backupPath);
+
+    if (await backupFile.exists()) {
+      try {
+        const text = await backupFile.text();
+        if (text) {
+          return JSON.parse(text) as StorageState;
+        }
+      } catch {
+        return null;
+      }
+    }
+
+    return null;
+  }
+
+  private async ensureDataDir(): Promise<void> {
+    try {
+      await mkdir(this.dataPath, { recursive: true });
+    } catch {
+      return;
+    }
+  }
+
+  private isQuotaError(e: unknown): boolean {
+    return (
+      e instanceof Error &&
+      (e.message.includes("ENOSPC") || e.message.includes("quota"))
+    );
+  }
+
+  private async atomicWrite(filePath: string, content: string): Promise<void> {
+    const tempPath = `${filePath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
+    try {
+      await Bun.write(tempPath, content);
+      await rename(tempPath, filePath);
+    } catch (e) {
+      try {
+        await unlink(tempPath);
+      } catch {}
+      throw e;
+    }
+  }
+
+  private getLockPath(filePath: string): string {
+    return `${filePath}.lock`;
+  }
+
+  private async acquireLock(filePath: string): Promise<boolean> {
+    const lockPath = this.getLockPath(filePath);
+    const startTime = Date.now();
+
+    while (Date.now() - startTime < LOCK_TIMEOUT_MS) {
+      const lockFile = Bun.file(lockPath);
+      if (await lockFile.exists()) {
+        const lockContent = await lockFile.text();
+        const lockTime = parseInt(lockContent, 10);
+        if (!isNaN(lockTime) && Date.now() - lockTime > LOCK_TIMEOUT_MS) {
+          try {
+            await unlink(lockPath);
+          } catch {}
+        } else {
+          await new Promise((r) => setTimeout(r, LOCK_RETRY_DELAY_MS));
+          continue;
+        }
+      }
+
+      try {
+        await Bun.write(lockPath, Date.now().toString());
+        return true;
+      } catch {
+        await new Promise((r) => setTimeout(r, LOCK_RETRY_DELAY_MS));
+      }
+    }
+
+    return false;
+  }
+
+  private async releaseLock(filePath: string): Promise<void> {
+    const lockPath = this.getLockPath(filePath);
+    try {
+      await unlink(lockPath);
+    } catch {}
+  }
+
+  private async withLock<T>(filePath: string, fn: () => Promise<T>): Promise<T> {
+    const acquired = await this.acquireLock(filePath);
+    if (!acquired) {
+      throw new Error("STORAGE_LOCK_TIMEOUT: Could not acquire file lock");
+    }
+    try {
+      return await fn();
+    } finally {
+      await this.releaseLock(filePath);
+    }
+  }
+}

package/tui/src/util/duration.ts

@@ -0,0 +1,32 @@
+const MINUTE = 60 * 1000;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+const WEEK = 7 * DAY;
+
+const MULTIPLIERS: Record<string, number> = {
+  m: MINUTE,
+  min: MINUTE,
+  h: HOUR,
+  hour: HOUR,
+  d: DAY,
+  day: DAY,
+  w: WEEK,
+  week: WEEK,
+};
+
+export function parseDuration(input: string): number | null {
+  const match = input.match(/^(\d+)(m|min|h|hour|d|day|w|week)s?$/i);
+  if (!match) return null;
+  
+  const value = parseInt(match[1], 10);
+  const unit = match[2].toLowerCase();
+  
+  return value * (MULTIPLIERS[unit] || 0);
+}
+
+export function formatDuration(ms: number): string {
+  if (ms >= WEEK) return `${Math.floor(ms / WEEK)}w`;
+  if (ms >= DAY) return `${Math.floor(ms / DAY)}d`;
+  if (ms >= HOUR) return `${Math.floor(ms / HOUR)}h`;
+  return `${Math.floor(ms / MINUTE)}m`;
+}

package/tui/src/util/editor.ts

@@ -0,0 +1,188 @@
+import { spawn } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import type { CliRenderer } from "@opentui/core";
+import { logger } from "./logger";
+
+export interface EditorOptions {
+  initialContent: string;
+  filename: string;
+  renderer: CliRenderer;
+}
+
+export interface EditorRawOptions {
+  initialContent: string;
+  filename: string;
+}
+
+export interface EditorResult {
+  success: boolean;
+  content: string | null;
+  aborted: boolean;
+}
+
+export async function spawnEditorRaw(options: EditorRawOptions): Promise<EditorResult> {
+  const { initialContent, filename } = options;
+  const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+  const tmpDir = os.tmpdir();
+  const safeName = filename.replace(/\s+/g, "-");
+  const tmpFile = path.join(tmpDir, `ei-${Date.now()}-${safeName}`);
+  
+  logger.debug("[editor] spawnEditorRaw called", { filename, editor });
+  
+  fs.writeFileSync(tmpFile, initialContent, "utf-8");
+  const originalContent = initialContent;
+  
+  return new Promise((resolve) => {
+    logger.debug("[editor] spawning editor process (raw)");
+    const child = spawn(editor, [tmpFile], {
+      stdio: "inherit",
+      shell: true,
+    });
+    
+    child.on("error", () => {
+      logger.error("[editor] editor process error (raw)");
+      try { fs.unlinkSync(tmpFile); } catch {}
+      resolve({
+        success: false,
+        content: null,
+        aborted: false,
+      });
+    });
+    
+    child.on("exit", (code) => {
+      logger.debug("[editor] editor process exited (raw)", { code });
+      
+      if (code !== 0) {
+        try { fs.unlinkSync(tmpFile); } catch {}
+        resolve({
+          success: false,
+          content: null,
+          aborted: true,
+        });
+        return;
+      }
+      
+      let editedContent: string;
+      try {
+        editedContent = fs.readFileSync(tmpFile, "utf-8");
+      } catch {
+        resolve({
+          success: false,
+          content: null,
+          aborted: false,
+        });
+        return;
+      } finally {
+        try { fs.unlinkSync(tmpFile); } catch {}
+      }
+      
+      if (editedContent === originalContent) {
+        resolve({
+          success: true,
+          content: null,
+          aborted: false,
+        });
+        return;
+      }
+      
+      resolve({
+        success: true,
+        content: editedContent,
+        aborted: false,
+      });
+    });
+  });
+}
+
+export async function spawnEditor(options: EditorOptions): Promise<EditorResult> {
+  const { initialContent, filename, renderer } = options;
+  const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+  const tmpDir = os.tmpdir();
+  const safeName = filename.replace(/\s+/g, "-");
+  const tmpFile = path.join(tmpDir, `ei-${Date.now()}-${safeName}`);
+  
+  logger.debug("[editor] spawnEditor called", { filename, editor });
+  
+  fs.writeFileSync(tmpFile, initialContent, "utf-8");
+  const originalContent = initialContent;
+  
+  return new Promise((resolve) => {
+    logger.debug("[editor] calling renderer.suspend()");
+    renderer.suspend();
+    logger.debug("[editor] calling renderer.currentRenderBuffer.clear()");
+    renderer.currentRenderBuffer.clear();
+    
+    logger.debug("[editor] spawning editor process");
+    const child = spawn(editor, [tmpFile], {
+      stdio: "inherit",
+      shell: true,
+    });
+    
+    child.on("error", () => {
+      logger.error("[editor] editor process error");
+      renderer.currentRenderBuffer.clear();
+      renderer.resume();
+      renderer.requestRender();
+      try { fs.unlinkSync(tmpFile); } catch {}
+      resolve({
+        success: false,
+        content: null,
+        aborted: false,
+      });
+    });
+    
+    child.on("exit", (code) => {
+      logger.debug("[editor] editor process exited", { code });
+      logger.debug("[editor] calling renderer.currentRenderBuffer.clear()");
+      renderer.currentRenderBuffer.clear();
+      logger.debug("[editor] calling renderer.resume()");
+      renderer.resume();
+      logger.debug("[editor] queueMicrotask for requestRender");
+      queueMicrotask(() => {
+        logger.debug("[editor] calling renderer.requestRender()");
+        renderer.requestRender();
+      });
+      
+      if (code !== 0) {
+        try { fs.unlinkSync(tmpFile); } catch {}
+        resolve({
+          success: false,
+          content: null,
+          aborted: true,
+        });
+        return;
+      }
+      
+      let editedContent: string;
+      try {
+        editedContent = fs.readFileSync(tmpFile, "utf-8");
+      } catch {
+        resolve({
+          success: false,
+          content: null,
+          aborted: false,
+        });
+        return;
+      } finally {
+        try { fs.unlinkSync(tmpFile); } catch {}
+      }
+      
+      if (editedContent === originalContent) {
+        resolve({
+          success: true,
+          content: null,
+          aborted: false,
+        });
+        return;
+      }
+      
+      resolve({
+        success: true,
+        content: editedContent,
+        aborted: false,
+      });
+    });
+  });
+}