march-cli 0.1.8 → 0.1.10

package/src/config/loader.mjs

@@ -46,13 +46,20 @@ function mergeLayers(layers) {
     serviceTier: null,
     providers: {},
     webSearch: { provider: null, providers: {} },
+    hostedTools: {
+      openai: { webSearch: "auto" },
+      openaiCodex: { webSearch: "auto" },
+      azureOpenai: { webSearch: "auto" },
+      anthropic: { webSearch: "auto" },
+      google: { webSearch: "auto" },
+      xai: { webSearch: "auto", xSearch: "auto" },
+    },
     network: { proxy: "system", ca: "system" },
     maxTurns: null,
     trimBatch: null,
     memoryRoot: null,
     notifications: { turnEnd: true, desktop: true, bell: false, command: null, minDurationMs: 0, sound: true },
   };
-
   for (const layer of layers) {
     if (!layer) continue;
     if (layer.model != null) result.model = layer.model;
@@ -64,6 +71,9 @@ function mergeLayers(layers) {
     if (layer.webSearch && typeof layer.webSearch === "object" && !Array.isArray(layer.webSearch)) {
       result.webSearch = mergeWebSearch(result.webSearch, layer.webSearch);
     }
+    if (layer.hostedTools && typeof layer.hostedTools === "object" && !Array.isArray(layer.hostedTools)) {
+      result.hostedTools = mergeHostedTools(result.hostedTools, layer.hostedTools);
+    }
     if (layer.notifications && typeof layer.notifications === "object" && !Array.isArray(layer.notifications)) {
       result.notifications = {
         ...result.notifications,
@@ -99,6 +109,23 @@ function mergeWebSearch(current, next) {
   return merged;
 }
 
+function mergeHostedTools(current, next) {
+  const merged = {
+    openai: { ...(current.openai ?? {}) },
+    openaiCodex: { ...(current.openaiCodex ?? {}) },
+    azureOpenai: { ...(current.azureOpenai ?? {}) },
+    anthropic: { ...(current.anthropic ?? {}) },
+    google: { ...(current.google ?? {}) },
+    xai: { ...(current.xai ?? {}) },
+  };
+  for (const provider of ["openai", "openaiCodex", "azureOpenai", "anthropic", "google", "xai"]) {
+    if (next[provider] && typeof next[provider] === "object" && !Array.isArray(next[provider])) {
+      merged[provider] = { ...merged[provider], ...next[provider] };
+    }
+  }
+  return merged;
+}
+
 function mergeProviders(current, next) {
   const merged = { ...current };
   for (const [id, profile] of Object.entries(next)) {

package/src/debug/logger.mjs

@@ -0,0 +1,141 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const LEVELS = Object.freeze({ debug: 10, info: 20, warn: 30, error: 40, silent: 99 });
+const REDACTED = "[redacted]";
+const MAX_STRING_LENGTH = 2000;
+const MAX_ARRAY_LENGTH = 50;
+const MAX_OBJECT_KEYS = 80;
+const SENSITIVE_KEY = /(api[-_]?key|authorization|auth|token|secret|password|cookie|credential|b64|base64|image)/i;
+
+export function createLogger({
+  enabled = process.env.MARCH_LOG !== "0",
+  level = process.env.MARCH_LOG_LEVEL ?? "info",
+  logDir = defaultLogDir(),
+  now = () => new Date(),
+  pid = process.pid,
+} = {}) {
+  const threshold = normalizeLevel(level);
+  const path = join(logDir, `${dateStamp(now())}-march-${pid}.jsonl`);
+  const base = { enabled: Boolean(enabled), level: levelName(threshold), path };
+
+  function write(levelNameValue, event, fields = {}) {
+    if (!base.enabled || normalizeLevel(levelNameValue) < threshold) return;
+    const entry = {
+      ts: now().toISOString(),
+      level: levelNameValue,
+      event,
+      pid,
+      ...sanitize(fields),
+    };
+    try {
+      mkdirSync(logDir, { recursive: true });
+      appendFileSync(path, `${JSON.stringify(entry)}\n`, "utf8");
+    } catch {
+      // Logging must never change CLI behavior.
+    }
+  }
+
+  const logger = {
+    ...base,
+    event: (event, fields) => write("info", event, fields),
+    debug: (event, fields) => write("debug", event, fields),
+    warn: (event, fields) => write("warn", event, fields),
+    error: (event, fields) => write("error", event, fields),
+    child(extraFields = {}) {
+      return createChildLogger(logger, sanitize(extraFields));
+    },
+  };
+  return logger;
+}
+
+export function createHeartbeat({ logger, event = "heartbeat", intervalMs = 10_000, getFields = () => ({}) } = {}) {
+  if (!logger?.enabled || intervalMs <= 0) return { stop() {} };
+  const timer = setInterval(() => logger.event(event, getFields()), intervalMs);
+  timer.unref?.();
+  return {
+    stop() { clearInterval(timer); },
+  };
+}
+
+export function installProcessLogHandlers(logger) {
+  if (!logger?.enabled) return;
+  process.once("uncaughtException", (err) => {
+    logger.error("process.uncaughtException", { error: formatError(err) });
+  });
+  process.once("unhandledRejection", (reason) => {
+    logger.error("process.unhandledRejection", { error: formatError(reason) });
+  });
+}
+
+export function formatError(err) {
+  if (err instanceof Error) {
+    return {
+      name: err.name,
+      message: err.message,
+      stack: err.stack,
+    };
+  }
+  return { message: String(err) };
+}
+
+export function sanitize(value, seen = new WeakSet(), key = "") {
+  if (SENSITIVE_KEY.test(key)) return REDACTED;
+  if (value == null || typeof value === "number" || typeof value === "boolean") return value;
+  if (typeof value === "string") return truncateString(value);
+  if (typeof value === "bigint") return String(value);
+  if (typeof value === "function" || typeof value === "symbol") return `[${typeof value}]`;
+  if (value instanceof Error) return sanitize(formatError(value), seen);
+  if (typeof value !== "object") return String(value);
+  if (seen.has(value)) return "[circular]";
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const items = value.slice(0, MAX_ARRAY_LENGTH).map((item) => sanitize(item, seen));
+    if (value.length > MAX_ARRAY_LENGTH) items.push(`[${value.length - MAX_ARRAY_LENGTH} more items]`);
+    return items;
+  }
+  const entries = Object.entries(value).slice(0, MAX_OBJECT_KEYS);
+  const out = {};
+  for (const [entryKey, entryValue] of entries) out[entryKey] = sanitize(entryValue, seen, entryKey);
+  const omitted = Object.keys(value).length - entries.length;
+  if (omitted > 0) out.__omittedKeys = omitted;
+  return out;
+}
+
+function createChildLogger(parent, extraFields) {
+  function withFields(fields) {
+    return { ...extraFields, ...(fields ?? {}) };
+  }
+  return {
+    enabled: parent.enabled,
+    level: parent.level,
+    path: parent.path,
+    event: (event, fields) => parent.event(event, withFields(fields)),
+    debug: (event, fields) => parent.debug(event, withFields(fields)),
+    warn: (event, fields) => parent.warn(event, withFields(fields)),
+    error: (event, fields) => parent.error(event, withFields(fields)),
+    child: (fields = {}) => createChildLogger(parent, withFields(sanitize(fields))),
+  };
+}
+
+function defaultLogDir() {
+  return join(homedir(), ".march", "logs");
+}
+
+function dateStamp(now) {
+  return now.toISOString().slice(0, 10);
+}
+
+function truncateString(value) {
+  if (value.length <= MAX_STRING_LENGTH) return value;
+  return `${value.slice(0, MAX_STRING_LENGTH)}...[truncated ${value.length - MAX_STRING_LENGTH} chars]`;
+}
+
+function normalizeLevel(level) {
+  return LEVELS[String(level).toLowerCase()] ?? LEVELS.info;
+}
+
+function levelName(value) {
+  return Object.entries(LEVELS).find(([, level]) => level === value)?.[0] ?? "info";
+}

package/src/lsp/client.mjs

@@ -1,5 +1,5 @@
-import { spawn } from "node:child_process";
 import { pathToFileURL } from "node:url";
+import { spawnCommand } from "../platform/spawn-command.mjs";
 import { extname } from "node:path";
 import { readFileSync } from "node:fs";
 
@@ -36,7 +36,7 @@ export class LspClient {
   }
 
   async start() {
-    this.process = spawn(this.command, this.args, {
+    this.process = spawnCommand(this.command, this.args, {
       cwd: this.cwd,
       env: process.env,
       stdio: ["pipe", "pipe", "pipe"],

package/src/lsp/diagnostic-store.mjs

@@ -1,4 +1,5 @@
 import { fileURLToPath } from "node:url";
+import { lspPathKey } from "./path-match.mjs";
 
 export class LspDiagnosticStore {
   constructor() {
@@ -13,7 +14,7 @@ export class LspDiagnosticStore {
       serverId,
       path,
     }));
-    this.byPath.set(path, {
+    this.byPath.set(lspPathKey(path), {
       path,
       updatedAt: Date.now(),
       diagnostics: normalized,
@@ -22,10 +23,12 @@ export class LspDiagnosticStore {
 
   snapshot() {
     const diagnostics = [];
+    const files = [];
     for (const entry of this.byPath.values()) {
       diagnostics.push(...entry.diagnostics);
+      files.push({ path: entry.path, updatedAt: entry.updatedAt, diagnostics: entry.diagnostics.length });
     }
-    return diagnostics;
+    return { diagnostics, files };
   }
 }
 

package/src/{context/diagnostics.mjs → lsp/diagnostics-format.mjs}

@@ -1,6 +1,8 @@
+import { sameLspPath } from "./path-match.mjs";
+
 const MAX_DIAGNOSTICS = 20;
 
-export function buildDiagnosticsLayer({ snapshot } = {}) {
+export function formatLspDiagnostics({ snapshot } = {}) {
   const diagnostics = snapshot?.diagnostics ?? [];
   if (diagnostics.length === 0) return "[diagnostics]";
 
@@ -17,12 +19,12 @@ export function buildDiagnosticsLayer({ snapshot } = {}) {
   return lines.join("\n");
 }
 
-export function buildDiagnosticsForPath({ snapshot, path } = {}) {
+export function formatLspDiagnosticsForPath({ snapshot, path } = {}) {
   const targetPath = String(path ?? "");
   if (!targetPath) return "";
-  const diagnostics = (snapshot?.diagnostics ?? []).filter((diagnostic) => diagnostic.path === targetPath);
+  const diagnostics = (snapshot?.diagnostics ?? []).filter((diagnostic) => sameLspPath(diagnostic.path, targetPath));
   if (diagnostics.length === 0) return "";
-  return buildDiagnosticsLayer({
+  return formatLspDiagnostics({
     snapshot: {
       ...snapshot,
       diagnostics,

package/src/lsp/managed-node-server.mjs

@@ -0,0 +1,94 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { spawnCommand } from "../platform/spawn-command.mjs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const DEFAULT_CACHE_ROOT = join(homedir(), ".march", "lsp", "node");
+
+const MANAGED_PACKAGES = {
+  "typescript-language-server": ["typescript-language-server", "typescript"],
+  "vue-language-server": ["@vue/language-server", "typescript"],
+};
+
+const installs = new Map();
+
+export function getManagedNodeLspRoot() {
+  return process.env.MARCH_LSP_NODE_ROOT || DEFAULT_CACHE_ROOT;
+}
+
+export async function ensureManagedNodeCommand(name) {
+  if (!MANAGED_PACKAGES[name]) return null;
+  const root = getManagedNodeLspRoot();
+  const existing = findManagedBin(name, root);
+  if (existing) return { command: existing, root, installed: false };
+
+  await ensureManagedPackages(name, root);
+  const command = findManagedBin(name, root);
+  if (!command) throw new Error(`managed install did not provide ${name}`);
+  return { command, root, installed: true };
+}
+
+export async function ensureManagedTypeScript() {
+  const root = getManagedNodeLspRoot();
+  if (findManagedTypeScriptServer()) return { root, installed: false };
+  await installPackages(root, ["typescript"]);
+  if (!findManagedTypeScriptServer()) throw new Error("managed install did not provide typescript");
+  return { root, installed: true };
+}
+
+export function findManagedTypeScriptServer() {
+  const root = getManagedNodeLspRoot();
+  const tsserver = join(root, "node_modules", "typescript", "lib", "tsserver.js");
+  return existsSync(tsserver) ? tsserver : null;
+}
+
+export function findManagedTypeScriptSdk() {
+  const root = getManagedNodeLspRoot();
+  const lib = join(root, "node_modules", "typescript", "lib");
+  return existsSync(join(lib, "tsserverlibrary.js")) || existsSync(join(lib, "tsserver.js")) ? lib : null;
+}
+
+async function ensureManagedPackages(name, root) {
+  const key = `${root}:${name}`;
+  if (!installs.has(key)) {
+    installs.set(key, installPackages(root, MANAGED_PACKAGES[name]).finally(() => installs.delete(key)));
+  }
+  return await installs.get(key);
+}
+
+async function installPackages(root, packages) {
+  mkdirSync(root, { recursive: true });
+  const packageJson = join(root, "package.json");
+  if (!existsSync(packageJson)) writeFileSync(packageJson, JSON.stringify({ private: true, name: "march-managed-lsp" }, null, 2));
+  const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+  await run(npm, ["install", "--no-audit", "--no-fund", "--save-exact", ...packages], { cwd: root });
+}
+
+function findManagedBin(name, root) {
+  for (const bin of platformCommandNames(name)) {
+    const candidate = join(root, "node_modules", ".bin", bin);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+function platformCommandNames(name) {
+  if (process.platform !== "win32") return [name];
+  return [`${name}.cmd`, `${name}.exe`, name];
+}
+
+function run(command, args, { cwd }) {
+  return new Promise((resolve, reject) => {
+    const child = spawnCommand(command, args, { cwd, stdio: ["ignore", "ignore", "pipe"], windowsHide: true });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+      if (stderr.length > 4000) stderr = stderr.slice(-4000);
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${command} ${args.join(" ")} failed with exit ${code}${stderr ? `: ${stderr.trim()}` : ""}`));
+    });
+  });
+}

package/src/lsp/path-match.mjs

@@ -0,0 +1,10 @@
+import { normalize } from "node:path";
+
+export function sameLspPath(left, right) {
+  return lspPathKey(left) === lspPathKey(right);
+}
+
+export function lspPathKey(path) {
+  const normalized = normalize(String(path ?? ""));
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}

package/src/lsp/servers.mjs

@@ -1,6 +1,8 @@
 import { existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { createRequire } from "node:module";
+import { ensureManagedNodeCommand, ensureManagedTypeScript, findManagedTypeScriptSdk, findManagedTypeScriptServer } from "./managed-node-server.mjs";
+import { resolveTypeScriptProjectRoot } from "./typescript-project-resolver.mjs";
 
 const NODE_ROOT_MARKERS = ["package-lock.json", "bun.lockb", "bun.lock", "pnpm-lock.yaml", "yarn.lock", "package.json"];
 
@@ -10,20 +12,29 @@ const LSP_SERVERS = [
     extensions: [".vue"],
     rootMarkers: NODE_ROOT_MARKERS,
     command: ["vue-language-server"],
+    managedCommand: "vue-language-server",
     args: ["--stdio"],
-    initialization: () => ({}),
+    initialization: ({ root, workspaceRoot }) => {
+      const tsdk = resolveTypeScriptSdk({ root, workspaceRoot });
+      return tsdk ? { typescript: { tsdk } } : null;
+    },
+    managedTypeScript: true,
+    missingInitialization: "missing project typescript SDK",
   },
   {
     id: "typescript",
     extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
     rootMarkers: NODE_ROOT_MARKERS,
+    projectRoot: resolveTypeScriptProjectRoot,
     command: ["typescript-language-server"],
+    managedCommand: "typescript-language-server",
     args: ["--stdio"],
     initialization: ({ root, workspaceRoot }) => {
-      const tsserver = resolveModule("typescript/lib/tsserver.js", workspaceRoot) ?? resolveModule("typescript/lib/tsserver.js", root);
-      if (!tsserver) return null;
-      return { tsserver: { path: tsserver } };
+      const tsserver = resolveTypeScriptServer({ root, workspaceRoot });
+      return tsserver ? { tsserver: { path: tsserver } } : null;
     },
+    managedTypeScript: true,
+    missingInitialization: "missing project typescript/tsserver.js",
   },
   {
     id: "python",
@@ -68,10 +79,10 @@ const LSP_SERVERS = [
     command: ["astro-ls", "@astrojs/language-server"],
     args: ["--stdio"],
     initialization: ({ root, workspaceRoot }) => {
-      const tsserver = resolveModule("typescript/lib/tsserver.js", workspaceRoot) ?? resolveModule("typescript/lib/tsserver.js", root);
-      if (!tsserver) return null;
-      return { typescript: { tsdk: dirname(tsserver) } };
+      const tsdk = resolveTypeScriptSdk({ root, workspaceRoot });
+      return tsdk ? { typescript: { tsdk } } : null;
     },
+    missingInitialization: "missing project typescript SDK",
   },
   {
     id: "yaml",
@@ -125,24 +136,31 @@ const LSP_SERVERS = [
   },
 ];
 
-export function resolveLspServer({ filePath, workspaceRoot }) {
+export async function resolveLspServer({ filePath, workspaceRoot, onEvent = null } = {}) {
+  const result = await resolveLspServerStatus({ filePath, workspaceRoot, onEvent });
+  return result.status === "available" ? result.server : null;
+}
+
+export async function resolveLspServerStatus({ filePath, workspaceRoot, onEvent = null } = {}) {
   const ext = extensionOf(filePath);
   const def = LSP_SERVERS.find((server) => server.extensions.includes(ext));
-  if (!def) return null;
+  if (!def) return { status: "unsupported", extension: ext };
+
+  const root = resolveServerRoot(def, { filePath, workspaceRoot });
+  const command = await resolveCommand(def, { root, workspaceRoot, onEvent });
+  if (command?.error) return { status: "unavailable", id: def.id, root, reason: command.error };
+  if (!command) return { status: "unavailable", id: def.id, root, reason: `missing ${def.command[0]}` };
+
+  const managedTypeScript = await ensureTypeScriptFallback(def, { root, workspaceRoot, onEvent });
+  if (managedTypeScript?.error) return { status: "unavailable", id: def.id, root, reason: managedTypeScript.error };
 
-  const root = def.rootMarkers.length > 0
-    ? findNearestRoot(dirname(filePath), workspaceRoot, def.rootMarkers) ?? workspaceRoot
-    : workspaceRoot;
-  const command = findCommand(def.command, { root, workspaceRoot });
-  if (!command) return null;
   const initialization = def.initialization?.({ root, workspaceRoot }) ?? {};
-  if (initialization === null) return null;
+  if (initialization === null) {
+    return { status: "unavailable", id: def.id, root, reason: def.missingInitialization ?? "missing SDK" };
+  }
   return {
-    id: def.id,
-    command,
-    args: def.args,
-    root,
-    initialization,
+    status: "available",
+    server: { id: def.id, command: command.command, args: def.args, root, initialization, managed: command.managed },
   };
 }
 
@@ -150,6 +168,42 @@ export function listLspServerDefinitions() {
   return LSP_SERVERS.map(({ id, extensions, rootMarkers, command, args }) => ({ id, extensions, rootMarkers, command, args }));
 }
 
+async function resolveCommand(def, { root, workspaceRoot, onEvent }) {
+  const local = findCommand(def.command, { root, workspaceRoot });
+  if (local) return { command: local, managed: false };
+  if (!def.managedCommand) return null;
+  onEvent?.({ status: "installing", id: def.id, root, reason: `installing ${def.managedCommand}` });
+  try {
+    const managed = await ensureManagedNodeCommand(def.managedCommand);
+    return { command: managed.command, managed: true };
+  } catch (err) {
+    const reason = err.message;
+    onEvent?.({ status: "failed", id: def.id, root, reason });
+    return { error: reason };
+  }
+}
+
+async function ensureTypeScriptFallback(def, { root, workspaceRoot, onEvent }) {
+  if (!def.managedTypeScript || resolveTypeScriptServer({ root, workspaceRoot })) return null;
+  onEvent?.({ status: "installing", id: def.id, root, reason: "installing typescript" });
+  try {
+    await ensureManagedTypeScript();
+    return null;
+  } catch (err) {
+    const reason = err.message;
+    onEvent?.({ status: "failed", id: def.id, root, reason });
+    return { error: reason };
+  }
+}
+
+function resolveServerRoot(def, { filePath, workspaceRoot }) {
+  const projectRoot = def.projectRoot?.({ filePath, workspaceRoot });
+  if (projectRoot) return projectRoot;
+  return def.rootMarkers.length > 0
+    ? findNearestRoot(dirname(filePath), workspaceRoot, def.rootMarkers) ?? workspaceRoot
+    : workspaceRoot;
+}
+
 function findCommand(names, { root, workspaceRoot }) {
   for (const name of names) {
     const hit = findBin(name, { root, workspaceRoot });
@@ -160,7 +214,7 @@ function findCommand(names, { root, workspaceRoot }) {
 
 function findBin(name, { root, workspaceRoot }) {
   const names = platformCommandNames(name);
-  for (const base of [root, workspaceRoot]) {
+  for (const base of uniquePaths([root, workspaceRoot])) {
     for (const bin of names) {
       const candidate = join(base, "node_modules", ".bin", bin);
       if (existsSync(candidate)) return candidate;
@@ -185,6 +239,24 @@ function findOnPath(names) {
   return null;
 }
 
+function resolveTypeScriptServer({ root, workspaceRoot }) {
+  return resolveModuleFromRoots("typescript/lib/tsserver.js", { root, workspaceRoot }) ?? findManagedTypeScriptServer();
+}
+
+function resolveTypeScriptSdk({ root, workspaceRoot }) {
+  const serverLibrary = resolveModuleFromRoots("typescript/lib/tsserverlibrary.js", { root, workspaceRoot });
+  const tsserver = serverLibrary ?? resolveTypeScriptServer({ root, workspaceRoot });
+  return tsserver ? dirname(tsserver) : findManagedTypeScriptSdk();
+}
+
+function resolveModuleFromRoots(id, { root, workspaceRoot }) {
+  for (const base of uniquePaths([root, workspaceRoot])) {
+    const hit = resolveModule(id, base);
+    if (hit) return hit;
+  }
+  return null;
+}
+
 function resolveModule(id, base) {
   try {
     return createRequire(join(base, "package.json")).resolve(id);
@@ -193,6 +265,10 @@ function resolveModule(id, base) {
   }
 }
 
+function uniquePaths(paths) {
+  return [...new Set(paths.map((path) => resolve(path)))];
+}
+
 function findNearestRoot(start, stop, markers) {
   let dir = resolve(start);
   const boundary = resolve(stop);

package/src/lsp/service.mjs

@@ -1,28 +1,40 @@
 import { LspClient } from "./client.mjs";
 import { LspDiagnosticStore } from "./diagnostic-store.mjs";
-import { resolveLspServer } from "./servers.mjs";
+import { resolveLspServerStatus } from "./servers.mjs";
 
 export class LspService {
-  constructor({ cwd }) {
+  constructor({ cwd, onEvent = null }) {
     this.cwd = cwd;
+    this.onEvent = onEvent;
     this.store = new LspDiagnosticStore();
     this.clients = new Map();
     this.spawning = new Map();
+    this.unavailable = new Map();
+    this.announced = new Set();
   }
 
-  touchFile(path) {
-    const server = resolveLspServer({ filePath: path, workspaceRoot: this.cwd });
-    if (!server) return;
+  async touchFile(path) {
+    const result = await resolveLspServerStatus({ filePath: path, workspaceRoot: this.cwd, onEvent: (event) => this.onEvent?.(event) });
+    if (result.status === "unsupported") return result;
+    if (result.status === "unavailable") {
+      this.unavailable.set(result.id, result);
+      this.#emitOnce(`unavailable:${result.id}:${result.reason}`, result);
+      return result;
+    }
+
+    const server = result.server;
     const key = `${server.id}:${server.root}`;
     const existing = this.clients.get(key);
     if (existing) {
       existing.touchFile(path);
-      return;
+      return { status: "already_attached", id: server.id, root: server.root };
     }
     if (this.spawning.has(key)) {
       this.spawning.get(key).then((client) => client?.touchFile(path)).catch(() => {});
-      return;
+      return { status: "starting", id: server.id, root: server.root };
     }
+
+    this.#emitOnce(`starting:${key}`, { status: "starting", id: server.id, root: server.root, managed: server.managed });
     const task = this.#startClient(server, key).then((client) => {
       client?.touchFile(path);
       return client;
@@ -31,13 +43,25 @@ export class LspService {
     task.finally(() => {
       if (this.spawning.get(key) === task) this.spawning.delete(key);
     }).catch(() => {});
+    return { status: "starting", id: server.id, root: server.root };
   }
 
   snapshot() {
-    const diagnostics = this.store.snapshot();
-    const statuses = [...this.clients.values()].map((client) => client.status);
-    const status = statuses.includes("busy") ? "busy" : statuses.includes("starting") ? "starting" : statuses.includes("failed") ? "failed" : statuses.length > 0 ? "idle" : "";
-    return { status, diagnostics };
+    const storeSnapshot = this.store.snapshot();
+    const servers = [
+      ...[...this.clients.values()].map((client) => ({
+        id: client.serverId,
+        root: client.cwd,
+        status: client.status,
+      })),
+      ...[...this.spawning.keys()].map((key) => ({
+        id: key.slice(0, key.indexOf(":")),
+        root: key.slice(key.indexOf(":") + 1),
+        status: "starting",
+      })),
+      ...this.unavailable.values(),
+    ];
+    return { status: summarizeStatus(servers), diagnostics: storeSnapshot.diagnostics, files: storeSnapshot.files, servers };
   }
 
   async dispose() {
@@ -56,10 +80,31 @@ export class LspService {
     try {
       await client.start();
       this.clients.set(key, client);
+      this.unavailable.delete(server.id);
+      this.#emitOnce(`attached:${key}`, { status: "attached", id: server.id, root: server.root, managed: server.managed });
       return client;
-    } catch {
+    } catch (err) {
       client.status = "failed";
+      const event = { status: "failed", id: server.id, root: server.root, reason: err.message };
+      this.unavailable.set(server.id, event);
+      this.#emitOnce(`failed:${key}:${err.message}`, event);
       return null;
     }
   }
+
+  #emitOnce(key, event) {
+    if (this.announced.has(key)) return;
+    this.announced.add(key);
+    this.onEvent?.(event);
+  }
+}
+
+function summarizeStatus(servers) {
+  const statuses = servers.map((server) => server.status);
+  if (statuses.includes("busy")) return "busy";
+  if (statuses.includes("starting")) return "starting";
+  if (statuses.includes("failed")) return "failed";
+  if (statuses.includes("ready") || statuses.includes("idle")) return "idle";
+  if (statuses.includes("unavailable")) return "unavailable";
+  return "";
 }

package/src/lsp/status-message.mjs

@@ -0,0 +1,9 @@
+export function formatLspServiceEvent(event) {
+  const id = event?.id ? String(event.id) : "server";
+  if (event?.status === "attached") return `LSP attached: ${id}`;
+  if (event?.status === "starting") return `LSP starting: ${id}`;
+  if (event?.status === "installing") return `LSP installing: ${id} - ${event.reason}`;
+  if (event?.status === "failed") return `LSP failed: ${id} - ${event.reason}`;
+  if (event?.status === "unavailable") return `LSP unavailable: ${id} - ${event.reason}`;
+  return `LSP ${event?.status ?? "status"}: ${id}`;
+}