@dotdrelle/wiki-manager 0.11.0 → 0.11.6

package/src/shell/repl.test.js

@@ -1,6 +1,14 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { applyRuntimeStateToShellSession, createSession, conversationMessages, submitRuntimeRun } from './repl.js';
+import {
+  applyRuntimeStateToShellSession,
+  createSession,
+  conversationMessages,
+  recordRuntimeUnavailableAgentInput,
+  runtimeStatusLine,
+  runtimeUnavailableAgentMessage,
+  submitRuntimeRun,
+} from './repl.js';
 
 function stubFetch(handler) {
   const original = globalThis.fetch;
@@ -112,3 +120,27 @@ test('submitRuntimeRun reports a non-409 error without throwing or calling /cont
     restore();
   }
 });
+
+test('agent mode without runtime records a visible error instead of falling back locally', () => {
+  const session = createSession();
+  session.chatMode = false;
+
+  const message = recordRuntimeUnavailableAgentInput(session, 'salut', { error: 'port 7788 already in use' });
+
+  assert.equal(message, '⚠ Runtime indisponible : port 7788 already in use — /agent désactivé, /chat reste possible');
+  assert.deepEqual(conversationMessages(session), [
+    { role: 'user', content: 'salut' },
+    { role: 'command', content: message },
+  ]);
+});
+
+test('runtime status exposes the disconnected reason', () => {
+  assert.equal(
+    runtimeStatusLine({ error: 'token mismatch' }, { workspace: 'juno' }),
+    'runtime: disconnected: token mismatch',
+  );
+  assert.equal(
+    runtimeUnavailableAgentMessage({ error: 'token mismatch' }),
+    '⚠ Runtime indisponible : token mismatch — /agent désactivé, /chat reste possible',
+  );
+});

package/src/shell/tui.tsx

@@ -1,7 +1,7 @@
 /** @jsxImportSource @opentui/solid */
 import { execFileSync } from 'node:child_process';
 import { render, useKeyboard, useRenderer, useSelectionHandler, useTerminalDimensions } from '@opentui/solid';
-import { createMemo, createSignal, onCleanup } from 'solid-js';
+import { createMemo, createSignal, onCleanup, Show } from 'solid-js';
 import { FileEditorDialog } from './FileEditorDialog';
 import { LeftPane } from './LeftPane';
 import { RightPane } from './RightPane';
@@ -12,6 +12,7 @@ import { useSession } from './useSession';
 import { buildMcpStatus } from '../core/mcp.js';
 import { loadWikircProfile, summarizeWikircConfig } from '../core/wikirc.js';
 import { listWorkspaces } from '../core/workspaces.js';
+import { postRuntimeShutdown } from '../runtime/client.js';
 
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 
@@ -109,6 +110,7 @@ function App(props: {
   const [exitHint, setExitHint] = createSignal(false);
   const [copyHint, setCopyHint] = createSignal<string | null>(null);
   const [chatInputHeight, setChatInputHeight] = createSignal(3);
+  const [startupKeyboardEvent, setStartupKeyboardEvent] = createSignal<{ id: number; key: any } | null>(null);
   // The app has exactly three mutually exclusive screens; one signal makes
   // that invariant structural instead of relying on two booleans staying in
   // sync at every call site.
@@ -116,7 +118,9 @@ function App(props: {
   let ctrlCTimer: ReturnType<typeof setTimeout> | null = null;
   let copyHintTimer: ReturnType<typeof setTimeout> | null = null;
   let selectionCopyTimer: ReturnType<typeof setTimeout> | null = null;
+  let startupKeyboardEventId = 0;
   let lastCopiedSelection = '';
+  let runtimeShutdownRequested = false;
   const state = useSession(props);
   const startup = createMemo(() => startupInfo(props.packageJson));
   const conversationRows = createMemo(() => Math.max(4, dimensions().height - 5 - chatInputHeight()));
@@ -224,6 +228,10 @@ function App(props: {
   onCleanup(() => {
     if (copyHintTimer) clearTimeout(copyHintTimer);
     if (selectionCopyTimer) clearTimeout(selectionCopyTimer);
+    if (props.runtime?.url && !runtimeShutdownRequested) {
+      runtimeShutdownRequested = true;
+      void postRuntimeShutdown({ url: props.runtime.url }).catch(() => {});
+    }
   });
 
   const spinnerTimer = setInterval(() => {
@@ -236,6 +244,11 @@ function App(props: {
 
   useKeyboard((key) => {
     const keyName = String(key.name ?? '').toLowerCase();
+    if (screen() === 'startup') {
+      startupKeyboardEventId += 1;
+      setStartupKeyboardEvent({ id: startupKeyboardEventId, key });
+      return;
+    }
     if (screen() !== 'main') return;
     if (state.activeEditor()) {
       if (keyName === 'escape') state.closeEditor();
@@ -279,89 +292,91 @@ function App(props: {
   const hintLine = () => {
     if (copyHint()) return copyHint();
     if (exitHint()) return 'Press Ctrl+C again to exit.';
+    if (state.runtimeHint()) return state.runtimeHint();
     return null;
   };
 
-  if (screen() === 'startup') {
-    const info = startup();
-    return (
+  return (
+    <Show
+      when={screen() === 'startup'}
+      fallback={
+        <box width="100%" height="100%" flexDirection="row">
+          <LeftPane
+            width={leftColumns()}
+            title={state.title()}
+            statusLine={state.statusLine()}
+            hintLine={hintLine()}
+            showWelcome={state.showWelcome()}
+            messages={state.messages()}
+            prompt={state.prompt()}
+            input={state.input()}
+            busy={state.busy()}
+            chatMode={state.chatMode()}
+            chatFocused={!state.activeEditor()}
+            setInput={state.setInput}
+            submit={submit}
+            conversationRows={conversationRows()}
+            conversationColumns={conversationColumns()}
+            conversationScroll={state.conversationScroll()}
+            scrollConversation={state.scrollConversation}
+            spinnerFrame={SPINNER_FRAMES[spinnerIndex()] ?? SPINNER_FRAMES[0]}
+            onInputHeightChange={setChatInputHeight}
+            onCopy={(content) => showCopyHint(copyToClipboard(content, renderer) ? 'Copied.' : 'Copy failed.')}
+          />
+          <box width={1} height="100%" flexDirection="column">
+            {Array.from({ length: dimensions().height }, () => (
+              <text fg="#4B5563">│</text>
+            ))}
+          </box>
+          <RightPane
+            width={rightColumns()}
+            activities={state.activities()}
+            logs={state.logs()}
+            plan={state.plan()}
+            queueItems={state.queueItems()}
+            queueInfo={state.queueInfo()}
+            activeTab={state.rightTab()}
+            onTabClick={state.selectRightTab}
+          />
+          <SlashDialog context={state.activeEditor() ? null : state.slash()} />
+          <FileEditorDialog
+            editor={state.activeEditor()}
+            width={dimensions().width}
+            height={dimensions().height}
+            onSave={state.saveEditor}
+            onCancel={state.closeEditor}
+          />
+          {screen() === 'setup' ? (
+            <SetupWizard
+              mode="setup"
+              session={state.session}
+              width={dimensions().width}
+              height={dimensions().height}
+              initialRoute="workspace-name"
+              closeOnDone
+              onComplete={closeSetup}
+              onClose={closeSetup}
+            />
+          ) : null}
+        </box>
+      }
+    >
       <StartupScreen
-        version={info.version}
-        model={info.model}
-        connectedMcpServers={info.connectedMcpServers}
-        wikiReady={info.wikiReady}
-        workspaceName={info.workspaceName}
-        profileName={info.profileName}
-        workspaces={info.workspaces}
-        hasWorkspace={info.hasWorkspace}
+        version={startup().version}
+        model={startup().model}
+        connectedMcpServers={startup().connectedMcpServers}
+        wikiReady={startup().wikiReady}
+        workspaceName={startup().workspaceName}
+        profileName={startup().profileName}
+        workspaces={startup().workspaces}
+        hasWorkspace={startup().hasWorkspace}
         width={dimensions().width}
         height={dimensions().height}
+        keyboardEvent={startupKeyboardEvent()}
         onSelect={openAction}
         onQuit={() => renderer.destroy()}
       />
-    );
-  }
-
-  return (
-    <box width="100%" height="100%" flexDirection="row">
-      <LeftPane
-        width={leftColumns()}
-        title={state.title()}
-        statusLine={state.statusLine()}
-        hintLine={hintLine()}
-        showWelcome={state.showWelcome()}
-        messages={state.messages()}
-        prompt={state.prompt()}
-        input={state.input()}
-        busy={state.busy()}
-        chatMode={state.chatMode()}
-        chatFocused={!state.activeEditor()}
-        setInput={state.setInput}
-        submit={submit}
-        conversationRows={conversationRows()}
-        conversationColumns={conversationColumns()}
-        conversationScroll={state.conversationScroll()}
-        scrollConversation={state.scrollConversation}
-        spinnerFrame={SPINNER_FRAMES[spinnerIndex()] ?? SPINNER_FRAMES[0]}
-        onInputHeightChange={setChatInputHeight}
-        onCopy={(content) => showCopyHint(copyToClipboard(content, renderer) ? 'Copied.' : 'Copy failed.')}
-      />
-      <box width={1} height="100%" flexDirection="column">
-        {Array.from({ length: dimensions().height }, () => (
-          <text fg="#4B5563">│</text>
-        ))}
-      </box>
-      <RightPane
-        width={rightColumns()}
-        activities={state.activities()}
-        logs={state.logs()}
-        plan={state.plan()}
-        queueItems={state.queueItems()}
-        queueInfo={state.queueInfo()}
-        activeTab={state.rightTab()}
-        onTabClick={state.selectRightTab}
-      />
-      <SlashDialog context={state.activeEditor() ? null : state.slash()} />
-      <FileEditorDialog
-        editor={state.activeEditor()}
-        width={dimensions().width}
-        height={dimensions().height}
-        onSave={state.saveEditor}
-        onCancel={state.closeEditor}
-      />
-      {screen() === 'setup' ? (
-        <SetupWizard
-          mode="setup"
-          session={state.session}
-          width={dimensions().width}
-          height={dimensions().height}
-          initialRoute="workspace-name"
-          closeOnDone
-          onComplete={closeSetup}
-          onClose={closeSetup}
-        />
-      ) : null}
-    </box>
+    </Show>
   );
 }
 

package/src/shell/useAgent.ts

@@ -1,8 +1,8 @@
 import { createSignal } from 'solid-js';
 import { postRuntimeCancel } from '../runtime/client.js';
-import { conversationMessages, runLine, submitRuntimeRun } from './repl.js';
+import { conversationMessages, recordRuntimeUnavailableAgentInput, runLine, submitRuntimeRun } from './repl.js';
 
-export function useAgent(props: { agent: unknown; packageJson: Record<string, unknown>; session: Record<string, any>; chatMode: () => boolean; runtimeUrl?: string | null; refresh: () => void; addLog: (line: string) => void; onRuntimeAccepted?: () => void }) {
+export function useAgent(props: { agent: unknown; packageJson: Record<string, unknown>; session: Record<string, any>; chatMode: () => boolean; runtimeUrl?: string | null; runtimeUnavailableReason?: string | null; refresh: () => void; addLog: (line: string) => void; onRuntimeAccepted?: () => void }) {
   const [busy, setBusy] = createSignal(false);
   const [abortController, setAbortController] = createSignal<AbortController | null>(null);
 
@@ -19,13 +19,15 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
 
     try {
       if (props.runtimeUrl && !props.chatMode() && !trimmed.startsWith('/')) {
-        conversationMessages(props.session).push({ role: 'user', content: trimmed });
+        // Marked _pending so mergeRuntimeConversation (useSession.ts) can
+        // confirm this exact entry instead of pushing a second copy once the
+        // same user message comes back from the runtime's own /state.
+        conversationMessages(props.session).push({ role: 'user', content: trimmed, _pending: true });
         const outcome = await submitRuntimeRun(trimmed, {
           runtime: { url: props.runtimeUrl },
           session: props.session,
         });
         if (outcome.kind === 'accepted') {
-          conversationMessages(props.session).push({ role: 'command', content: `Runtime run queued: ${props.runtimeUrl}` });
           props.onRuntimeAccepted?.();
           props.addLog('runtime: run accepted');
         } else if (outcome.kind === 'queued') {
@@ -38,6 +40,14 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
         props.refresh();
         return { exit: false, runtime: true };
       }
+      if (!props.chatMode() && !trimmed.startsWith('/')) {
+        const message = recordRuntimeUnavailableAgentInput(props.session, trimmed, {
+          error: props.runtimeUnavailableReason ?? 'runtime introuvable',
+        });
+        props.addLog(message ?? 'runtime: disconnected');
+        props.refresh();
+        return { exit: false, runtimeUnavailable: true };
+      }
       const result = await runLine(trimmed, {
         agent: props.agent,
         packageJson: props.packageJson,

package/src/shell/useSession.ts

@@ -1,6 +1,6 @@
 import { writeFileSync } from 'node:fs';
 import { isAbsolute, relative, resolve, sep } from 'node:path';
-import { createMemo, createSignal, onCleanup } from 'solid-js';
+import { createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
 import { formatMcpToolResult, callMcpTool } from '../core/mcp.js';
 import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
 import { formatPlanStatus, formatCompletedActivities } from '../core/plan.js';
@@ -14,12 +14,13 @@ import {
   completionDescription,
   conversationMessages,
   createSession,
+  runtimeUnavailableAgentMessage,
 } from './repl.js';
 import { useAgent } from './useAgent';
 
-function runtimeStatusText(status: 'disabled' | 'connected' | 'disconnected', runStatus: string): string {
-  if (status === 'connected') return `runtime ${runStatus}`;
-  if (status === 'disconnected') return 'runtime offline';
+function runtimeStatusText(status: 'disabled' | 'connected' | 'disconnected', runStatus: string, reason: string | null, workspace: string | null): string {
+  if (status === 'connected') return `runtime: connected (${workspace ?? 'no workspace'}) ${runStatus}`;
+  if (status === 'disconnected') return reason ? `runtime: disconnected: ${reason}` : 'runtime offline';
   return 'runtime off';
 }
 
@@ -74,13 +75,21 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   const addLog = (line: string) => {
     setLogs((items) => [...items, `${new Date().toLocaleTimeString()} ${line}`].slice(-200));
   };
+  const runtimeUnavailableReason = createMemo(() => {
+    if (props.runtime?.url) return null;
+    const reason = props.runtime?.error ?? props.runtime?.unavailableReason ?? props.runtime?.reason ?? null;
+    return reason ? String(reason) : null;
+  });
   if (props.runtime?.url) addLog(`runtime: connected ${props.runtime.url}${props.runtime.started ? ' (started)' : ''}`);
+  else if (props.runtime?.error) addLog(`runtime: unavailable — ${props.runtime.error}`);
+  else if (runtimeUnavailableReason()) addLog(`runtime: disconnected: ${runtimeUnavailableReason()}`);
   const agent = useAgent({
     agent: props.agent,
     packageJson: props.packageJson,
     session,
     chatMode,
     runtimeUrl: props.runtime?.url ?? null,
+    runtimeUnavailableReason: runtimeUnavailableReason(),
     refresh,
     addLog,
     onRuntimeAccepted: () => {
@@ -97,23 +106,22 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   );
   const localFallbackActive = createMemo(() => !props.runtime?.url || runtimeStatus() === 'disconnected');
 
+  // Runtime conversation entries are merged into conversationMessages(session)
+  // (see mergeRuntimeConversation below) as they arrive, so they land in true
+  // chronological order alongside local command output (/status, /use, ...)
+  // instead of being reconstructed as two separately-ordered blocks at render
+  // time — that used to put every local command before the whole runtime
+  // history regardless of when each one actually happened.
   const messages = createMemo(() => {
     version();
+    return [...conversationMessages(session)].slice(-200);
+  });
+  createEffect(() => {
     const runtimeConversation = runtimeState()?.conversation;
-    const localCommands = conversationMessages(session)
-      .filter((message: any) => message.role === 'command')
-      .map((message: any) => ({
-        role: 'command',
-        content: String(message.content ?? ''),
-      }));
     if (Array.isArray(runtimeConversation) && runtimeConversation.length > 0) {
-      const runtimeMessages = runtimeConversation.map((message: any) => ({
-        role: message.role === 'assistant' ? 'donna' : message.role,
-        content: String(message.content ?? ''),
-      }));
-      return [...runtimeMessages, ...localCommands].slice(-200);
+      setShowWelcome(false);
+      setConversationScroll(0);
     }
-    return [...conversationMessages(session)];
   });
   const prompt = createMemo(() => {
     version();
@@ -133,9 +141,14 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
       session.wikirc?.profile ? session.wikirc.profile : 'no wikirc',
       session.language ? session.language : 'no language',
       session.llm ? 'llm ready' : 'llm limited',
-      runtimeStatusText(runtimeStatus(), runtimeRunStatus()),
+      runtimeStatusText(runtimeStatus(), runtimeRunStatus(), runtimeUnavailableReason(), session.workspace),
     ].join('  ');
   });
+  const runtimeHint = createMemo(() => {
+    version();
+    if (props.runtime?.url) return null;
+    return runtimeUnavailableAgentMessage({ error: runtimeUnavailableReason() ?? 'runtime introuvable' });
+  });
   const matchContext = createMemo(() => {
     if (input() === dismissedSlashInput()) return null;
     return completionContext(input(), session);
@@ -263,10 +276,54 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     return [...logs(), ...tagged].slice(-200);
   });
 
+  // Index-aligned with each workspace's runtimeConversation array — not just
+  // a length count. The server sometimes finalizes a streaming placeholder
+  // (queued during a tool-calling turn, never closed out because that turn's
+  // reply had no final text) by overwriting the *same* conversation entry's
+  // content on a later turn, without the array growing. A length-based diff
+  // would miss that update entirely and leave the stale placeholder text
+  // shown forever; tracking local entry references per index picks it up.
+  const runtimeConversationRefsByWorkspace = new Map<string, any[]>();
+  function mergeRuntimeConversation(state: any) {
+    const workspace = (session as any).workspace || '__global__';
+    const runtimeConversation = Array.isArray(state?.conversation) ? state.conversation : [];
+    if (runtimeConversation.length === 0) return;
+    const target = conversationMessages(session);
+    const backed = runtimeConversationRefsByWorkspace.get(workspace) ?? [];
+    runtimeConversationRefsByWorkspace.set(workspace, backed);
+    for (let i = 0; i < runtimeConversation.length; i += 1) {
+      const message = runtimeConversation[i];
+      const content = String(message.content ?? '');
+      const role = message.role === 'assistant' ? 'donna' : message.role;
+      if (i < backed.length) {
+        const entry = backed[i];
+        if (entry.content !== content) entry.content = content;
+        if (entry.role !== role) entry.role = role;
+        continue;
+      }
+      if (role === 'user') {
+        // The user's own message was already pushed optimistically (see
+        // useAgent.ts) and marked _pending — confirm that entry instead of
+        // adding a second copy. No matching pending entry (e.g. history
+        // restored after a fresh reconnect) falls through to a normal push.
+        const pendingIndex = target.findIndex((entry: any) => entry._pending && entry.role === 'user' && entry.content === content);
+        if (pendingIndex !== -1) {
+          delete target[pendingIndex]._pending;
+          backed.push(target[pendingIndex]);
+          continue;
+        }
+      }
+      const entry = { role, content };
+      target.push(entry);
+      backed.push(entry);
+    }
+  }
+
   function syncRuntimeState() {
     void fetchRuntimeState({ url: props.runtime.url, workspace: (session as any).workspace ?? null })
       .then((state) => {
         setRuntimeState(state);
+        mergeRuntimeConversation(state);
         setRuntimeStatus('connected');
         refresh();
       })
@@ -310,6 +367,22 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     syncRuntimeState();
     void subscribeRuntimeEvents();
   }
+
+  let currentRuntimeWorkspace = (session as any).workspace ?? null;
+  function resyncRuntimeWorkspaceIfChanged() {
+    const workspace = (session as any).workspace ?? null;
+    if (workspace === currentRuntimeWorkspace) return;
+    currentRuntimeWorkspace = workspace;
+    if (!props.runtime?.url) return;
+    if (runtimeReconnectTimer) {
+      clearTimeout(runtimeReconnectTimer);
+      runtimeReconnectTimer = null;
+    }
+    runtimeStreamAbort?.abort();
+    syncRuntimeState();
+    void subscribeRuntimeEvents();
+  }
+
   onCleanup(() => {
     runtimeStreamStopped = true;
     runtimeStreamAbort?.abort();
@@ -408,6 +481,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     lastActivityLines.clear();
     lastActivityDetails.clear();
     const result = await agent.submit(line);
+    resyncRuntimeWorkspaceIfChanged();
     if ((result as any)?.setMode === 'chat') {
       setChatMode(true);
       (session as any).chatMode = true;
@@ -523,6 +597,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     setInput: updateInput,
     title,
     statusLine,
+    runtimeHint,
     chatMode,
     showWelcome,
     activeEditor,