mu-coding 0.11.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mu-coding",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Minimal terminal AI assistant for local models",
   "type": "module",
   "bin": {
@@ -24,9 +24,9 @@
   },
   "dependencies": {
     "ink": "^7.0.1",
-    "mu-agents": "0.11.0",
-    "mu-core": "0.11.0",
-    "mu-openai-provider": "0.11.0",
+    "mu-agents": "0.13.0",
+    "mu-core": "0.13.0",
+    "mu-openai-provider": "0.13.0",
     "react": "^19.2.5"
   }
 }

package/src/runtime/startupUpdateCheck.ts

@@ -7,7 +7,7 @@
  *  - Must never block startup. Caller fire-and-forgets the returned promise.
  *  - Must never crash the host on network / DNS errors. Every probe is wrapped.
  *  - Must not hammer npm on every boot. Results are cached in
- *    `<cacheDir>/update-check.json` for `CACHE_TTL_MS` (24h).
+ *    `<cacheDir>/update-check.json` for `CACHE_TTL_MS` (1h).
  *  - Disable with `MU_NO_UPDATE_CHECK=1` (kill switch for offline / CI / tests).
  *
  * Toasts are routed through the existing `InkUIService.notify` queue, which
@@ -16,7 +16,7 @@
  * the alert still surfaces.
  */
 
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { getCacheDir, getDataDir } from '../config/index';
 import type { InkUIService } from '../tui/plugins/InkUIService';
@@ -28,7 +28,7 @@ import {
   probeSelfAsync,
 } from './updateCheck';
 
-const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 h
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 h
 const CACHE_FILENAME = 'update-check.json';
 
 interface CacheShape {
@@ -61,6 +61,19 @@ function writeCache(cache: CacheShape): void {
   }
 }
 
+/**
+ * Discard the cached probe result. Called after a `/update` so the next
+ * boot re-probes against fresh registry data instead of replaying the
+ * pre-update state from cache.
+ */
+export function invalidateUpdateCheckCache(): void {
+  try {
+    rmSync(cachePath(), { force: true });
+  } catch {
+    // best-effort
+  }
+}
+
 function isDisabled(): boolean {
   const v = process.env.MU_NO_UPDATE_CHECK;
   return v === '1' || v === 'true' || v === 'yes';

package/src/tui/components/messages/WebFetchOutput.tsx

@@ -0,0 +1,30 @@
+import { Box } from 'ink';
+import { ToolHeader } from './ToolHeader';
+
+interface WebFetchOutputProps {
+  args: string;
+  error: boolean;
+}
+
+function parseUrl(args: string): string {
+  try {
+    const parsed = JSON.parse(args);
+    return typeof parsed.url === 'string' ? parsed.url : '(unknown)';
+  } catch {
+    return '(unknown)';
+  }
+}
+
+/**
+ * Compact renderer for the `webfetch` tool — shows a one-line header with the
+ * fetched URL and elides the (often huge) response body so it doesn't fill
+ * the transcript. Mirrors `ReadOutput`'s minimal layout.
+ */
+export function WebFetchOutput({ args, error }: WebFetchOutputProps) {
+  const url = parseUrl(args);
+  return (
+    <Box flexDirection="column" flexShrink={0} marginBottom={0}>
+      <ToolHeader name="webfetch" subtitle={url} error={error} />
+    </Box>
+  );
+}

package/src/tui/components/messages/toolCallBlock.tsx

@@ -5,6 +5,7 @@ import { useTheme } from '../../context/ThemeContext';
 import { useSpinner } from '../../hooks/useUI';
 import { EditOutput } from './EditOutput';
 import { ReadOutput } from './ReadOutput';
+import { WebFetchOutput } from './WebFetchOutput';
 import { WriteOutput } from './WriteOutput';
 
 /**
@@ -76,6 +77,8 @@ function renderToolOutput(
       return <WriteOutput args={args} content={content} error={error} />;
     case 'diff':
       return <EditOutput args={args} content={content} error={error} hint={hint} />;
+    case 'webfetch':
+      return <WebFetchOutput args={args} error={error} />;
     default:
       return <GenericToolOutput name={name} args={args} content={content} error={error} hint={hint} />;
   }

package/src/tui/input/commands.test.ts

@@ -23,17 +23,37 @@ describe('BUILTIN_COMMANDS', () => {
     const onTogglePicker = mock(() => undefined);
     const onToggleSessionPicker = mock(() => undefined);
     const onNew = mock(() => undefined);
+    const onCompact = mock(() => undefined);
     const onShowContext = mock(() => undefined);
-    const actions: InputActions = { onTogglePicker, onToggleSessionPicker, onNew, onShowContext };
+    const onUpdate = mock(() => undefined);
+    const actions: InputActions = {
+      onTogglePicker,
+      onToggleSessionPicker,
+      onNew,
+      onCompact,
+      onShowContext,
+      onUpdate,
+    };
 
     for (const cmd of BUILTIN_COMMANDS) {
-      cmd.invoke?.(actions);
+      cmd.invoke?.(actions, '');
     }
 
     expect(onTogglePicker).toHaveBeenCalledTimes(1);
     expect(onToggleSessionPicker).toHaveBeenCalledTimes(1);
     expect(onNew).toHaveBeenCalledTimes(1);
+    expect(onCompact).toHaveBeenCalledTimes(1);
     expect(onShowContext).toHaveBeenCalledTimes(1);
+    expect(onUpdate).toHaveBeenCalledTimes(1);
+  });
+
+  it('/update forwards args to onUpdate', () => {
+    const onUpdate = mock(() => undefined);
+    const actions: InputActions = { onUpdate };
+    const cmd = BUILTIN_COMMANDS.find((c) => c.name === '/update');
+    expect(cmd).toBeDefined();
+    cmd?.invoke?.(actions, 'plugins');
+    expect(onUpdate).toHaveBeenCalledWith('plugins');
   });
 });
 

package/src/tui/input/commands.ts

@@ -3,7 +3,8 @@ import type { InputActions } from './useInputHandler';
 
 /**
  * A slash command can either:
- *  - run via `invoke(actions)` — for builtins that just toggle UI state, or
+ *  - run via `invoke(actions, args)` — for builtins that just toggle UI state
+ *    (most ignore `args`), or
  *  - run via `execute(args)` — for plugin-supplied commands that produce
  *    side-effects through the agent runtime.
  *
@@ -12,7 +13,7 @@ import type { InputActions } from './useInputHandler';
 export interface SlashCommand {
   name: string;
   description: string;
-  invoke?: (actions: InputActions) => void;
+  invoke?: (actions: InputActions, args: string) => void;
   execute?: (args: string) => Promise<string | undefined>;
 }
 
@@ -30,6 +31,11 @@ export const BUILTIN_COMMANDS: SlashCommand[] = [
     description: 'Show the LLM context (system prompt, messages, tools) as plain text',
     invoke: (a) => a.onShowContext?.(),
   },
+  {
+    name: '/update',
+    description: 'Update mu and installed npm plugins. Args: "plugins" | "self" (default: all)',
+    invoke: (a, args) => a.onUpdate?.(args),
+  },
 ];
 
 export function fromPluginCommand(command: PluginSlashCommand, context: CommandContext): SlashCommand {

package/src/tui/input/useCommandExecutor.ts

@@ -23,7 +23,7 @@ export function useCommandExecutor(options: CommandExecutorOptions) {
         void command.execute(args);
         return;
       }
-      command.invoke?.(actions);
+      command.invoke?.(actions, args);
     },
     [actions],
   );

package/src/tui/input/useInputBox.ts

@@ -1,6 +1,8 @@
 import type { InputInfoSegment } from 'mu-core';
 import { useCallback, useMemo, useRef } from 'react';
 import { useChatContext } from '../chat/ChatContext';
+import type { InkUIService } from '../plugins/InkUIService';
+import { runUpdateInTui, type UpdateScope } from '../update/runUpdateInTui';
 import { dumpContext } from './dumpContext';
 import type { InputBoxViewProps } from './InputBoxView';
 import { useCommandExecutor } from './useCommandExecutor';
@@ -8,6 +10,14 @@ import { type InputActions, type MentionMode, useInputHandler } from './useInput
 import { type MentionPickerState, useMentionPicker } from './useMentionPicker';
 import { usePluginShortcuts } from './usePluginShortcuts';
 
+function parseUpdateScope(args: string): UpdateScope | null {
+  const trimmed = args.trim().toLowerCase();
+  if (trimmed === '' || trimmed === 'all') return 'all';
+  if (trimmed === 'plugins') return 'plugins';
+  if (trimmed === 'self' || trimmed === 'mu') return 'self';
+  return null;
+}
+
 export interface InputBoxProps {
   onSubmit: (text: string) => void;
   onScrollUp?: () => void;
@@ -96,12 +106,13 @@ interface ActionDeps {
   models: ReturnType<typeof useChatContext>['models'];
   toggles: ReturnType<typeof useChatContext>['toggles'];
   onShowContext: () => Promise<void>;
+  onUpdate: (args: string) => void;
   onScrollUp?: () => void;
   onScrollDown?: () => void;
 }
 
 function useInputActions(deps: ActionDeps): InputActions {
-  const { abort, attachment, session, models, toggles, onShowContext, onScrollUp, onScrollDown } = deps;
+  const { abort, attachment, session, models, toggles, onShowContext, onUpdate, onScrollUp, onScrollDown } = deps;
   return useMemo<InputActions>(
     () => ({
       onCtrlC: abort.onCtrlC,
@@ -115,6 +126,7 @@ function useInputActions(deps: ActionDeps): InputActions {
       onTogglePicker: toggles.onTogglePicker,
       onToggleSessionPicker: toggles.onToggleSessionPicker,
       onShowContext,
+      onUpdate,
       onScrollUp,
       onScrollDown,
       modelCount: models.models.length,
@@ -130,12 +142,29 @@ function useInputActions(deps: ActionDeps): InputActions {
       toggles.onTogglePicker,
       toggles.onToggleSessionPicker,
       onShowContext,
+      onUpdate,
       onScrollUp,
       onScrollDown,
     ],
   );
 }
 
+function useOnUpdate(uiService: InkUIService | undefined) {
+  return useCallback(
+    (args: string) => {
+      if (!uiService) return;
+      const scope = parseUpdateScope(args);
+      if (!scope) {
+        uiService.notify('Usage: /update [plugins|self|all]', 'warning');
+        return;
+      }
+      uiService.notify(scope === 'all' ? 'Starting update…' : `Starting ${scope} update…`, 'info');
+      void runUpdateInTui(scope, uiService);
+    },
+    [uiService],
+  );
+}
+
 const EMPTY_SEGMENTS: InputInfoSegment[] = [];
 
 export function useInputBox({
@@ -164,6 +193,8 @@ export function useInputBox({
     }
   }, [config, session.messages, registry, uiService]);
 
+  const onUpdate = useOnUpdate(uiService);
+
   const actions = useInputActions({
     abort,
     attachment,
@@ -171,6 +202,7 @@ export function useInputBox({
     models,
     toggles,
     onShowContext,
+    onUpdate,
     onScrollUp,
     onScrollDown,
   });

package/src/tui/input/useInputHandler.ts

@@ -36,6 +36,7 @@ export interface InputActions {
   onEsc?: () => void;
   onScrollUp?: () => void;
   onScrollDown?: () => void;
+  onUpdate?: (args: string) => void;
   modelCount?: number;
 }
 

package/src/tui/update/runUpdateInTui.ts

@@ -0,0 +1,127 @@
+/**
+ * TUI-friendly update runner — same semantics as `mu update` from the CLI,
+ * but never writes to stdout/stderr (Ink owns the terminal). Progress and
+ * results are surfaced as toasts via `uiService.notify`.
+ *
+ * Mirrors `cli/update.ts` but uses `child_process.execFile` with `stdio:
+ * 'pipe'` so subprocess output is buffered, not streamed to the TUI's tty.
+ */
+
+import { execFile } from 'node:child_process';
+import { realpathSync } from 'node:fs';
+import { promisify } from 'node:util';
+import { ensureDataDir } from '../../cli/install';
+import { invalidateUpdateCheckCache } from '../../runtime/startupUpdateCheck';
+import { listConfiguredNpmPlugins, PACKAGE_NAME } from '../../runtime/updateCheck';
+import type { InkUIService } from '../plugins/InkUIService';
+
+const execFileAsync = promisify(execFile);
+
+export type UpdateScope = 'all' | 'plugins' | 'self';
+
+interface SelfInstallStrategy {
+  manager: 'bun' | 'npm' | 'pnpm' | 'yarn' | 'unknown';
+  command?: [string, string[]];
+}
+
+function detectSelfInstall(): SelfInstallStrategy {
+  let bin = process.argv[1] ?? '';
+  try {
+    bin = realpathSync(bin);
+  } catch {
+    // keep raw argv
+  }
+  const norm = bin.replace(/\\/g, '/');
+  if (norm.includes('/.bun/') || norm.includes('/bun/install/')) {
+    return { manager: 'bun', command: ['bun', ['add', '-g', `${PACKAGE_NAME}@latest`]] };
+  }
+  if (norm.includes('/pnpm/')) {
+    return { manager: 'pnpm', command: ['pnpm', ['add', '-g', `${PACKAGE_NAME}@latest`]] };
+  }
+  if (norm.includes('/.yarn/') || norm.includes('/yarn/global/')) {
+    return { manager: 'yarn', command: ['yarn', ['global', 'add', `${PACKAGE_NAME}@latest`]] };
+  }
+  if (norm.includes('/npm/') || norm.includes('node_modules/.bin/mu')) {
+    return { manager: 'npm', command: ['npm', ['i', '-g', `${PACKAGE_NAME}@latest`]] };
+  }
+  return { manager: 'unknown' };
+}
+
+async function updatePlugin(name: string, dataDir: string): Promise<boolean> {
+  try {
+    await execFileAsync('bun', ['update', '--latest', name], { cwd: dataDir });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function updatePlugins(ui: InkUIService): Promise<{ ok: number; failed: number; total: number }> {
+  const dataDir = ensureDataDir();
+  const names = listConfiguredNpmPlugins();
+  if (names.length === 0) return { ok: 0, failed: 0, total: 0 };
+
+  let ok = 0;
+  let failed = 0;
+  for (const name of names) {
+    ui.notify(`Updating ${name}…`, 'info');
+    if (await updatePlugin(name, dataDir)) ok += 1;
+    else {
+      failed += 1;
+      ui.notify(`Failed to update ${name}`, 'error');
+    }
+  }
+  return { ok, failed, total: names.length };
+}
+
+async function updateSelf(ui: InkUIService): Promise<boolean> {
+  const strategy = detectSelfInstall();
+  if (!strategy.command) {
+    ui.notify(`Cannot auto-detect mu's installer. Re-install manually: bun add -g ${PACKAGE_NAME}@latest`, 'warning');
+    return false;
+  }
+  const [bin, args] = strategy.command;
+  ui.notify(`Updating mu via ${strategy.manager}…`, 'info');
+  try {
+    await execFileAsync(bin, args);
+    ui.notify('mu updated. Restart your session to pick up the new version.', 'success');
+    return true;
+  } catch (err) {
+    const message = err instanceof Error ? err.message.split('\n')[0] : String(err);
+    ui.notify(`Failed to update mu: ${message}`, 'error');
+    return false;
+  }
+}
+
+/**
+ * Entry point used by the `/update` slash command. Fire-and-forget — the
+ * caller voids the returned promise. All progress / errors land in toasts.
+ */
+export async function runUpdateInTui(scope: UpdateScope, ui: InkUIService): Promise<void> {
+  if (scope === 'plugins') {
+    const { ok, failed, total } = await updatePlugins(ui);
+    if (total === 0) ui.notify('No npm plugins configured.', 'info');
+    else if (failed === 0) ui.notify(`Updated ${ok}/${total} plugin${total === 1 ? '' : 's'}.`, 'success');
+    else ui.notify(`Plugins: ${ok} updated, ${failed} failed.`, 'warning');
+    invalidateUpdateCheckCache();
+    return;
+  }
+
+  if (scope === 'self') {
+    await updateSelf(ui);
+    invalidateUpdateCheckCache();
+    return;
+  }
+
+  // 'all'
+  const plugins = await updatePlugins(ui);
+  const selfOk = await updateSelf(ui);
+  if (plugins.total === 0 && selfOk) {
+    // mu-only success already toasted; nothing to add
+  } else if (plugins.failed === 0 && selfOk) {
+    ui.notify('Update complete.', 'success');
+  } else {
+    ui.notify('Update finished with errors — see prior messages.', 'warning');
+  }
+  invalidateUpdateCheckCache();
+}