mu-coding 0.10.0 → 0.11.0

package/package.json

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

package/src/app/startApp.ts

@@ -3,6 +3,7 @@ import { parseArgs, resolveInitialMessages } from '../cli/args';
 import { handleSubcommand } from '../cli/subcommands';
 import { loadConfig } from '../config/index';
 import { createRegistry } from '../runtime/createRegistry';
+import { checkForUpdatesInBackground } from '../runtime/startupUpdateCheck';
 import { InkUIService } from '../tui/plugins/InkUIService';
 import { registerShutdown } from './shutdown';
 
@@ -29,6 +30,11 @@ async function runApp(): Promise<void> {
   });
   registryRef = registry;
 
+  // Fire-and-forget npm registry probe — surfaces a toast via uiService.notify
+  // if mu or an installed npm plugin has a newer version. Cached for 24h to
+  // avoid hammering the registry; disable with MU_NO_UPDATE_CHECK=1.
+  void checkForUpdatesInBackground(uiService);
+
   // The TUI is registered as a `Channel` by `createCodingPlugin`. Starting
   // it mounts Ink with the same options that were captured at activation
   // time (config, initialMessages, registry, messageBus, uiService, shutdown).

package/src/cli/args.ts

@@ -21,6 +21,8 @@ Usage:
   mu --session <path>           Resume a specific session file
   mu install npm:<package>      Install a plugin from npm
   mu uninstall npm:<package>    Remove an installed plugin
+  mu update [plugins|self|all]  Update plugins and/or mu (default: all)
+  mu outdated [plugins|self]    List available updates without applying
   mu -v, --version              Print version and exit
   mu -h, --help                 Show this help
 

package/src/cli/subcommands.ts

@@ -1,4 +1,5 @@
 import { runInstall, runUninstall } from './install';
+import { runOutdated, runUpdate } from './update';
 
 /**
  * Handle CLI subcommands that run before the TUI.
@@ -14,6 +15,14 @@ export async function handleSubcommand(): Promise<boolean> {
     case 'uninstall':
       await runUninstall(process.argv.slice(3));
       return true;
+    case 'update':
+    case 'upgrade':
+      await runUpdate(process.argv.slice(3));
+      return true;
+    case 'outdated':
+    case 'ping':
+      await runOutdated(process.argv.slice(3));
+      return true;
     default:
       return false;
   }

package/src/cli/update.ts

@@ -0,0 +1,205 @@
+/**
+ * `mu update` — bring installed plugins (and optionally mu itself) to the
+ * latest version published on the npm registry.
+ *
+ * Plugins live in `~/.local/share/mu/node_modules/<name>` and are listed in
+ * `config.plugins` as `npm:<name>` specifiers. Updating them is a thin
+ * wrapper around `bun update --latest <name>` against the data dir, which
+ * already owns its own `package.json`.
+ *
+ * mu itself is updated by re-running its global installer. We probe the
+ * binary path to detect which manager owns the install (bun, npm, pnpm) and
+ * fall back to a generic `npm i -g` instructions message on unknown setups.
+ */
+
+import { execFileSync } from 'node:child_process';
+import { realpathSync } from 'node:fs';
+import {
+  listConfiguredNpmPlugins,
+  type NpmRegistryView,
+  PACKAGE_NAME,
+  probePluginSync,
+  probeSelfSync,
+} from '../runtime/updateCheck';
+import { ensureDataDir } from './install';
+
+function printRow(name: string, view: NpmRegistryView | null) {
+  if (!view) {
+    console.log(`  ${name.padEnd(28)} ?       (npm view failed)`);
+    return;
+  }
+  const arrow = view.hasUpdate ? '→' : '=';
+  const tail = view.hasUpdate ? `${view.current} ${arrow} ${view.latest}` : `${view.current} (up to date)`;
+  console.log(`  ${name.padEnd(28)} ${tail}`);
+}
+
+// ─── outdated ────────────────────────────────────────────────────────────────
+
+export async function runOutdated(args: string[]): Promise<void> {
+  const scope = args[0];
+  const wantsPlugins = !scope || scope === 'plugins' || scope === 'all';
+  const wantsSelf = !scope || scope === 'self' || scope === 'mu' || scope === 'all';
+
+  const dataDir = ensureDataDir();
+  let anyUpdate = false;
+
+  if (wantsSelf) {
+    console.log('mu:');
+    const view = probeSelfSync();
+    printRow(PACKAGE_NAME, view);
+    if (view?.hasUpdate) anyUpdate = true;
+  }
+
+  if (wantsPlugins) {
+    const names = listConfiguredNpmPlugins();
+    console.log(`\nplugins (${names.length}):`);
+    if (names.length === 0) {
+      console.log('  (none configured)');
+    } else {
+      for (const name of names) {
+        const view = probePluginSync(name, dataDir);
+        printRow(name, view);
+        if (view?.hasUpdate) anyUpdate = true;
+      }
+    }
+  }
+
+  if (!anyUpdate) {
+    console.log('\nEverything is up to date.');
+  } else {
+    console.log("\nRun 'mu update' to apply.");
+  }
+}
+
+// ─── update plugins ──────────────────────────────────────────────────────────
+
+function updatePlugin(name: string, dataDir: string): boolean {
+  try {
+    execFileSync('bun', ['update', '--latest', name], { cwd: dataDir, stdio: 'inherit' });
+    return true;
+  } catch (err) {
+    console.error(`Failed to update ${name}: ${err instanceof Error ? err.message : err}`);
+    return false;
+  }
+}
+
+export async function runUpdatePlugins(): Promise<{ ok: number; failed: number }> {
+  const dataDir = ensureDataDir();
+  const names = listConfiguredNpmPlugins();
+  if (names.length === 0) {
+    console.log('No npm plugins configured.');
+    return { ok: 0, failed: 0 };
+  }
+  let ok = 0;
+  let failed = 0;
+  for (const name of names) {
+    console.log(`\nUpdating ${name}…`);
+    if (updatePlugin(name, dataDir)) {
+      ok += 1;
+      console.log(`✓ ${name}`);
+    } else {
+      failed += 1;
+    }
+  }
+  return { ok, failed };
+}
+
+// ─── update self ─────────────────────────────────────────────────────────────
+
+interface SelfInstallStrategy {
+  manager: 'bun' | 'npm' | 'pnpm' | 'yarn' | 'unknown';
+  command?: [string, string[]];
+}
+
+/**
+ * Best-effort detection of which package manager installed `mu` globally.
+ * We resolve the absolute binary path of the running process and look for
+ * tell-tale path segments.
+ */
+function detectSelfInstall(): SelfInstallStrategy {
+  let bin = process.argv[1] ?? '';
+  try {
+    bin = realpathSync(bin);
+  } catch {
+    // keep raw argv path
+  }
+  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' };
+}
+
+export async function runUpdateSelf(): Promise<boolean> {
+  const view = probeSelfSync();
+  if (view && !view.hasUpdate) {
+    console.log(`mu is already up to date (${view.current}).`);
+    return true;
+  }
+
+  const strategy = detectSelfInstall();
+  if (!strategy.command) {
+    console.log(
+      [
+        'Could not auto-detect how mu was installed.',
+        'Re-install with one of:',
+        `  bun add -g ${PACKAGE_NAME}@latest`,
+        `  npm i -g ${PACKAGE_NAME}@latest`,
+        `  pnpm add -g ${PACKAGE_NAME}@latest`,
+      ].join('\n'),
+    );
+    return false;
+  }
+
+  const [bin, args] = strategy.command;
+  console.log(`Updating mu via ${strategy.manager}…`);
+  console.log(`$ ${bin} ${args.join(' ')}`);
+  try {
+    execFileSync(bin, args, { stdio: 'inherit' });
+    console.log('✓ mu updated. Restart any running mu sessions.');
+    return true;
+  } catch (err) {
+    console.error(`Failed to update mu: ${err instanceof Error ? err.message : err}`);
+    return false;
+  }
+}
+
+// ─── dispatcher ──────────────────────────────────────────────────────────────
+
+export async function runUpdate(args: string[]): Promise<void> {
+  const scope = args[0];
+
+  if (scope === 'plugins') {
+    const { failed } = await runUpdatePlugins();
+    if (failed > 0) process.exit(1);
+    return;
+  }
+
+  if (scope === 'self' || scope === 'mu') {
+    const ok = await runUpdateSelf();
+    if (!ok) process.exit(1);
+    return;
+  }
+
+  if (scope && scope !== 'all') {
+    console.error('Usage: mu update [plugins|self|all]');
+    process.exit(1);
+  }
+
+  // Default: update everything.
+  console.log('=== Updating plugins ===');
+  const pluginRes = await runUpdatePlugins();
+  console.log('\n=== Updating mu ===');
+  const selfOk = await runUpdateSelf();
+  if (pluginRes.failed > 0 || !selfOk) process.exit(1);
+}

package/src/runtime/startupUpdateCheck.ts

@@ -0,0 +1,150 @@
+/**
+ * Startup update check — fires off `npm view` probes in the background after
+ * the TUI is up, then surfaces a toast through `uiService.notify` when mu or
+ * any installed npm plugin has a newer version on the registry.
+ *
+ * Design constraints:
+ *  - 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).
+ *  - Disable with `MU_NO_UPDATE_CHECK=1` (kill switch for offline / CI / tests).
+ *
+ * Toasts are routed through the existing `InkUIService.notify` queue, which
+ * buffers messages emitted before any toast listener attaches — so even if
+ * the probe finishes before the TUI mounts (rare; see fast `npm view` runs)
+ * the alert still surfaces.
+ */
+
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getCacheDir, getDataDir } from '../config/index';
+import type { InkUIService } from '../tui/plugins/InkUIService';
+import {
+  listConfiguredNpmPlugins,
+  type NpmRegistryView,
+  PACKAGE_NAME,
+  probePluginAsync,
+  probeSelfAsync,
+} from './updateCheck';
+
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 h
+const CACHE_FILENAME = 'update-check.json';
+
+interface CacheShape {
+  ts: number;
+  results: Record<string, NpmRegistryView | null>;
+}
+
+function cachePath(): string {
+  return join(getCacheDir(), CACHE_FILENAME);
+}
+
+function readCache(): CacheShape | null {
+  try {
+    const raw = readFileSync(cachePath(), 'utf-8');
+    const parsed = JSON.parse(raw) as CacheShape;
+    if (typeof parsed?.ts !== 'number' || typeof parsed?.results !== 'object') return null;
+    if (Date.now() - parsed.ts > CACHE_TTL_MS) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(cache: CacheShape): void {
+  try {
+    mkdirSync(getCacheDir(), { recursive: true });
+    writeFileSync(cachePath(), JSON.stringify(cache), 'utf-8');
+  } catch {
+    // Cache writes are best-effort; ignore disk errors.
+  }
+}
+
+function isDisabled(): boolean {
+  const v = process.env.MU_NO_UPDATE_CHECK;
+  return v === '1' || v === 'true' || v === 'yes';
+}
+
+interface ProbeOutcome {
+  self: NpmRegistryView | null;
+  plugins: Map<string, NpmRegistryView | null>;
+}
+
+async function runProbes(): Promise<ProbeOutcome> {
+  const dataDir = getDataDir();
+  const pluginNames = listConfiguredNpmPlugins();
+
+  const [self, ...plugins] = await Promise.all([
+    probeSelfAsync().catch(() => null),
+    ...pluginNames.map((name) => probePluginAsync(name, dataDir).catch(() => null)),
+  ]);
+
+  const pluginMap = new Map<string, NpmRegistryView | null>();
+  pluginNames.forEach((name, i) => {
+    pluginMap.set(name, plugins[i] ?? null);
+  });
+
+  return { self, plugins: pluginMap };
+}
+
+function outcomeFromCache(cache: CacheShape, pluginNames: string[]): ProbeOutcome {
+  const self = cache.results[PACKAGE_NAME] ?? null;
+  const plugins = new Map<string, NpmRegistryView | null>();
+  for (const name of pluginNames) {
+    plugins.set(name, cache.results[name] ?? null);
+  }
+  return { self, plugins };
+}
+
+function outcomeToCache(outcome: ProbeOutcome): CacheShape {
+  const results: Record<string, NpmRegistryView | null> = {};
+  results[PACKAGE_NAME] = outcome.self;
+  for (const [name, view] of outcome.plugins) {
+    results[name] = view;
+  }
+  return { ts: Date.now(), results };
+}
+
+function notifyOutcome(outcome: ProbeOutcome, ui: InkUIService): void {
+  const stale: string[] = [];
+  if (outcome.self?.hasUpdate) {
+    stale.push(`mu ${outcome.self.current} → ${outcome.self.latest}`);
+  }
+  for (const [name, view] of outcome.plugins) {
+    if (view?.hasUpdate) {
+      stale.push(`${name} ${view.current} → ${view.latest}`);
+    }
+  }
+  if (stale.length === 0) return;
+
+  const header = stale.length === 1 ? 'Update available' : `${stale.length} updates available`;
+  const body = stale.join(', ');
+  ui.notify(`${header}: ${body}. Run \`mu update\` to apply.`, 'info');
+}
+
+/**
+ * Background entry point. Resolves once the probe (or cache lookup) has
+ * completed and any toast has been emitted. Callers should fire-and-forget.
+ */
+export async function checkForUpdatesInBackground(ui: InkUIService): Promise<void> {
+  if (isDisabled()) return;
+
+  const pluginNames = listConfiguredNpmPlugins();
+
+  const cached = readCache();
+  if (cached) {
+    notifyOutcome(outcomeFromCache(cached, pluginNames), ui);
+    return;
+  }
+
+  let outcome: ProbeOutcome;
+  try {
+    outcome = await runProbes();
+  } catch {
+    return;
+  }
+
+  writeCache(outcomeToCache(outcome));
+  notifyOutcome(outcome, ui);
+}

package/src/runtime/updateCheck.ts

@@ -0,0 +1,136 @@
+/**
+ * Shared "is there a newer version?" probes used by both the `mu update` /
+ * `mu outdated` CLI subcommands (synchronous, blocking) and the in-TUI
+ * startup alert (asynchronous, cached). Pure & side-effect free except for
+ * the actual `npm view` exec — no toast / IO concerns live here.
+ */
+
+import { execFile, execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+import { loadConfig, parseBareNpmSpec } from '../config/index';
+
+const execFileAsync = promisify(execFile);
+
+export const PACKAGE_NAME = 'mu-coding';
+
+export interface NpmRegistryView {
+  current: string;
+  latest: string;
+  hasUpdate: boolean;
+}
+
+export function npmViewLatestSync(name: string): string | undefined {
+  try {
+    const out = execFileSync('npm', ['view', name, 'version'], {
+      stdio: ['ignore', 'pipe', 'ignore'],
+      encoding: 'utf-8',
+    });
+    return out.trim() || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function npmViewLatest(name: string, timeoutMs = 8000): Promise<string | undefined> {
+  try {
+    const { stdout } = await execFileAsync('npm', ['view', name, 'version'], {
+      timeout: timeoutMs,
+      encoding: 'utf-8',
+    });
+    return stdout.trim() || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function readInstalledVersion(name: string, cwd: string): string | undefined {
+  try {
+    const path = join(cwd, 'node_modules', name, 'package.json');
+    const pkg = JSON.parse(readFileSync(path, 'utf-8'));
+    return typeof pkg.version === 'string' ? pkg.version : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function readSelfVersion(): string | undefined {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(here, '..', '..', 'package.json'),
+    join(here, '..', 'package.json'),
+    join(here, '..', '..', '..', 'package.json'),
+  ];
+  for (const path of candidates) {
+    try {
+      const pkg = JSON.parse(readFileSync(path, 'utf-8'));
+      if (pkg?.name === PACKAGE_NAME && typeof pkg.version === 'string') return pkg.version;
+    } catch {
+      // try next
+    }
+  }
+  return undefined;
+}
+
+export function listConfiguredNpmPlugins(): string[] {
+  const config = loadConfig();
+  const out: string[] = [];
+  for (const entry of config.plugins ?? []) {
+    const spec = typeof entry === 'string' ? entry : entry.name;
+    if (!spec.startsWith('npm:')) continue;
+    const { name } = parseBareNpmSpec(spec.slice(4));
+    out.push(name);
+  }
+  return out;
+}
+
+/**
+ * Best-effort "is `latest` newer than `current`?". Splits on `.+-` and
+ * compares numeric segments left-to-right. Returns `true` when `current` is
+ * unknown so a missing local install reads as "needs install / update".
+ */
+export function isVersionNewer(current: string | undefined, latest: string): boolean {
+  if (!current) return true;
+  if (current === latest) return false;
+  const cur = current.split(/[.+-]/).map((p) => Number.parseInt(p, 10));
+  const lat = latest.split(/[.+-]/).map((p) => Number.parseInt(p, 10));
+  const len = Math.max(cur.length, lat.length);
+  for (let i = 0; i < len; i++) {
+    const a = cur[i];
+    const b = lat[i];
+    if (Number.isNaN(a ?? Number.NaN) || Number.isNaN(b ?? Number.NaN)) return current !== latest;
+    if ((a ?? 0) < (b ?? 0)) return true;
+    if ((a ?? 0) > (b ?? 0)) return false;
+  }
+  return false;
+}
+
+export function probePluginSync(name: string, dataDir: string): NpmRegistryView | null {
+  const latest = npmViewLatestSync(name);
+  if (!latest) return null;
+  const current = readInstalledVersion(name, dataDir);
+  return { current: current ?? '(not installed)', latest, hasUpdate: isVersionNewer(current, latest) };
+}
+
+export function probeSelfSync(): NpmRegistryView | null {
+  const latest = npmViewLatestSync(PACKAGE_NAME);
+  if (!latest) return null;
+  const current = readSelfVersion();
+  return { current: current ?? '(unknown)', latest, hasUpdate: isVersionNewer(current, latest) };
+}
+
+export async function probePluginAsync(name: string, dataDir: string): Promise<NpmRegistryView | null> {
+  const latest = await npmViewLatest(name);
+  if (!latest) return null;
+  const current = readInstalledVersion(name, dataDir);
+  return { current: current ?? '(not installed)', latest, hasUpdate: isVersionNewer(current, latest) };
+}
+
+export async function probeSelfAsync(): Promise<NpmRegistryView | null> {
+  const latest = await npmViewLatest(PACKAGE_NAME);
+  if (!latest) return null;
+  const current = readSelfVersion();
+  return { current: current ?? '(unknown)', latest, hasUpdate: isVersionNewer(current, latest) };
+}