@dotdrelle/wiki-manager 0.6.31 → 0.6.34

package/src/core/startupCheck.js

@@ -0,0 +1,130 @@
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { parseComposePsJson } from './compose.js';
+import { listWikircProfiles, loadWikircProfile, summarizeWikircConfig } from './wikirc.js';
+import { listWorkspaces, managerRoot, workspacesDir } from './workspaces.js';
+
+const execFileAsync = promisify(execFile);
+
+async function checkAgents() {
+  const composeFile = join(managerRoot(), 'agents.docker-compose.yml');
+  if (!existsSync(composeFile)) return null;
+  try {
+    const { stdout } = await execFileAsync('docker', [
+      'compose',
+      '--project-directory',
+      managerRoot(),
+      '-f',
+      composeFile,
+      '-p',
+      'wiki-agents',
+      'ps',
+      '--format',
+      'json',
+    ], {
+      cwd: managerRoot(),
+      env: {
+        ...process.env,
+        WORKSPACES_ROOT: workspacesDir(),
+        WIKI_WORKSPACES_DIR: workspacesDir(),
+      },
+      timeout: 5000,
+      maxBuffer: 1024 * 1024,
+    });
+    const entries = parseComposePsJson(stdout);
+    if (entries.length === 0) return null;
+    const downServices = entries
+      .filter((entry) => {
+        const state = String(entry.State ?? entry.state ?? entry.Status ?? entry.status ?? '').toLowerCase();
+        return !(state.includes('running') || state.includes('up'));
+      })
+      .map((entry) => entry.Service ?? entry.service ?? entry.Name ?? entry.name)
+      .filter(Boolean);
+    return downServices.length > 0 ? { kind: 'agents', context: { downServices } } : null;
+  } catch (err) {
+    if (err?.code === 'ENOENT') {
+      return { kind: 'agents', context: { dockerMissing: true } };
+    }
+    const stderr = String(err?.stderr ?? err?.message ?? '');
+    if (
+      stderr.includes('Cannot connect to the Docker daemon') ||
+      stderr.includes('Is the docker daemon running') ||
+      stderr.includes('docker daemon') ||
+      stderr.includes('connection refused')
+    ) {
+      return { kind: 'agents', context: { dockerUnavailable: true } };
+    }
+    // Timeout or unknown error — don't block startup with ambiguous state.
+    return null;
+  }
+}
+
+function checkWorkspace(workspaces) {
+  return workspaces.length === 0 ? { kind: 'workspace' } : null;
+}
+
+function checkWikirc(workspace) {
+  if (!workspace) return [];
+  const baseContext = {
+    workspaceName: workspace.name,
+    workspacePath: workspace.workspacePath,
+    profileName: 'default',
+  };
+  if (listWikircProfiles(workspace.workspacePath).length === 0) {
+    return [
+      {
+        kind: 'llm',
+        context: {
+          ...baseContext,
+          configError: 'No .wikirc.yaml profile found in the workspace.',
+        },
+      },
+    ];
+  }
+  try {
+    const loaded = loadWikircProfile(workspace.workspacePath, 'default');
+    const summary = summarizeWikircConfig(loaded.profile, loaded.config);
+    const context = {
+      workspaceName: workspace.name,
+      workspacePath: workspace.workspacePath,
+      profileName: loaded.profile.name,
+    };
+    const gaps = [];
+    if (!summary.hasApiKey || !summary.model) gaps.push({ kind: 'llm', context });
+    if (!summary.vectorEnabled) gaps.push({ kind: 'vector', context });
+    return gaps;
+  } catch {
+    return [
+      {
+        kind: 'llm',
+        context: {
+          ...baseContext,
+          configError: 'Default .wikirc.yaml profile could not be loaded.',
+        },
+      },
+      {
+        kind: 'vector',
+        context: {
+          ...baseContext,
+          configError: 'Default .wikirc.yaml profile could not be loaded.',
+        },
+      },
+    ];
+  }
+}
+
+export async function runChecks() {
+  const workspaces = listWorkspaces();
+  const agents = await checkAgents();
+  const gaps = [];
+  if (agents) gaps.push(agents);
+  const workspaceGap = checkWorkspace(workspaces);
+  if (workspaceGap) {
+    gaps.push(workspaceGap);
+    return gaps;
+  }
+  gaps.push(...checkWikirc(workspaces[0] ?? null));
+  return gaps;
+}

package/src/core/wikiSetup.js

@@ -0,0 +1,156 @@
+import { execFile } from 'node:child_process';
+import { readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { patchWikircProfile } from './wikirc.js';
+import { createWorkspace, findWorkspace, isValidWorkspaceName, listWorkspaces, managerRoot, workspacesDir } from './workspaces.js';
+
+const execFileAsync = promisify(execFile);
+
+function wrapDockerError(err) {
+  if (err?.code === 'ENOENT') {
+    return new Error('wiki-workspace script not found. Reinstall wiki-manager.');
+  }
+  const message = String(err?.message ?? '');
+  const output = [err?.stderr, err?.stdout, message].filter(Boolean).map(String).join('\n');
+  if (output.includes('docker: command not found') || output.includes('docker: not found')) {
+    return new Error('Docker is not installed. Install Docker Desktop (https://docs.docker.com/get-docker/) and restart.');
+  }
+  if (output.includes('Cannot connect to the Docker daemon') || output.includes('Is the docker daemon running')) {
+    return new Error('Docker daemon is not running. Start Docker Desktop and try again.');
+  }
+  const commandMatch = message.match(/^Command failed:\s+(.+)$/m);
+  if (commandMatch) {
+    const [, commandLine] = commandMatch;
+    const rest = message.split(/\r?\n/).slice(1).join('\n').trim();
+    return new Error([
+      'Command failed:',
+      commandLine,
+      rest,
+    ].filter(Boolean).join('\n'));
+  }
+  return err;
+}
+
+export async function startAgents(options = {}) {
+  try {
+    const { stdout, stderr } = await execFileAsync(join(managerRoot(), 'wiki-workspace'), ['agents', 'up'], {
+      cwd: managerRoot(),
+      env: {
+        ...process.env,
+        WIKI_WORKSPACES_DIR: workspacesDir(),
+      },
+      timeout: options.timeout ?? 180_000,
+      maxBuffer: options.maxBuffer ?? 1024 * 1024 * 8,
+    });
+    return [stdout, stderr].filter(Boolean).join('\n').trim();
+  } catch (err) {
+    throw wrapDockerError(err);
+  }
+}
+
+export async function stopAgents(options = {}) {
+  try {
+    const { stdout, stderr } = await execFileAsync(join(managerRoot(), 'wiki-workspace'), ['agents', 'down'], {
+      cwd: managerRoot(),
+      env: {
+        ...process.env,
+        WIKI_WORKSPACES_DIR: workspacesDir(),
+      },
+      timeout: options.timeout ?? 120_000,
+      maxBuffer: options.maxBuffer ?? 1024 * 1024 * 8,
+    });
+    return [stdout, stderr].filter(Boolean).join('\n').trim();
+  } catch (err) {
+    throw wrapDockerError(err);
+  }
+}
+
+export async function createNewWorkspace(name, targetPath) {
+  try {
+    const output = await createWorkspace(name, targetPath, { timeout: 600_000 });
+    const workspace = findWorkspace(name);
+    if (workspace) initializeWorkspaceWikirc(workspace);
+    return { output, workspace };
+  } catch (err) {
+    throw wrapDockerError(err);
+  }
+}
+
+export function initializeWorkspaceWikirc(workspace) {
+  const accessKey = workspace?.env?.WIKI_MCP_AUTH_TOKEN;
+  if (!workspace?.workspacePath || !accessKey) return null;
+  return patchWikircProfile(workspace.workspacePath, 'default', {
+    mcp: {
+      accessKey,
+    },
+  });
+}
+
+export async function unregisterWorkspace(nameOrWorkspace) {
+  const workspace = typeof nameOrWorkspace === 'string' ? findWorkspace(nameOrWorkspace) : nameOrWorkspace;
+  if (!workspace) throw new Error(`Workspace not found: ${nameOrWorkspace}`);
+  await rm(workspace.registryPath, { recursive: true, force: true });
+  return workspace;
+}
+
+export async function renameWorkspace(name, nextName) {
+  if (!isValidWorkspaceName(nextName)) throw new Error('Invalid workspace name.');
+  const all = listWorkspaces();
+  const workspace = all.find((w) => w.name === name);
+  if (!workspace) throw new Error(`Workspace not found: ${name}`);
+  if (all.find((w) => w.name === nextName)) throw new Error(`Workspace already exists: ${nextName}`);
+  const nextRegistryPath = join(workspacesDir(), nextName);
+  const envText = await readFile(workspace.envFile, 'utf8');
+  const nextEnvText = envText.match(/^WORKSPACE_NAME=/m)
+    ? envText.replace(/^WORKSPACE_NAME=.*$/m, `WORKSPACE_NAME=${nextName}`)
+    : `${envText.trimEnd()}\nWORKSPACE_NAME=${nextName}\n`;
+  const tmpEnvFile = join(workspace.registryPath, `.env.${process.pid}.tmp`);
+  await writeFile(tmpEnvFile, nextEnvText, 'utf8');
+  await rename(tmpEnvFile, workspace.envFile);
+  await rename(workspace.registryPath, nextRegistryPath);
+  return { previousName: name, name: nextName, registryPath: nextRegistryPath };
+}
+
+export async function deleteWorkspaceAndFiles(name, workspacePath) {
+  const workspace = await unregisterWorkspace(name);
+  const target = workspacePath || workspace.workspacePath;
+  await rm(target, { recursive: true, force: true });
+  return { workspace, deletedPath: target };
+}
+
+export function writeLanguageConfig(workspacePath, profileName, language) {
+  return patchWikircProfile(workspacePath, profileName || 'default', { language });
+}
+
+export function writeLlmConfig(workspacePath, profileName, config) {
+  const patches = {
+    llm: {
+      provider: config.provider,
+      ...(config.baseUrl ? { baseUrl: config.baseUrl } : {}),
+      ...(config.apiKey ? { apiKey: config.apiKey } : {}),
+      model: config.model,
+    },
+  };
+  return patchWikircProfile(workspacePath, profileName || 'default', patches);
+}
+
+export function writeVectorConfig(workspacePath, profileName, config) {
+  const patches = {
+    retrieval: {
+      vector: {
+        enabled: true,
+        ...(config.baseUrl ? { baseUrl: config.baseUrl } : {}),
+        ...(config.apiKey ? { apiKey: config.apiKey } : {}),
+        timeoutMs: config.timeoutMs ?? 600_000,
+        embeddingModel: config.embeddingModel,
+        rerankEnabled: Boolean(config.rerankEnabled),
+        ...(config.rerankerModel ? { rerankerModel: config.rerankerModel } : {}),
+        topK: config.topK ?? 120,
+        rerankTopK: config.rerankTopK ?? 80,
+        maxResults: config.maxResults ?? 6,
+      },
+    },
+  };
+  return patchWikircProfile(workspacePath, profileName || 'default', patches);
+}

package/src/core/wikirc.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import YAML from 'yaml';
 
@@ -50,6 +50,85 @@ export function loadWikircProfile(workspacePath, profileName = 'default') {
   return { profile, config };
 }
 
+function isPlainObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function setYamlValue(map, key, value) {
+  if (isPlainObject(value)) {
+    let child = map.get(key, true);
+    if (!YAML.isMap(child)) {
+      child = new YAML.YAMLMap();
+      map.set(key, child);
+    }
+    mergeYamlMap(child, value);
+    return;
+  }
+  map.set(key, value);
+}
+
+function mergeYamlMap(map, patches) {
+  for (const [key, value] of Object.entries(patches ?? {})) {
+    setYamlValue(map, key, value);
+  }
+}
+
+function stripCommentedVectorKeys(raw, keys) {
+  const keySet = new Set(keys.filter(Boolean));
+  if (keySet.size === 0) return raw;
+
+  let inRetrieval = false;
+  let retrievalIndent = -1;
+  let inVector = false;
+  let vectorIndent = -1;
+
+  return raw.split(/\r?\n/).filter((line) => {
+    const nonComment = line.match(/^(\s*)([A-Za-z0-9_-]+):(?:\s|$)/);
+    if (nonComment) {
+      const indent = nonComment[1].length;
+      const key = nonComment[2];
+      if (inVector && indent <= vectorIndent) inVector = false;
+      if (inRetrieval && indent <= retrievalIndent) inRetrieval = false;
+      if (!inRetrieval && key === 'retrieval') {
+        inRetrieval = true;
+        retrievalIndent = indent;
+      } else if (inRetrieval && !inVector && indent > retrievalIndent && key === 'vector') {
+        inVector = true;
+        vectorIndent = indent;
+      }
+    }
+
+    if (inVector) {
+      const commentedKey = line.match(/^\s*#\s*([A-Za-z0-9_-]+):/);
+      if (commentedKey && keySet.has(commentedKey[1])) return false;
+    }
+    return true;
+  }).join('\n');
+}
+
+export function patchWikircProfile(workspacePath, profileName = 'default', patches = {}) {
+  const profile = resolveWikircProfile(workspacePath, profileName);
+  const vectorPatch = patches?.retrieval?.vector;
+  const commentedVectorKeysToStrip = [
+    vectorPatch?.baseUrl ? 'baseUrl' : null,
+    vectorPatch?.apiKey ? 'apiKey' : null,
+  ];
+  const raw = stripCommentedVectorKeys(readFileSync(profile.path, 'utf8'), commentedVectorKeysToStrip);
+  const doc = YAML.parseDocument(raw, {
+    schema: 'core',
+    keepSourceTokens: true,
+  });
+  if (doc.errors.length > 0) {
+    throw new Error(`wikirc YAML invalide: ${doc.errors[0].message}`);
+  }
+  if (!YAML.isMap(doc.contents)) {
+    throw new Error('wikirc YAML invalide: objet attendu a la racine');
+  }
+  mergeYamlMap(doc.contents, patches);
+  writeFileSync(profile.path, doc.toString(), 'utf8');
+  return { profile, patches };
+}
+
 export function summarizeWikircConfig(profile, config) {
   return {
     profile: profile.name,

package/src/core/wikirc.test.js

@@ -0,0 +1,111 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import YAML from 'yaml';
+import { patchWikircProfile } from './wikirc.js';
+import { writeVectorConfig } from './wikiSetup.js';
+
+test('patchWikircProfile merges keys and preserves existing values', () => {
+  const root = mkdtempSync(join(tmpdir(), 'wikirc-patch-'));
+  const file = join(root, '.wikirc.yaml');
+  writeFileSync(file, [
+    '# workspace config',
+    'language: en-US',
+    'llm:',
+    '  provider: openai',
+    '  temperature: 0.2',
+    '',
+  ].join('\n'), 'utf8');
+
+  patchWikircProfile(root, 'default', {
+    llm: {
+      model: 'gpt-5.4-mini',
+      apiKey: 'secret',
+    },
+    retrieval: {
+      vector: {
+        enabled: true,
+        embeddingModel: 'text-embedding-3-small',
+      },
+    },
+  });
+
+  const raw = readFileSync(file, 'utf8');
+  const parsed = YAML.parse(raw);
+  assert.match(raw, /# workspace config/);
+  assert.equal(parsed.language, 'en-US');
+  assert.equal(parsed.llm.provider, 'openai');
+  assert.equal(parsed.llm.temperature, 0.2);
+  assert.equal(parsed.llm.model, 'gpt-5.4-mini');
+  assert.equal(parsed.retrieval.vector.enabled, true);
+});
+
+test('writeVectorConfig writes llm-wiki vector and rerank keys', () => {
+  const root = mkdtempSync(join(tmpdir(), 'wikirc-vector-'));
+  writeFileSync(join(root, '.wikirc.yaml'), [
+    'language: en',
+    'llm:',
+    '  provider: openai-compatible',
+    '  baseUrl: http://localhost:8000/v1',
+    '  apiKey: llm-key',
+    '  model: chat-model',
+    'retrieval:',
+    '  vector:',
+    '    enabled: false',
+    '',
+  ].join('\n'), 'utf8');
+
+  writeVectorConfig(root, 'default', {
+    baseUrl: 'http://localhost:7997/v1',
+    apiKey: 'vector-key',
+    embeddingModel: 'BAAI/bge-m3',
+    rerankEnabled: true,
+    rerankerModel: 'BAAI/bge-reranker-v2-m3',
+  });
+
+  const parsed = YAML.parse(readFileSync(join(root, '.wikirc.yaml'), 'utf8'));
+  assert.equal(parsed.retrieval.vector.enabled, true);
+  assert.equal(parsed.retrieval.vector.baseUrl, 'http://localhost:7997/v1');
+  assert.equal(parsed.retrieval.vector.apiKey, 'vector-key');
+  assert.equal(parsed.retrieval.vector.embeddingModel, 'BAAI/bge-m3');
+  assert.equal(parsed.retrieval.vector.rerankEnabled, true);
+  assert.equal(parsed.retrieval.vector.rerankerModel, 'BAAI/bge-reranker-v2-m3');
+});
+
+test('writeVectorConfig removes commented vector placeholders it replaces', () => {
+  const root = mkdtempSync(join(tmpdir(), 'wikirc-vector-comments-'));
+  writeFileSync(join(root, '.wikirc.yaml'), [
+    'language: en',
+    'llm:',
+    '  provider: openai-compatible',
+    '  baseUrl: http://localhost:8000/v1',
+    '  apiKey: llm-key',
+    '  model: chat-model',
+    'retrieval:',
+    '  vector:',
+    '    enabled: false',
+    '    # Defaults to llm.baseUrl.',
+    '    # baseUrl: http://127.0.0.1:7997/v1',
+    '    # apiKey: your-vector-key',
+    '    embeddingModel: BAAI/bge-m3',
+    '    rerankerModel: BAAI/bge-reranker-v2-m3',
+    '',
+  ].join('\n'), 'utf8');
+
+  writeVectorConfig(root, 'default', {
+    baseUrl: 'http://localhost:7997/v1',
+    apiKey: 'vector-key',
+    embeddingModel: 'BAAI/bge-m3',
+    rerankEnabled: true,
+    rerankerModel: 'custom-reranker',
+  });
+
+  const raw = readFileSync(join(root, '.wikirc.yaml'), 'utf8');
+  const parsed = YAML.parse(raw);
+  assert.doesNotMatch(raw, /^\s*#\s*baseUrl:/m);
+  assert.doesNotMatch(raw, /^\s*#\s*apiKey:/m);
+  assert.equal(parsed.retrieval.vector.baseUrl, 'http://localhost:7997/v1');
+  assert.equal(parsed.retrieval.vector.apiKey, 'vector-key');
+});

package/src/core/workspaces.js

@@ -49,7 +49,7 @@ export function findWorkspace(name) {
   return listWorkspaces().find((workspace) => workspace.name === name);
 }
 
-function isValidWorkspaceName(name) {
+export function isValidWorkspaceName(name) {
   return (
     typeof name === 'string' &&
     /^[a-zA-Z0-9][a-zA-Z0-9_.-]*[a-zA-Z0-9]$|^[a-zA-Z0-9]$/.test(name) &&

package/src/shell/LeftPane.tsx

@@ -1,5 +1,5 @@
 /** @jsxImportSource @opentui/solid */
-import { For, createEffect, createMemo, createSignal } from 'solid-js';
+import { For, createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
 import { colorForRenderedLine, helpCommandParts, keyValueParts, renderPlainMarkdown } from './renderer';
 
 const LEGACY_DONNA_ROLE = 'do' + 't';
@@ -59,12 +59,12 @@ const STATUS_COLUMN_GAP = 2;
 type HelpCard = { title: string; text: string; example: string };
 
 const HELP_CARDS: HelpCard[] = [
+  { title: '/use', text: 'Load one workspace.', example: 'Ex: /use <workspace>' },
   { title: '/new', text: 'Create/configure a workspace.', example: 'Ex: /new <name> [path]' },
-  { title: 'modify wikirc', text: 'Action: edit file.', example: 'File: .wikirc.yaml' },
-  { title: 'configure CME', text: 'Add type, URL, PAT, email.', example: 'Provide source credentials' },
-  { title: 'add MCP', text: 'Inspect and use MCP endpoints.', example: 'Ex: /mcp endpoints' },
-  { title: '/use', text: 'Load one workspace and its tools.', example: 'Ex: /use <workspace>' },
-  { title: 'llm call action', text: 'Ask to LLM.', example: 'Ex: ask to LLM to run an action' },
+  { title: '/config', text: 'Modify LLM configuration.', example: 'Ex: /config edit <profile>' },
+  { title: '/mcp', text: 'View MCP.', example: 'Ex: /mcp status' },
+  { title: 'configure CME', text: 'Add type, URL, PAT, email.', example: 'Ask to donna to set credentials' },
+  { title: '/status', text: 'Check config.', example: 'Ex: /status' },
 ];
 
 function HelpCardPanel(props: { card: HelpCard; width: number }) {
@@ -364,6 +364,7 @@ function conversationLines(messages: Array<{ role: string; content: string }>, c
     if (isStatusOutput(message)) {
       return [
         { segments: messageHeaderSegments(message.role, columns), copyContent: raw },
+        { segments: [{ text: ' ', color: '#D6DEE8' }] },
         ...raw.split('\n').map((line) => {
           const { left, right } = statusColumns(line || ' ');
           return { status: true, statusLeft: left, statusRight: right, segments: [] };
@@ -379,6 +380,7 @@ function conversationLines(messages: Array<{ role: string; content: string }>, c
     }
     return [
       { segments: messageHeaderSegments(message.role, columns), copyContent: raw },
+      { segments: [{ text: ' ', color: '#D6DEE8' }] },
       ...renderMarkdownLines(lines, message.role, columns),
       { segments: [{ text: ' ', color: '#D6DEE8' }] },
     ];
@@ -397,7 +399,7 @@ export function ConversationView(props: {
   const allLines = createMemo(() => conversationLines(props.messages, props.columns));
   const visibleLines = () => {
     const lines = allLines();
-    const rows = Math.max(1, props.rows - 1);
+    const rows = Math.max(1, props.rows - 2);
     const maxScroll = Math.max(0, lines.length - rows);
     const scroll = Math.min(props.scroll, maxScroll);
     const end = lines.length - scroll;
@@ -406,7 +408,7 @@ export function ConversationView(props: {
   };
   const scrollHint = () => {
     const lines = allLines();
-    const rows = Math.max(1, props.rows - 1);
+    const rows = Math.max(1, props.rows - 2);
     const maxScroll = Math.max(0, lines.length - rows);
     const scroll = Math.min(props.scroll, maxScroll);
     if (maxScroll === 0) return '';
@@ -483,6 +485,7 @@ export function ConversationView(props: {
           )
         )}
       </For>
+      <text height={1} />
     </box>
   );
 }
@@ -504,28 +507,34 @@ export function ChatInput(props: {
   const minRows = 1;
   const maxRows = 5;
   const [textareaRows, setTextareaRows] = createSignal(minRows);
+  let disposed = false;
   const idleColor = () => props.chatMode ? '#22C55E' : '#06B6D4';
   const promptText = () => props.busy ? `${props.spinnerFrame} ` : props.prompt;
   const boxHeight = () => textareaRows() + 2;
+  const inputColumns = () => Math.max(8, props.width - promptText().length - 6);
   const textareaColumns = () => {
     const measured = Number(textareaRef?.width ?? 0);
-    if (Number.isFinite(measured) && measured > 0) return Math.max(8, measured - 1);
-    return Math.max(8, props.width - promptText().length - 7);
+    const bounded = Math.min(inputColumns(), Number.isFinite(measured) && measured > 0 ? measured : inputColumns());
+    return Math.max(8, bounded - 1);
   };
   const estimatedVisualRows = (value: string) => {
     const columns = textareaColumns();
     return Math.max(1, value.split('\n').reduce((rows, line) => rows + Math.max(1, Math.ceil(line.length / columns)), 0));
   };
   const measuredVisualRows = (value: string) => {
-    const virtualRows = Number(textareaRef?.virtualLineCount ?? 0);
-    const logicalRows = Number(textareaRef?.lineCount ?? 0);
-    const scrollRows = Number(textareaRef?.scrollHeight ?? 0);
-    return Math.max(
-      estimatedVisualRows(value),
-      Number.isFinite(virtualRows) ? virtualRows : 0,
-      Number.isFinite(logicalRows) ? logicalRows : 0,
-      Number.isFinite(scrollRows) ? scrollRows : 0,
-    );
+    try {
+      const virtualRows = Number(textareaRef?.virtualLineCount ?? 0);
+      const logicalRows = Number(textareaRef?.lineCount ?? 0);
+      const scrollRows = Number(textareaRef?.scrollHeight ?? 0);
+      return Math.max(
+        estimatedVisualRows(value),
+        Number.isFinite(virtualRows) ? virtualRows : 0,
+        Number.isFinite(logicalRows) ? logicalRows : 0,
+        Number.isFinite(scrollRows) ? scrollRows : 0,
+      );
+    } catch {
+      return estimatedVisualRows(value);
+    }
   };
   const applyHeight = (rows: number) => {
     const height = rows + 2;
@@ -533,11 +542,25 @@ export function ChatInput(props: {
     if (containerRef) containerRef.height = height;
     props.onHeightChange(height);
   };
-  const updateRows = (value = String(textareaRef?.plainText ?? props.value ?? '')) => {
-    const rows = Math.min(maxRows, Math.max(minRows, measuredVisualRows(value)));
+  const safePlainText = () => {
+    try {
+      return String(textareaRef?.plainText ?? props.value ?? '');
+    } catch {
+      return String(props.value ?? '');
+    }
+  };
+  const updateRows = (value?: string) => {
+    if (disposed) return;
+    const text = value ?? safePlainText();
+    const rows = Math.min(maxRows, Math.max(minRows, measuredVisualRows(text)));
     setTextareaRows(rows);
     applyHeight(rows);
   };
+  const queueUpdateRows = (value?: string) => {
+    queueMicrotask(() => {
+      if (!disposed) updateRows(value);
+    });
+  };
   const syncTextareaValue = (value: string) => {
     const current = String(textareaRef?.plainText ?? '');
     if (!textareaRef || current === value) return;
@@ -549,16 +572,16 @@ export function ChatInput(props: {
       // Some renderable states reject cursor movement while layout is settling.
     }
     updateRows(value);
-    queueMicrotask(() => updateRows(value));
+    queueUpdateRows(value);
   };
   const handleContentChange = () => {
-    const value = String(textareaRef?.plainText ?? '');
+    const value = safePlainText();
     props.onInput(value);
     updateRows(value);
-    queueMicrotask(() => updateRows(value));
+    queueUpdateRows(value);
   };
   const submitCurrentValue = () => {
-    props.onSubmit(String(textareaRef?.plainText ?? props.value ?? ''));
+    props.onSubmit(safePlainText());
   };
 
   createEffect(() => {
@@ -573,7 +596,10 @@ export function ChatInput(props: {
     props.width;
     props.prompt;
     props.spinnerFrame;
-    queueMicrotask(() => updateRows());
+    queueUpdateRows();
+  });
+  onCleanup(() => {
+    disposed = true;
   });
 
   return (
@@ -590,7 +616,7 @@ export function ChatInput(props: {
       <text height={1} fg={props.busy ? '#FBBF24' : idleColor()}>{promptText()}</text>
       <textarea
         ref={textareaRef}
-        flexGrow={1}
+        width={inputColumns()}
         height={textareaRows()}
         focused={props.focused && !props.busy}
         initialValue={props.value}
@@ -599,7 +625,7 @@ export function ChatInput(props: {
         keyBindings={[
           { name: 'return', action: 'submit' },
           { name: 'kpenter', action: 'submit' },
-          { name: 'linefeed', action: 'newline' },
+          { name: 'linefeed', action: 'submit' },
           { name: 'return', shift: true, action: 'newline' },
           { name: 'kpenter', shift: true, action: 'newline' },
           { name: 'linefeed', shift: true, action: 'newline' },