mixdog 0.9.84 → 0.9.86

package/src/standalone/memory-runtime-proxy.mjs

@@ -103,10 +103,52 @@ function isMemoryReadOnlyToolCall(name, args = {}) {
   return false;
 }
 
-function requestJson({ port, method = 'GET', path = '/', body = null, timeoutMs = 10_000, headers = {} }) {
-  return new Promise((resolvePromise, reject) => {
+function memoryAbortError(reason) {
+  if (reason instanceof Error) return reason;
+  const error = new Error(typeof reason === 'string' && reason ? reason : 'memory proxy request aborted');
+  error.name = 'AbortError';
+  error.code = 'ABORT_ERR';
+  return error;
+}
+
+export function requestJson({
+  port,
+  method = 'GET',
+  path = '/',
+  body = null,
+  timeoutMs = 10_000,
+  headers = {},
+  signal = null,
+}) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    let settled = false;
+    let req = null;
+    const cleanup = () => {
+      try { signal?.removeEventListener?.('abort', onAbort); } catch {}
+    };
+    const resolve = (value) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolvePromise(value);
+    };
+    const reject = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      rejectPromise(error);
+    };
+    const onAbort = () => {
+      const error = memoryAbortError(signal?.reason);
+      if (req) req.destroy(error);
+      else reject(error);
+    };
+    if (signal?.aborted) {
+      reject(memoryAbortError(signal.reason));
+      return;
+    }
     const payload = body == null ? null : JSON.stringify(body);
-    const req = http.request({
+    req = http.request({
       hostname: '127.0.0.1',
       port,
       path,
@@ -135,14 +177,19 @@ function requestJson({ port, method = 'GET', path = '/', body = null, timeoutMs
           reject(error);
           return;
         }
-        resolvePromise(parsed ?? { raw: data });
+        resolve(parsed ?? { raw: data });
       });
+      res.on('error', reject);
     });
     req.on('error', reject);
     req.on('timeout', () => {
-      req.destroy();
-      reject(new Error(`memory proxy request timed out: ${method} ${path}`));
+      req.destroy(new Error(`memory proxy request timed out: ${method} ${path}`));
     });
+    try { signal?.addEventListener?.('abort', onAbort, { once: true }); } catch {}
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
     if (payload) req.write(payload);
     req.end();
   });
@@ -496,26 +543,54 @@ export function createStandaloneMemoryRuntime({
     return { running: true, port, mode: 'http-proxy' };
   }
 
-  async function handleToolCall(name, args = {}) {
+  async function handleToolCall(name, args = {}, signalOrOptions = null) {
+    const signal = signalOrOptions?.signal || signalOrOptions || null;
     const readOnlyRpc = isMemoryReadOnlyToolCall(name, args);
     const callId = `mem_${process.pid}_${nextCallId++}`;
-    return await withTransientMemoryRpcRetry(async () => {
-      await start();
-      let port = portCache || await findLivePort({ allowStarting: true });
-      if (!port) throw new Error('memory runtime is not available');
-      // ensureClientRegistered may respawn onto a fresh daemon/port; target the
-      // port it hands back so the RPC and registration always hit the same one.
-      port = await ensureClientRegistered(port);
-      if (!port) throw new Error('memory runtime is not available');
-      return await requestJson({
-        port,
+    let activePort = null;
+    let rpcStarted = false;
+    const throwIfAborted = () => {
+      if (signal?.aborted) throw memoryAbortError(signal.reason);
+    };
+    const cancelRemote = () => {
+      if (!activePort || !rpcStarted) return;
+      void requestJson({
+        port: activePort,
         method: 'POST',
-        path: '/api/tool',
-        body: { name, arguments: args || {} },
-        timeoutMs: Math.max(1000, Number(process.env.MIXDOG_MEMORY_TOOL_TIMEOUT_MS) || 180_000),
-        headers: { 'X-Mixdog-Call-Id': callId },
-      });
-    }, { readOnlyRpc });
+        path: '/api/cancel',
+        body: { callId },
+        timeoutMs: 1500,
+      }).catch(() => {});
+    };
+    throwIfAborted();
+    try { signal?.addEventListener?.('abort', cancelRemote, { once: true }); } catch {}
+    try {
+      return await withTransientMemoryRpcRetry(async () => {
+        throwIfAborted();
+        await start();
+        throwIfAborted();
+        let port = portCache || await findLivePort({ allowStarting: true });
+        if (!port) throw new Error('memory runtime is not available');
+        // ensureClientRegistered may respawn onto a fresh daemon/port; target the
+        // port it hands back so the RPC and registration always hit the same one.
+        port = await ensureClientRegistered(port);
+        if (!port) throw new Error('memory runtime is not available');
+        activePort = port;
+        throwIfAborted();
+        rpcStarted = true;
+        return await requestJson({
+          port,
+          method: 'POST',
+          path: '/api/tool',
+          body: { name, arguments: args || {} },
+          timeoutMs: Math.max(1000, Number(process.env.MIXDOG_MEMORY_TOOL_TIMEOUT_MS) || 180_000),
+          headers: { 'X-Mixdog-Call-Id': callId },
+          signal,
+        });
+      }, { readOnlyRpc });
+    } finally {
+      try { signal?.removeEventListener?.('abort', cancelRemote); } catch {}
+    }
   }
 
   async function buildSessionCoreMemoryPayload(sessionCwd) {

package/src/tui/App.jsx

@@ -686,8 +686,6 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     openAgentsPicker,
     openWorkflowPicker,
     openOutputStylePicker,
-    openBridgePicker,
-    openToolsPicker,
   } = createRoutePickers({
     store,
     state,
@@ -699,7 +697,6 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     setContextPanel,
     closeUsagePanel,
     clean,
-    copyToClipboard,
     routeLabel,
     agentModelParts,
     agentModelProfile,
@@ -726,8 +723,6 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     openAgentsPicker: (...a) => openAgentsPicker(...a),
     openWorkflowPicker: (...a) => openWorkflowPicker(...a),
     openOutputStylePicker: (...a) => openOutputStylePicker(...a),
-    openBridgePicker: (...a) => openBridgePicker(...a),
-    openToolsPicker: (...a) => openToolsPicker(...a),
     openProviderSetupPicker: (...a) => openProviderSetupPicker(...a),
     openThemePicker: (...a) => openThemePicker(...a),
     openAutoClearPicker: (...a) => openAutoClearPicker(...a),
@@ -736,6 +731,7 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     openPluginsPicker: (...a) => openPluginsPicker(...a),
     openHooksPicker: (...a) => openHooksPicker(...a),
     openSkillsPicker: (...a) => openSkillsPicker(...a),
+    openMemoryCorePicker: (...a) => openMemoryCorePicker(...a),
     openUpdatePicker: (...a) => openUpdatePicker(...a),
     openChannelSettingTypePicker: (...a) => openChannelSettingTypePicker(...a),
   });
@@ -756,10 +752,8 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     openThemePicker: (...a) => openThemePicker(...a),
     themeNotice,
     openEffortPicker: (...a) => openEffortPicker(...a),
-    projectNameFromPath,
     enterProject: (...a) => enterProject(...a),
     openProjectPicker: (...a) => openProjectPicker(...a),
-    openToolsPicker: (...a) => openToolsPicker(...a),
     openMcpPicker: (...a) => openMcpPicker(...a),
     openSkillsPicker: (...a) => openSkillsPicker(...a),
     openPluginsPicker: (...a) => openPluginsPicker(...a),
@@ -2510,8 +2504,6 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
   // Slash search floats above the normal prompt. Actual option panels own the
   // prompt/status area, so they hide those rows and expand into that space.
   const inputBoxHidden = expandedOptionPanel || bootSettling;
-  const showWelcomeBanner = (state.items.length === 0 && !hasFloatingPanel) || projectSelectionActive || onboardingActive;
-  const WELCOME_ROWS = showWelcomeBanner ? 11 : 0;
   const liveSpinner = state.spinner?.active ? state.spinner : (state.commandStatus?.active ? state.commandStatus : null);
   // Command-status spinner (auto-clear/compact/etc.) is NOT part of the
   // spinner → TurnDone handoff: it typically starts while the transcript tail
@@ -2616,6 +2608,21 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
   const queuedCompact = queuedFullRows > queuedRowBudget;
   const queuedRows = queuedVisible ? (queuedCompact ? state.queued.length : queuedFullRows) : 0;
   const INPUT_BOX_ROWS = promptBoxRows + promptMetaRows + overlayHintRows;
+  // Welcome banner visibility (computed here, after the prompt/panel row math
+  // it depends on). The slash palette must NOT unmount the banner on the empty
+  // transcript: dropping the 11-row banner the moment '/' opened the palette
+  // (and remounting it on Esc) read as the whole top of the screen jumping on
+  // command-palette entry. Keep the banner mounted through a slash session
+  // whenever the terminal is tall enough to hold banner + palette + prompt +
+  // statusline at once; short terminals still yield the banner so the palette
+  // chrome never clips (the floating container clips from the top).
+  const WELCOME_BANNER_ROWS = 11;
+  const SLASH_PALETTE_ROWS = PANEL_MAX_VISIBLE + PANEL_CHROME_ROWS;
+  const slashKeepsWelcomeBanner = slashPaletteOpen
+    && resizeState.rows >= WELCOME_BANNER_ROWS + SLASH_PALETTE_ROWS + INPUT_BOX_ROWS + STATUSLINE_ROWS + 1;
+  const showWelcomeBanner = (state.items.length === 0 && (!hasFloatingPanel || slashKeepsWelcomeBanner))
+    || projectSelectionActive || onboardingActive;
+  const WELCOME_ROWS = showWelcomeBanner ? WELCOME_BANNER_ROWS : 0;
   const baseReserve = WELCOME_ROWS + SCROLL_HINT_ROWS + LIVE_STATUS_ROWS + INPUT_BOX_ROWS + STATUSLINE_ROWS + queuedRows;
   const maxFloatingPanelRows = Math.max(0, resizeState.rows - baseReserve - 1);
   const desiredFloatingPanelRows = toolApproval

package/src/tui/app/channel-pickers.mjs

@@ -309,12 +309,13 @@ export function createChannelPickers({
         value: 'webhook-endpoint',
         label: 'Webhook endpoint',
         // Relay tunnel: public exposure is automatic, so the endpoint is
-        // "On" whenever the webhook server itself is enabled.
+        // "On" whenever the webhook server itself is enabled. Info-only row:
+        // endpoint management lives in the desktop Webhooks page.
         meta: setup.webhook?.enabled === false ? 'Off' : 'On',
         description: setup.webhook?.publicUrl
           ? setup.webhook.publicUrl
           : 'Mixdog relay tunnel — URL assigned on first run',
-        _action: 'webhook-endpoint',
+        _action: null,
       },
     ];
 
@@ -361,12 +362,6 @@ export function createChannelPickers({
             });
             return;
           }
-          if (item._action === 'webhook-endpoint') {
-            void openChannelSetupPicker('webhook-endpoint', {
-              ...(options.onboarding ? { onboarding: true, confirmBar: options.confirmBar || null } : {}),
-              returnTo: () => reopenRoot({ highlightValue: 'webhook-endpoint' }),
-            });
-          }
         } catch (e) {
           store.pushNotice(`channels update failed: ${e?.message || e}`, 'error');
         }

package/src/tui/app/route-pickers.mjs

@@ -27,7 +27,6 @@ export function createRoutePickers({
   setContextPanel,
   closeUsagePanel,
   clean,
-  copyToClipboard,
   routeLabel,
   agentModelParts,
   agentModelProfile,
@@ -158,28 +157,134 @@ export function createRoutePickers({
     closeUsagePanel();
     setPicker({
       title: 'Workflow',
-      description: 'Select active workflow.',
-      help: returnTo ? '↑/↓ Select · Enter Choose · Esc Settings' : '↑/↓ Select · Enter Choose · Esc Back',
+      description: 'Active workflow and its agents.',
+      help: returnTo ? '↑/↓ Select · Enter Open · Esc Settings' : '↑/↓ Select · Enter Open · Esc Back',
       labelWidth: 18,
+      initialIndex: Math.max(0, items.findIndex((item) => item.value === (options.initialWorkflowId || ''))),
       items,
       onSelect: (_value, item) => {
         const workflow = item?._workflow;
         if (!workflow) return;
+        // Depth mirrors the system model: a workflow pack owns the agent set
+        // it delegates to, so Enter opens the pack (activate + its agents)
+        // instead of switching immediately.
+        openWorkflowDetailPicker(workflow.id, { returnTo });
+      },
+      onCancel: () => {
         setPicker(null);
-        void store.setWorkflow?.(workflow.id)
-          .then((result) => {
+        if (returnTo) returnTo();
+      },
+    });
+  };
+
+  // Workflow detail: activation row plus the agents this pack delegates to
+  // (route editing inline). Packs without an `agents:` key delegate to all
+  // fixed agents; a configured-but-empty list means Lead works alone.
+  const openWorkflowDetailPicker = (workflowId, options = {}) => {
+    const returnTo = typeof options.returnTo === 'function' ? options.returnTo : null;
+    let workflows = [];
+    try {
+      workflows = store.listWorkflows?.() || [];
+    } catch (e) {
+      store.pushNotice(`could not list workflows: ${e?.message || e}`, 'error');
+      return;
+    }
+    const workflow = workflows.find((item) => item.id === workflowId);
+    if (!workflow) {
+      store.pushNotice(`workflow "${workflowId}" not found`, 'warn');
+      openWorkflowPicker({ returnTo });
+      return;
+    }
+    let agents = [];
+    try {
+      agents = store.listAgents?.() || [];
+    } catch (e) {
+      store.pushNotice(`could not list agents: ${e?.message || e}`, 'error');
+      agents = [];
+    }
+    const packAgents = workflow.agentsConfigured === true
+      ? (workflow.agents || [])
+          .map((id) => agents.find((agent) => agent.id === id) || { id, label: id, route: null, description: '' })
+      : agents.filter((agent) => agent.custom !== true);
+    const routeOverrides = options.routeOverrides && typeof options.routeOverrides === 'object' ? options.routeOverrides : {};
+    const items = [
+      {
+        value: '__activate',
+        label: workflow.active ? 'Active' : 'Activate',
+        marker: workflow.active ? '✓' : '',
+        markerColor: theme.success,
+        description: workflow.active
+          ? 'This workflow is active.'
+          : 'Make this the active workflow.',
+      },
+      ...(packAgents.length
+        ? packAgents.map((agent) => ({
+            value: agent.id,
+            label: agent.label,
+            metaParts: agentModelParts(routeOverrides[agent.id] || agent.route),
+            description: agent.description || agent.definition?.description || '',
+            _agent: agent,
+          }))
+        : [{
+            value: '__lead-only',
+            label: 'Lead only',
+            description: 'This workflow delegates to no agents.',
+          }]),
+    ];
+    setPicker({
+      title: workflow.name,
+      description: workflow.description || 'Workflow activation and agents.',
+      help: '↑/↓ Select · Enter Choose · Esc Back',
+      indexMode: 'always',
+      labelWidth: 18,
+      metaWidth: 33,
+      initialIndex: Math.max(0, items.findIndex((item) => item.value === (options.initialValue || '__activate'))),
+      items,
+      onSelect: (_value, item) => {
+        if (item?.value === '__activate') {
+          if (workflow.active) {
+            store.pushNotice(`${workflow.name} is already the active workflow`, 'info');
+            return;
+          }
+          setPicker(null);
+          void store.setWorkflow?.(workflow.id)
+            .then((result) => {
+              if (!result) {
+                store.pushNotice('Workflow switch is already running.', 'warn');
+                return;
+              }
+              store.pushNotice(workflowSwitchNotice(result), 'info');
+              openWorkflowPicker({ returnTo, initialWorkflowId: workflow.id });
+            })
+            .catch((e) => store.pushNotice(`Couldn’t switch workflow: ${e?.message || e}`, 'error'));
+          return;
+        }
+        const agent = item?._agent;
+        if (!agent) return;
+        void openModelPicker({
+          title: `${agent.label} Model`,
+          providerDescription: 'Choose a provider for this agent.',
+          currentRoute: agent.route || null,
+          returnTo: () => openWorkflowDetailPicker(workflow.id, { returnTo, initialValue: agent.id }),
+          onImmediateSelect: (routeInput) => {
+            openWorkflowDetailPicker(workflow.id, {
+              returnTo,
+              routeOverrides: { [agent.id]: routeInput },
+              initialValue: agent.id,
+            });
+          },
+          onSelectRoute: async (routeInput) => {
+            const result = await store.setAgentRoute?.(agent.id, routeInput);
             if (!result) {
-              store.pushNotice('Workflow switch is already running.', 'warn');
+              store.pushNotice('Agent model save is already running.', 'warn');
               return;
             }
-            store.pushNotice(workflowSwitchNotice(result), 'info');
-            if (returnTo) returnTo();
-          })
-          .catch((e) => store.pushNotice(`Couldn’t switch workflow: ${e?.message || e}`, 'error'));
+            store.pushNotice(`${agent.label} model set to ${agentModelProfile(result)}`, 'info');
+          },
+        });
       },
       onCancel: () => {
-        setPicker(null);
-        if (returnTo) returnTo();
+        openWorkflowPicker({ returnTo, initialWorkflowId: workflow.id });
       },
     });
   };
@@ -274,150 +379,10 @@ export function createRoutePickers({
     });
   };
 
-  const openBridgePicker = () => {
-    setProviderPrompt(null);
-    setChannelPrompt(null);
-    setHookPrompt(null);
-    setSettingsPrompt(null);
-    setPicker({
-      title: 'Agent Tasks',
-      description: 'Inspect or clean up background agent tasks.',
-      items: [
-        {
-          value: 'list',
-          label: 'List agents/tasks',
-          description: 'show active agents and async tasks',
-          _action: 'control',
-          _args: { type: 'list' },
-        },
-        {
-          value: 'cleanup',
-          label: 'Cleanup finished tasks',
-          description: 'remove completed agent task records',
-          _action: 'control',
-          _args: { type: 'cleanup' },
-        },
-      ],
-      onSelect: (_value, item) => {
-        setPicker(null);
-        if (item._action === 'control') {
-          void store.agentControl?.(item._args)
-            .catch((e) => store.pushNotice(`agent failed: ${e?.message || e}`, 'error'));
-        }
-      },
-      onCancel: () => {
-        setPicker(null);
-      },
-    });
-  };
-
-  const openToolsPicker = (query = '') => {
-    let status;
-    try {
-      status = store.toolsStatus?.(query) || { tools: [] };
-    } catch (e) {
-      store.pushNotice(`tools status failed: ${e?.message || e}`, 'error');
-      return;
-    }
-    const tools = status.tools || [];
-    const items = [
-      {
-        value: 'summary',
-        label: 'Tool surface',
-        description: `${status.activeCount || 0}/${status.count || 0} active · mode ${status.mode || state.toolMode}`,
-        _action: 'summary',
-      },
-      ...(tools.length ? tools.map((tool) => ({
-        value: tool.name,
-        label: tool.name,
-        marker: tool.active ? '●' : '○',
-        markerColor: tool.active ? theme.success : theme.inactive,
-        description: `${tool.kind || 'tool'} · usage ${tool.usage || 0}${tool.description ? ` · ${tool.description}` : ''}`,
-        _action: tool.active ? 'tool' : 'enable',
-        _tool: tool,
-      })) : [{
-        value: 'empty',
-        label: 'No tools',
-        description: query ? `no matches for "${query}"` : 'tool catalog is empty',
-        _action: 'noop',
-      }]),
-    ];
-    setProviderPrompt(null);
-    setChannelPrompt(null);
-    setHookPrompt(null);
-    setSettingsPrompt(null);
-    setPicker({
-      title: query ? `Tools · ${query}` : 'Tools',
-      description: 'Browse active and deferred tools.',
-      items,
-      onSelect: (_value, item) => {
-        setPicker(null);
-        if (item._action === 'summary') {
-          store.pushNotice([
-            `mode: ${status.mode || state.toolMode}`,
-            `active: ${status.activeCount || 0}/${status.count || 0}`,
-            `active tools: ${(status.activeTools || []).join(', ') || '(none)'}`,
-          ].join('\n'), 'info');
-          return;
-        }
-        if (item._action === 'enable') {
-          store.selectTools?.([item._tool.name]);
-          void openToolsPicker(query);
-          return;
-        }
-        if (item._action === 'tool') {
-          const tool = item._tool;
-          setPicker({
-            title: `Tool · ${tool.name}`,
-            description: 'Tool details and quick actions.',
-            items: [
-              {
-                value: 'info',
-                label: 'Tool info',
-                description: `${tool.kind || 'tool'} · ${tool.active ? 'active' : 'deferred'}`,
-                _action: 'info',
-              },
-              {
-                value: 'copy-name',
-                label: 'Copy name',
-                description: tool.name,
-                _action: 'copy-name',
-              },
-            ],
-            onSelect: (_detailValue, detail) => {
-              setPicker(null);
-              if (detail._action === 'info') {
-                store.pushNotice([
-                  tool.name,
-                  `kind: ${tool.kind || 'tool'}`,
-                  `state: ${tool.active ? 'active' : 'deferred'}`,
-                  `usage: ${tool.usage || 0}`,
-                  tool.description || '',
-                ].filter(Boolean).join('\n'), 'info');
-                return;
-              }
-              if (detail._action === 'copy-name') {
-                void copyToClipboard(tool.name)
-                  .then(() => store.pushNotice(`copied tool name: ${tool.name}`, 'plain'))
-                  .catch((e) => store.pushNotice(`copy failed: ${e?.message || e}`, 'error'));
-              }
-            },
-            onCancel: () => openToolsPicker(query),
-          });
-        }
-      },
-      onCancel: () => {
-        setPicker(null);
-      },
-    });
-  };
-
   return {
     openSearchPicker,
     openAgentsPicker,
     openWorkflowPicker,
     openOutputStylePicker,
-    openBridgePicker,
-    openToolsPicker,
   };
 }