ei-tui 1.6.9 → 1.7.0

package/src/core/state/personas.ts

@@ -80,6 +80,14 @@ export class PersonaState {
     return true;
   }
 
+  /** Full replace of a persona's entity (not a merge) — used by the live-drain path for corrections-queue upserts, where record.record is already a complete PersonaEntity and any field genuinely absent from it must NOT survive from the prior value. Preserves .messages untouched, same as update(). */
+  replace(personaId: string, entity: PersonaEntity): boolean {
+    const data = this.personas.get(personaId);
+    if (!data) return false;
+    data.entity = { ...entity, last_updated: new Date().toISOString() };
+    return true;
+  }
+
   archive(personaId: string): boolean {
     const data = this.personas.get(personaId);
     if (!data) return false;

package/src/core/state-manager.ts

@@ -715,6 +715,11 @@ export class StateManager {
     this.scheduleSave();
   }
 
+  human_quote_upsert(quote: Quote): void {
+    this.humanState.quote_upsert(quote);
+    this.scheduleSave();
+  }
+
   human_quote_update(id: string, updates: Partial<Quote>): boolean {
     const result = this.humanState.quote_update(id, updates);
     this.scheduleSave();
@@ -758,6 +763,12 @@ export class StateManager {
     return result;
   }
 
+  persona_replace(personaId: string, entity: PersonaEntity): boolean {
+    const result = this.personaState.replace(personaId, entity);
+    this.scheduleSave();
+    return result;
+  }
+
   persona_archive(personaId: string): boolean {
     const result = this.personaState.archive(personaId);
     this.scheduleSave();

package/src/core/utils/identifier-utils.ts

@@ -1,4 +1,5 @@
 import type { PersonIdentifier } from "../types/data-items.js";
+import type { PersonaEntity } from "../types/entities.js";
 import type { StateManager } from "../state-manager.js";
 import { BUILT_IN_IDENTIFIER_TYPES } from "../constants/built-in-identifier-types.js";
 
@@ -29,12 +30,12 @@ export function normalizeIdentifierType(llmType: string, state: StateManager): s
 
 export function sanitizeEiPersonaIdentifiers(
   identifiers: PersonIdentifier[],
-  state: StateManager
+  personas: PersonaEntity[]
 ): PersonIdentifier[] {
   return identifiers.map(id => {
     if (id.type !== 'Ei Persona' && id.type !== 'AI Persona') return id;
     if (UUID_REGEX.test(id.value)) return { ...id, type: 'Ei Persona' };
-    const matched = state.persona_getAll().find(p =>
+    const matched = personas.find(p =>
       p.display_name === id.value || p.aliases?.includes(id.value)
     );
     if (matched) return { ...id, type: 'Ei Persona', value: matched.id };

package/src/storage/file-lock.ts

@@ -0,0 +1,120 @@
+/**
+ * File-based advisory locking + atomic writes, shared by any Storage
+ * implementation (and CLI tooling) that needs to serialize writes to a
+ * JSON file on disk without a database.
+ *
+ * Extracted from tui/src/storage/file.ts so the CLI's corrections.json
+ * writer/drainer can use identical lock semantics instead of forking a
+ * second implementation.
+ *
+ * fs/promises is imported dynamically per-function, not statically at
+ * module scope: this module is transitively imported by src/core/corrections.ts
+ * -> src/core/processor.ts, which Web's Vite build bundles for the browser.
+ * A static `import { readFile } from "fs/promises"` makes rollup try to
+ * resolve named exports against Vite's browser-externalized stub, which
+ * has none — that's a hard build failure, not a runtime one (same pattern
+ * already used in src/cli.ts and src/cli/install.ts for this exact reason).
+ */
+
+const LOCK_TIMEOUT_MS = 5000;
+const LOCK_RETRY_DELAY_MS = 50;
+
+// Plain executor form, not Promise.withResolvers — this module runs on
+// whatever Node the CLI/TUI ships with, and withResolvers only landed in
+// Node 22. No behavior difference, just broader runtime compatibility.
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function getLockPath(filePath: string): string {
+  return `${filePath}.lock`;
+}
+
+/**
+ * Acquire an advisory lock on filePath. Stale locks (older than
+ * LOCK_TIMEOUT_MS) are broken automatically. Returns false if the lock
+ * could not be acquired within LOCK_TIMEOUT_MS.
+ */
+export async function acquireLock(filePath: string): Promise<boolean> {
+  const { readFile, writeFile, unlink } = await import(/* @vite-ignore */ "fs/promises");
+  const lockPath = getLockPath(filePath);
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < LOCK_TIMEOUT_MS) {
+    // readFile throws ENOENT when the lock is absent — treated the same as
+    // "lock vanished mid-read" below: proceed straight to acquire.
+    let lockContent: string | null = null;
+    try {
+      lockContent = await readFile(lockPath, "utf-8");
+    } catch {
+      lockContent = null;
+    }
+
+    if (lockContent !== null) {
+      const lockTime = parseInt(lockContent, 10);
+      if (!isNaN(lockTime) && Date.now() - lockTime > LOCK_TIMEOUT_MS) {
+        try {
+          await unlink(lockPath);
+        } catch {}
+      } else {
+        await delay(LOCK_RETRY_DELAY_MS);
+        continue;
+      }
+    }
+
+    try {
+      // "wx" = exclusive create, fails with EEXIST if the path already
+      // exists. Without this flag, two callers that both observed the lock
+      // as absent (the check above) could both reach this writeFile and
+      // both succeed — writeFile has no atomicity of its own, it just
+      // overwrites. "wx" makes the write itself the atomic test-and-set:
+      // only one caller can win it, the other gets EEXIST and falls into
+      // the catch below to retry from the top of the loop.
+      await writeFile(lockPath, Date.now().toString(), { flag: "wx" });
+      return true;
+    } catch {
+      await delay(LOCK_RETRY_DELAY_MS);
+    }
+  }
+
+  return false;
+}
+
+export async function releaseLock(filePath: string): Promise<void> {
+  const { unlink } = await import(/* @vite-ignore */ "fs/promises");
+  const lockPath = getLockPath(filePath);
+  try {
+    await unlink(lockPath);
+  } catch {}
+}
+
+/**
+ * Run fn() while holding filePath's advisory lock. Throws
+ * STORAGE_LOCK_TIMEOUT if the lock can't be acquired in time.
+ */
+export async function withLock<T>(filePath: string, fn: () => Promise<T>): Promise<T> {
+  const acquired = await acquireLock(filePath);
+  if (!acquired) {
+    throw new Error("STORAGE_LOCK_TIMEOUT: Could not acquire file lock");
+  }
+  try {
+    return await fn();
+  } finally {
+    await releaseLock(filePath);
+  }
+}
+
+/** Write content to filePath via temp-file + rename, so readers never see a partial write. */
+export async function atomicWrite(filePath: string, content: string): Promise<void> {
+  const { writeFile, rename, unlink } = await import(/* @vite-ignore */ "fs/promises");
+  const tempPath = `${filePath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
+  try {
+    await writeFile(tempPath, content);
+    await rename(tempPath, filePath);
+  } catch (e) {
+    try {
+      await unlink(tempPath);
+    } catch {}
+    throw e;
+  }
+}

package/tui/README.md

@@ -174,6 +174,8 @@ Rooms have three modes, set at creation time:
 | `/tools` | | Manage tool providers — enable/disable tools per persona |
 | `/auth <service>` | | Authenticate with an external service via OAuth. Supported: `spotify`, `slack` |
 
+> Disabling a tool provider hides its tools from `/details`' YAML editor, but doesn't revoke them — a persona's grants for a disabled provider's tools survive an unrelated `/details` edit and reappear once you re-enable the provider with `/tools` or `/provider`.
+
 ### Editor
 
 | Command | Aliases | Description |

package/tui/src/commands/provider.tsx

@@ -48,7 +48,7 @@ export async function openModelOverlay(ctx: Parameters<Command["execute"]>[1]):
   const models = await buildModelList(ctx);
 
   if (models.length === 0) {
-    ctx.showNotification("No models configured. Use /provider new to create one.", "info");
+    await createProviderViaEditor(ctx);
     return;
   }
 

package/tui/src/components/WelcomeOverlay.tsx

@@ -90,9 +90,9 @@ export function WelcomeOverlay(props: WelcomeOverlayProps) {
         <box visible={!hasAny()} flexDirection="column">
           <text fg="#dc322f">No LLM provider detected.</text>
           <text> </text>
-          <text fg="#93a1a1">Start LMStudio (port 1234) or Ollama (port 11434), or</text>
-          <text fg="#93a1a1">set one of: ANTHROPIC_API_KEY, OPENAI_API_KEY, GROQ_API_KEY,</text>
-          <text fg="#93a1a1">MISTRAL_API_KEY, GEMINI_API_KEY and restart.</text>
+          <text fg="#93a1a1">Use /provider new to configure one manually, or</text>
+          <text fg="#93a1a1">start LMStudio (port 1234) / Ollama (port 11434), or</text>
+          <text fg="#93a1a1">set ANTHROPIC_API_KEY, OPENAI_API_KEY, etc. and restart.</text>
         </box>
 
         <text> </text>

package/tui/src/context/ei.tsx

@@ -3,6 +3,7 @@ import {
   useContext,
   onMount,
   onCleanup,
+  For,
   Match,
   Switch,
   createSignal,
@@ -183,6 +184,7 @@ export const EiProvider: ParentComponent = (props) => {
   const [showWelcomeOverlay, setShowWelcomeOverlay] = createSignal(false);
   const [detectedProviders, setDetectedProviders] = createSignal<ProviderDetectionStatus[]>([]);
   const [firstBootDefaultModel, setFirstBootDefaultModel] = createSignal<string | undefined>(undefined);
+  const [bootError, setBootError] = createSignal<string | null>(null);
   const [conflictData, setConflictData] = createSignal<StateConflictData | null>(null);
 
   let processor: Processor | null = null;
@@ -970,6 +972,7 @@ export const EiProvider: ParentComponent = (props) => {
       await finishBootstrap();
     } catch (err: any) {
       logger.error(`bootstrap() failed: ${err?.message || err}`);
+      setBootError(err?.message || String(err));
     }
   }
 
@@ -1089,6 +1092,17 @@ export const EiProvider: ParentComponent = (props) => {
       <Match when={store.ready}>
         <EiContext.Provider value={value}>{props.children}</EiContext.Provider>
       </Match>
+      <Match when={bootError()}>
+        <box width="100%" height="100%" justifyContent="center" alignItems="center" flexDirection="column">
+          <text fg="#dc322f">Ei failed to start</text>
+          <text> </text>
+          <For each={bootError()!.split('\n')}>
+            {(line) => <text fg="#93a1a1">{line || " "}</text>}
+          </For>
+          <text> </text>
+          <text fg="#586e75">Press Ctrl+C to exit</text>
+        </box>
+      </Match>
       <Match when={!store.ready}>
         <box width="100%" height="100%" justifyContent="center" alignItems="center">
           <text>Loading Ei...</text>

package/tui/src/index.tsx

@@ -14,7 +14,19 @@ if (args.includes("--version") || args.includes("version") || args.includes("-v"
 
 const storage = new FileStorage(Bun.env.EI_DATA_PATH);
 const lock = new InstanceLock(storage.getDataPath());
-const lockResult = await lock.acquire();
+const lockResult = await lock.acquire().catch((e) => {
+  const msg = e instanceof Error ? e.message : String(e);
+  const dataPath = storage.getDataPath();
+  process.stderr.write(
+    `\nEi cannot start: cannot write to data directory.\n\n` +
+    `  Path:  ${dataPath}\n` +
+    `  Error: ${msg}\n\n` +
+    `Fix options:\n` +
+    `  - Fix Permissions  (sudo chown $USER $EI_DATA_PATH)\n` +
+    `  - Change Data Path (EI_DATA_PATH=~/ei-data ei)\n\n`
+  );
+  process.exit(1);
+});
 
 if (!lockResult.acquired) {
   process.stderr.write(

package/tui/src/storage/file.ts

@@ -1,6 +1,7 @@
 import type { StorageState } from "../../../src/core/types";
 import type { Storage } from "../../../src/storage/interface";
 import { encodeAllEmbeddings, decodeAllEmbeddings } from "../../../src/storage/embeddings";
+import { withLock, atomicWrite } from "../../../src/storage/file-lock";
 import { join } from "path";
 import { mkdir, rename, unlink, readdir } from "fs/promises";
 import { resolveDataPath } from "../util/resolve-data-path.js";
@@ -8,8 +9,6 @@ import { resolveDataPath } from "../util/resolve-data-path.js";
 const STATE_FILE = "state.json";
 const BACKUP_FILE = "state.backup.json";
 const BACKUPS_DIR = "backups";
-const LOCK_TIMEOUT_MS = 5000;
-const LOCK_RETRY_DELAY_MS = 50;
 
 export class FileStorage implements Storage {
   private readonly dataPath: string;
@@ -39,9 +38,9 @@ export class FileStorage implements Storage {
     const filePath = join(this.dataPath, STATE_FILE);
     state.timestamp = new Date().toISOString();
 
-    await this.withLock(filePath, async () => {
+    await withLock(filePath, async () => {
       try {
-        await this.atomicWrite(filePath, JSON.stringify(encodeAllEmbeddings(state), null, 2));
+        await atomicWrite(filePath, JSON.stringify(encodeAllEmbeddings(state), null, 2));
       } catch (e) {
         if (this.isQuotaError(e)) {
           throw new Error("STORAGE_SAVE_FAILED: Disk quota exceeded");
@@ -89,7 +88,7 @@ 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));
+    await atomicWrite(backupPath, JSON.stringify(encodeAllEmbeddings(state), null, 2));
   }
 
   /**
@@ -130,7 +129,7 @@ export class FileStorage implements Storage {
     ].join("") + ".json";
 
     const destPath = join(backupsPath, name);
-    await this.atomicWrite(destPath, JSON.stringify(encodeAllEmbeddings(state), null, 2));
+    await atomicWrite(destPath, JSON.stringify(encodeAllEmbeddings(state), null, 2));
 
     // Prune: keep only the newest maxBackups files
     const entries = await readdir(backupsPath);
@@ -149,8 +148,16 @@ export class FileStorage implements Storage {
   private async ensureDataDir(): Promise<void> {
     try {
       await mkdir(this.dataPath, { recursive: true });
-    } catch {
-      return;
+    } catch (e: any) {
+      if (e?.code === 'EACCES' || e?.code === 'EPERM') {
+        throw new Error(
+          `Cannot create data directory: ${this.dataPath}\n` +
+          `Fix options:\n` +
+          `  - Fix Permissions  (sudo chown $USER $EI_DATA_PATH)\n` +
+          `  - Change Data Path (EI_DATA_PATH=~/ei-data ei-tui)`
+        );
+      }
+      // Other errors (e.g., race conditions) are safe to ignore
     }
   }
 
@@ -160,79 +167,4 @@ export class FileStorage implements Storage {
       (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()) {
-        // Read may throw if another writer deleted the lock between exists() and text() —
-        // treat that as "lock is gone, proceed to acquire" by falling through.
-        let lockContent: string;
-        try {
-          lockContent = await lockFile.text();
-        } catch {
-          // Lock vanished in the race window — retry from top to re-check state cleanly.
-          await new Promise((r) => setTimeout(r, LOCK_RETRY_DELAY_MS));
-          continue;
-        }
-        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/instance-lock.ts

@@ -1,5 +1,5 @@
-import { join } from "path";
-import { unlink } from "fs/promises";
+import { join, dirname } from "path";
+import { unlink, mkdir } from "fs/promises";
 
 const LOCK_FILE = "ei.lock";
 
@@ -69,6 +69,7 @@ export class InstanceLock {
   }
 
   private async writeLock(): Promise<void> {
+    await mkdir(dirname(this.lockPath), { recursive: true });
     const data: LockData = {
       pid: process.pid,
       started: new Date().toISOString(),

package/tui/src/util/yaml-persona.ts

@@ -7,6 +7,7 @@ import type {
   ProviderAccount,
 } from "../../../src/core/types.js";
 import { modelGuidToDisplay, displayToModelGuid } from "./yaml-shared.js";
+import { buildPersonaToolsMap, resolvePersonaToolsFromMap, preserveHiddenToolGrants } from "../../../src/core/persona-tools.js";
 import { parseDuration, formatDuration } from "./duration.js";
 
 const PLACEHOLDER_LONG_DESC = "Detailed description of this persona's personality, background, and role";
@@ -62,43 +63,6 @@ const PLACEHOLDER_TOPIC: YAMLPersonaTopic = {
   exposure_desired: 0.5,
 };
 
-function buildPersonaToolsMap(
-  enabledToolIds: string[],
-  allTools: ToolDefinition[],
-  allProviders: import('../../../src/core/types.js').ToolProvider[]
-): Record<string, Record<string, boolean>> | undefined {
-  if (allTools.length === 0) return undefined;
-  const enabledSet = new Set(enabledToolIds);
-  const result: Record<string, Record<string, boolean>> = {};
-  for (const provider of allProviders.filter(p => p.enabled)) {
-    const providerTools = allTools.filter(t => t.provider_id === provider.id);
-    if (providerTools.length === 0) continue;
-    result[provider.display_name] = Object.fromEntries(
-      providerTools.map(t => [t.display_name, enabledSet.has(t.id)])
-    );
-  }
-  return Object.keys(result).length > 0 ? result : undefined;
-}
-
-function resolvePersonaToolsFromMap(
-  toolsMap: Record<string, Record<string, boolean>> | undefined,
-  allTools: ToolDefinition[],
-  allProviders: import('../../../src/core/types.js').ToolProvider[]
-): string[] | undefined {
-  if (!toolsMap) return undefined;
-  const enabledIds: string[] = [];
-  for (const [providerDisplayName, toolToggles] of Object.entries(toolsMap)) {
-    const provider = allProviders.find(p => p.display_name === providerDisplayName);
-    if (!provider) continue;
-    for (const [toolDisplayName, enabled] of Object.entries(toolToggles)) {
-      if (!enabled) continue;
-      const tool = allTools.find(t => t.provider_id === provider.id && t.display_name === toolDisplayName);
-      if (tool) enabledIds.push(tool.id);
-    }
-  }
-  return enabledIds.length > 0 ? enabledIds : [];
-}
-
 export function newPersonaToYAML(name: string, allTools?: ToolDefinition[], allProviders?: import('../../../src/core/types.js').ToolProvider[]): string {
   const toolsMap = buildPersonaToolsMap([], allTools ?? [], allProviders ?? []);
 
@@ -337,7 +301,12 @@ export function personaFromYAML(yamlContent: string, original: PersonaEntity, al
     pause_until: data.pause_until,
     is_static: data.is_static ?? false,
     include_message_timestamps: data.include_message_timestamps ?? false,
-    tools: resolvePersonaToolsFromMap(data.tools, allTools ?? [], allProviders ?? []),
+    tools: preserveHiddenToolGrants(
+      resolvePersonaToolsFromMap(data.tools, allTools ?? [], allProviders ?? []),
+      original.tools,
+      allTools ?? [],
+      allProviders ?? []
+    ),
     last_updated: new Date().toISOString(),
   };