@dotdrelle/wiki-manager 0.15.48 → 0.15.50

package/src/runtime/server.test.js

@@ -728,6 +728,57 @@ test('runtime server kill can target a specific run id', async (t) => {
   }
 });
 
+test('runtime server kill purge without workspace is refused', async (t) => {
+  let clearedArgs = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+        interruptRuns: () => 0,
+        cancelActiveTasksForInterruptedRuns: () => 0,
+        clearWorkspaceState: (args) => {
+          clearedArgs = args;
+          return { runs: 0, events: 0, queue: 0 };
+        },
+      },
+      session: {},
+      run: async () => {},
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const unscoped = await fetch(`http://127.0.0.1:${handle.port}/kill`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ purge: true }),
+    });
+    assert.equal(unscoped.status, 400);
+    assert.deepEqual(await unscoped.json(), { killed: false, reason: 'workspace_required' });
+    assert.equal(clearedArgs, null);
+
+    const scoped = await fetch(`http://127.0.0.1:${handle.port}/kill?workspace=docs`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ purge: true }),
+    });
+    assert.equal(scoped.status, 202);
+    assert.equal(clearedArgs.workspace, 'docs');
+  } finally {
+    await handle.close();
+  }
+});
+
 test('runtime server state exposes active run identity while running', async (t) => {
   let releaseRun;
   const context = {
@@ -1031,6 +1082,7 @@ test('runtime server exposes approval endpoint', async (t) => {
       groupId: null,
       planRevision: null,
       approvalClasses: [],
+      caller: null,
     });
     assert.deepEqual(await response.json(), { approved: true, runId: 'run-1', itemId: 'item-1' });
   } finally {
@@ -1256,11 +1308,21 @@ test('runtime server control message handles approve and cancel intents during a
     const approveResponse = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ action: 'message', input: 'valide tout' }),
+      body: JSON.stringify({ action: 'message', input: 'valide tout', intent: 'approve' }),
     });
     assert.equal(approveResponse.status, 200);
     assert.equal((await approveResponse.json()).kind, 'approve');
 
+    // Free-text approval phrasing is NOT honored anymore: approval is an
+    // explicit /approve (or the approval button), never a keyword match.
+    const freeTextResponse = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'message', input: 'valide tout' }),
+    });
+    assert.equal(freeTextResponse.status, 200);
+    assert.notEqual((await freeTextResponse.json()).kind, 'approve');
+
     const cancelResponse = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },

package/src/runtime/supervisor.js

@@ -13,6 +13,7 @@ export function startActivitySupervisor(session, {
   agentRegistryIntervalMs = registryIntervalFromEnv(),
   agentRegistry = null,
   callTool = callMcpTool,
+  refreshMcp = null,
 } = {}) {
   const pollBusy = new Set();
   let stopped = false;
@@ -32,8 +33,24 @@ export function startActivitySupervisor(session, {
     }
   }, queueIntervalMs);
 
+  /*
+   The re-scan must probe the endpoints again, not trust a stale status.
+
+   The first discovery ran while the containers were still coming up, so the
+   production endpoint was marked "not connected" and its agent fell back to a
+   legacy placeholder. Re-scanning against that cached status kept the fallback
+   forever. `refreshMcp` re-resolves the endpoint states (and their tools)
+   before each discovery, so a container that came up is actually discovered.
+  */
   const agentRegistryTimer = agentRegistryIntervalMs > 0
-    ? setInterval(() => {
+    ? setInterval(async () => {
+      if (refreshMcp) {
+        try {
+          await refreshMcp(session);
+        } catch {
+          /* the discovery below still runs on the cached status */
+        }
+      }
       void discoverAgentsOnce(session, { registry, signal: runSignal });
     }, agentRegistryIntervalMs)
     : null;

package/src/runtime/supervisor.test.js

@@ -246,6 +246,49 @@ test('startActivitySupervisor periodically re-scans the agent registry', async (
   }
 });
 
+test('startActivitySupervisor refreshes MCP before each periodic re-scan', async () => {
+  /*
+   Without the refresh, the re-scan re-reads a cached "not connected" endpoint
+   status and keeps a legacy placeholder forever, so an agent whose container
+   came up after boot is never discovered. The refresh probes the endpoints
+   again before the scan.
+  */
+  const session = {
+    mcp: {},
+    activities: {},
+    headlessPlan: null,
+    jobQueue: [],
+  };
+  let refreshes = 0;
+  let discoveries = 0;
+  const registry = {
+    async discover() {
+      discoveries += 1;
+      return [];
+    },
+    snapshot() {
+      return [];
+    },
+  };
+
+  const supervisor = startActivitySupervisor(session, {
+    intervalMs: 1000,
+    queueIntervalMs: 1000,
+    agentRegistryIntervalMs: 10,
+    agentRegistry: registry,
+    refreshMcp: async () => {
+      refreshes += 1;
+    },
+  });
+
+  try {
+    await waitFor(() => refreshes >= 2);
+    assert.ok(discoveries >= 2);
+  } finally {
+    supervisor.stop();
+  }
+});
+
 test('discoverAgentsOnce uses the session registry and returns discovered agents', async () => {
   const expected = [{ agentInstanceId: 'a' }];
   const registry = {

package/src/shell/LeftPane.tsx

@@ -822,14 +822,17 @@ export function LeftPane(props: {
   const showWelcome = () => props.showWelcome && props.messages.length === 0;
   return (
     <box width={props.width} height="100%" flexDirection="column" padding={1} overflow="hidden">
-      <box height={3} flexDirection="column">
+      {/*
+        The header keeps what changes the MEANING of what is typed — the mode,
+        and the transient hint. Workspace, version and connection states moved
+        to the foot of the pane: they are an ambient state one glances at, not
+        something read before every message, and at the top they pushed the
+        conversation down by a line for standing information.
+      */}
+      <box height={2} flexDirection="column">
         <box height={1} flexDirection="row" backgroundColor={modeColor()} paddingX={1}>
           <text fg="#0B1020">{modeLabel()}</text>
         </box>
-        <box height={1} flexDirection="row">
-          <text fg="#D6DEE8">{props.title}</text>
-          <text fg="#7F8C8D">  {props.statusLine}</text>
-        </box>
         <box height={1} flexDirection="row">
           {props.hintLine ? <text fg="#FBBF24">[ {props.hintLine} ]</text> : null}
         </box>
@@ -860,6 +863,15 @@ export function LeftPane(props: {
         onSubmit={props.submit}
         onHeightChange={props.onInputHeightChange}
       />
+      {/*
+        Status foot. One line, as in the header before it, so the row budget of
+        `conversationRows` (height - 5 - input) is unchanged: the line moved,
+        it was not added.
+      */}
+      <box height={1} flexDirection="row">
+        <text fg="#D6DEE8">{props.title}</text>
+        <text fg="#7F8C8D">  {props.statusLine}</text>
+      </box>
     </box>
   );
 }

package/src/shell/StartupScreen.tsx

@@ -249,7 +249,15 @@ export function StartupScreen(props: {
     return `${workspace} / ${profile}`;
   });
 
-  const innerWidth = createMemo(() => Math.max(40, panelWidth() - 6));
+  /*
+   Usable width inside the panel.
+
+   The panel has no border any more, only `padding={2}`: 4 columns, not 6. The
+   two extra columns were the border's, and keeping them would leave the text
+   measured for a frame that is no longer drawn — every `fit()` truncating two
+   characters early for nothing.
+  */
+  const innerWidth = createMemo(() => Math.max(40, panelWidth() - 4));
   const shortcutHint = createMemo(() => {
     const count = currentLength();
     const quick = count === 1 ? '1 quick select' : `1-${count} quick select`;
@@ -267,9 +275,6 @@ export function StartupScreen(props: {
         top={top()}
         width={panelWidth()}
         height={panelHeight()}
-        border
-        borderStyle="rounded"
-        borderColor="#8BD5CA"
         backgroundColor="#111318"
         padding={2}
         flexDirection="column"

package/src/shell/repl.js

@@ -2115,6 +2115,7 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
               url: runtime.url,
               workspace: session.workspace ?? null,
               ...(kind === 'item' ? { itemId: id } : kind === 'approval' ? { approvalId: id } : { runId: id }),
+              caller: 'shell-/approve',
             });
             conversationMessages(session).push({ role: 'command', content: `Approval ${result.approved ? 'accepted' : 'not found'}: ${id}` });
             syncRuntimeState();