march-cli 0.1.9 → 0.1.10

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/lsp/diagnostics-format.mjs

@@ -1,3 +1,5 @@
+import { sameLspPath } from "./path-match.mjs";
+
 const MAX_DIAGNOSTICS = 20;
 
 export function formatLspDiagnostics({ snapshot } = {}) {
@@ -20,7 +22,7 @@ export function formatLspDiagnostics({ snapshot } = {}) {
 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 formatLspDiagnostics({
     snapshot: {

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,23 +12,28 @@ const LSP_SERVERS = [
     extensions: [".vue"],
     rootMarkers: NODE_ROOT_MARKERS,
     command: ["vue-language-server"],
+    managedCommand: "vue-language-server",
     args: ["--stdio"],
     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 = resolveTypeScriptServer({ root, workspaceRoot });
       return tsserver ? { tsserver: { path: tsserver } } : null;
     },
+    managedTypeScript: true,
     missingInitialization: "missing project typescript/tsserver.js",
   },
   {
@@ -129,23 +136,23 @@ const LSP_SERVERS = [
   },
 ];
 
-export function resolveLspServer({ filePath, workspaceRoot }) {
-  const result = resolveLspServerStatus({ 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 function resolveLspServerStatus({ filePath, workspaceRoot }) {
+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 { status: "unsupported", extension: ext };
 
-  const root = def.rootMarkers.length > 0
-    ? findNearestRoot(dirname(filePath), workspaceRoot, def.rootMarkers) ?? workspaceRoot
-    : workspaceRoot;
-  const command = findCommand(def.command, { root, workspaceRoot });
-  if (!command) {
-    return { status: "unavailable", id: def.id, root, reason: `missing ${def.command[0]}` };
-  }
+  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 initialization = def.initialization?.({ root, workspaceRoot }) ?? {};
   if (initialization === null) {
@@ -153,7 +160,7 @@ export function resolveLspServerStatus({ filePath, workspaceRoot }) {
   }
   return {
     status: "available",
-    server: { id: def.id, command, args: def.args, root, initialization },
+    server: { id: def.id, command: command.command, args: def.args, root, initialization, managed: command.managed },
   };
 }
 
@@ -161,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 });
@@ -197,13 +240,13 @@ function findOnPath(names) {
 }
 
 function resolveTypeScriptServer({ root, workspaceRoot }) {
-  return resolveModuleFromRoots("typescript/lib/tsserver.js", { 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) : null;
+  return tsserver ? dirname(tsserver) : findManagedTypeScriptSdk();
 }
 
 function resolveModuleFromRoots(id, { root, workspaceRoot }) {

package/src/lsp/service.mjs

@@ -13,8 +13,8 @@ export class LspService {
     this.announced = new Set();
   }
 
-  touchFile(path) {
-    const result = resolveLspServerStatus({ filePath: path, workspaceRoot: this.cwd });
+  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);
@@ -34,7 +34,7 @@ export class LspService {
       return { status: "starting", id: server.id, root: server.root };
     }
 
-    this.#emitOnce(`starting:${key}`, { 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;
@@ -47,7 +47,7 @@ export class LspService {
   }
 
   snapshot() {
-    const diagnostics = this.store.snapshot();
+    const storeSnapshot = this.store.snapshot();
     const servers = [
       ...[...this.clients.values()].map((client) => ({
         id: client.serverId,
@@ -61,7 +61,7 @@ export class LspService {
       })),
       ...this.unavailable.values(),
     ];
-    return { status: summarizeStatus(servers), diagnostics, servers };
+    return { status: summarizeStatus(servers), diagnostics: storeSnapshot.diagnostics, files: storeSnapshot.files, servers };
   }
 
   async dispose() {
@@ -81,7 +81,7 @@ export class LspService {
       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 });
+      this.#emitOnce(`attached:${key}`, { status: "attached", id: server.id, root: server.root, managed: server.managed });
       return client;
     } catch (err) {
       client.status = "failed";

package/src/lsp/status-message.mjs

@@ -2,6 +2,7 @@ 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}`;