march-cli 0.1.39 → 0.1.41

package/src/cli/workspace/tui-timeline.mjs

@@ -0,0 +1,247 @@
+import { createTuiTimelineProjection } from "./tui-timeline-projection.mjs";
+
+export const DEFAULT_MAX_TIMELINE_EVENTS = 4000;
+export const DEFAULT_TIMELINE_PERSIST_DEBOUNCE_MS = 250;
+
+export function createTuiTimelineRegistry({
+  maxEventsPerTimeline = DEFAULT_MAX_TIMELINE_EVENTS,
+  persistDebounceMs = DEFAULT_TIMELINE_PERSIST_DEBOUNCE_MS,
+  onPersistTimeline = null,
+} = {}) {
+  const timelines = new Map();
+
+  return {
+    ensure(key, { events = null } = {}) {
+      let timeline = timelines.get(key);
+      if (!timeline) {
+        timeline = createTuiTimelineInstance({
+          key,
+          maxEvents: maxEventsPerTimeline,
+          persistDebounceMs,
+          onPersist: onPersistTimeline,
+        });
+        timelines.set(key, timeline);
+      }
+      if (Array.isArray(events)) timeline.hydrateIfEmpty(events);
+      return timeline;
+    },
+    get(key) {
+      return timelines.get(key) ?? null;
+    },
+    has(key) {
+      return timelines.has(key);
+    },
+    clear(key, options) {
+      const timeline = this.ensure(key);
+      timeline.clear(options);
+      return timeline;
+    },
+    flush(key, reason = "manual") {
+      return this.get(key)?.flushPersist(reason) ?? false;
+    },
+    flushAll(reason = "manual") {
+      let flushed = 0;
+      for (const timeline of timelines.values()) {
+        if (timeline.flushPersist(reason)) flushed += 1;
+      }
+      return flushed;
+    },
+    replaceEvents(key, events) {
+      const timeline = this.ensure(key);
+      timeline.replaceEvents(events);
+      return timeline;
+    },
+    getEvents(key) {
+      return this.get(key)?.getEvents() ?? [];
+    },
+    getBlocks(key) {
+      return this.get(key)?.getBlocks() ?? [];
+    },
+    getEventCount(key) {
+      return this.get(key)?.getEventCount() ?? 0;
+    },
+    getMetadata(key) {
+      return this.get(key)?.getMetadata() ?? null;
+    },
+  };
+}
+
+export function createTuiTimelineInstance({
+  key,
+  maxEvents = DEFAULT_MAX_TIMELINE_EVENTS,
+  persistDebounceMs = DEFAULT_TIMELINE_PERSIST_DEBOUNCE_MS,
+  onPersist = null,
+} = {}) {
+  let events = [];
+  const projection = createTuiTimelineProjection();
+  let hydrated = false;
+  let dirty = false;
+  let lastAccessedAt = Date.now();
+  let lastUpdatedAt = null;
+  let lastPersistedAt = null;
+  let estimatedBytes = 0;
+  let persistTimer = null;
+
+  return {
+    key,
+    apply(method, args, { at = Date.now(), persist = true } = {}) {
+      touch();
+      const event = { method, args, at };
+      events.push(event);
+      projection.apply(event);
+      trimToBudget();
+      dirty = true;
+      lastUpdatedAt = at;
+      if (persist) schedulePersist("debounce");
+      return event;
+    },
+    hydrateIfEmpty(nextEvents) {
+      touch();
+      if (events.length > 0) return false;
+      replaceEvents(nextEvents, { markHydrated: true });
+      return true;
+    },
+    replaceEvents(nextEvents) {
+      touch();
+      replaceEvents(nextEvents, { markHydrated: false });
+    },
+    clear({ flush = true } = {}) {
+      touch();
+      events = [];
+      projection.clear();
+      dirty = true;
+      lastUpdatedAt = Date.now();
+      estimatedBytes = 0;
+      if (flush) this.flushPersist("clear");
+      else schedulePersist("debounce");
+    },
+    replayTo(ui) {
+      touch();
+      if (typeof ui.restoreTimelineBlocks === "function") {
+        const blocks = projection.getBlocks();
+        ui.restoreTimelineBlocks(blocks);
+        return blocks.length;
+      }
+      for (const event of events) applyRenderEvent(ui, event);
+      return events.length;
+    },
+    flushPersist(reason = "manual") {
+      clearPersistTimer();
+      if (!dirty || typeof onPersist !== "function") return false;
+      onPersist({ key, events: this.getEvents(), reason, timeline: this.getMetadata() });
+      dirty = false;
+      lastPersistedAt = Date.now();
+      return true;
+    },
+    getEvents() {
+      touch();
+      return cloneEvents(events);
+    },
+    getBlocks() {
+      touch();
+      return projection.getBlocks();
+    },
+    getEventCount() {
+      return events.length;
+    },
+    markPersisted() {
+      clearPersistTimer();
+      dirty = false;
+      lastPersistedAt = Date.now();
+    },
+    getMetadata() {
+      return buildMetadata();
+    },
+  };
+
+  function schedulePersist(reason) {
+    if (typeof onPersist !== "function") return;
+    clearPersistTimer();
+    persistTimer = setTimeout(() => {
+      persistTimer = null;
+      if (!dirty) return;
+      onPersist({ key, events: cloneEvents(events), reason, timeline: buildMetadata() });
+      dirty = false;
+      lastPersistedAt = Date.now();
+    }, Math.max(0, persistDebounceMs));
+    persistTimer.unref?.();
+  }
+
+  function clearPersistTimer() {
+    if (!persistTimer) return;
+    clearTimeout(persistTimer);
+    persistTimer = null;
+  }
+
+  function replaceEvents(nextEvents, { markHydrated }) {
+    clearPersistTimer();
+    events = normalizeTimelineEvents(nextEvents);
+    trimToBudget();
+    rebuildProjection();
+    hydrated = markHydrated;
+    dirty = false;
+    lastUpdatedAt = events.at(-1)?.at ?? null;
+    lastPersistedAt = null;
+    updateEstimatedBytes();
+  }
+
+  function trimToBudget() {
+    if (events.length > maxEvents) {
+      events.splice(0, events.length - maxEvents);
+      rebuildProjection();
+    }
+    updateEstimatedBytes();
+  }
+
+  function rebuildProjection() {
+    projection.rebuild(events);
+  }
+
+  function updateEstimatedBytes() {
+    estimatedBytes = estimateJsonBytes(events) + estimateJsonBytes(projection.getBlocks());
+  }
+
+  function touch() {
+    lastAccessedAt = Date.now();
+  }
+
+  function buildMetadata() {
+    return {
+      key,
+      eventCount: events.length,
+      maxEvents,
+      hydrated,
+      dirty,
+      lastAccessedAt,
+      lastUpdatedAt,
+      lastPersistedAt,
+      estimatedBytes,
+      persistScheduled: Boolean(persistTimer),
+      ...projection.getMetadata(),
+    };
+  }
+}
+
+export function normalizeTimelineEvents(events) {
+  if (!Array.isArray(events)) return [];
+  return events
+    .filter((event) => typeof event?.method === "string" && Array.isArray(event.args))
+    .map((event) => ({ method: event.method, args: event.args, at: event.at ?? null }));
+}
+
+function applyRenderEvent(ui, { method, args }) {
+  const value = ui[method];
+  if (typeof value === "function") value.apply(ui, args);
+}
+
+function cloneEvents(items) {
+  return items.map((event) => ({ method: event.method, args: event.args, at: event.at ?? null }));
+}
+
+function estimateJsonBytes(value) {
+  try {
+    return JSON.stringify(value).length;
+  } catch {
+    return 0;
+  }
+}

package/src/config/config-json.mjs

@@ -38,6 +38,26 @@ export function upsertProviderProfile({ path = globalConfigJsonPath(), id, type,
   return config;
 }
 
+export function removeProviderProfile({ path = globalConfigJsonPath(), id }) {
+  const config = readConfigJson(path);
+  const providers = config.providers && typeof config.providers === "object" && !Array.isArray(config.providers)
+    ? config.providers
+    : {};
+  const hadProviderProfile = Object.prototype.hasOwnProperty.call(providers, id);
+  const wasSelectedProvider = config.provider === id;
+  if (hadProviderProfile) delete providers[id];
+  if (Object.keys(providers).length) config.providers = providers;
+  else delete config.providers;
+  if (wasSelectedProvider) {
+    delete config.provider;
+    delete config.model;
+    delete config.serviceTier;
+  }
+  if (!hadProviderProfile && !wasSelectedProvider) return false;
+  writeConfigJson(path, config);
+  return true;
+}
+
 export function upsertSharedProviderProfile({ path = globalConfigJsonPath(), id, provider }) {
   const config = readConfigJson(path);
   const providers = config.providers && typeof config.providers === "object" && !Array.isArray(config.providers)

package/src/provider/command.mjs

@@ -2,6 +2,7 @@ import { homedir } from "node:os";
 import { runProviderConfigCommand } from "./config-command.mjs";
 import { runProviderShareCommand } from "./share-command.mjs";
 import { runProviderAcceptCommand } from "./accept-command.mjs";
+import { runProviderRemoveCommand } from "./remove-command.mjs";
 
 export async function runProviderCommand(args, { homeDir = homedir(), stderr = process.stderr } = {}) {
   if (args.providerConfig) return await runProviderConfigCommand({ homeDir });
@@ -16,6 +17,9 @@ export async function runProviderCommand(args, { homeDir = homedir(), stderr = p
   if (args.command.args[0] === "accept") {
     return await runProviderAcceptCommand({ homeDir, token: args.command.args[1] });
   }
-  stderr.write("Usage: march provider --config | march provider share [id] | march provider accept <token>\n");
+  if (args.command.args[0] === "remove" || args.command.args[0] === "uninstall") {
+    return await runProviderRemoveCommand({ homeDir, providerId: args.command.args[1] });
+  }
+  stderr.write("Usage: march provider --config | march provider share [id] | march provider accept <token> | march provider remove\n");
   return 1;
 }

package/src/provider/remove-command.mjs

@@ -0,0 +1,129 @@
+import { createInterface } from "node:readline";
+import { AuthStorage } from "@earendil-works/pi-coding-agent";
+import { globalConfigJsonPath, readConfigJson, removeProviderProfile } from "../config/config-json.mjs";
+import { getMarchAuthPath } from "../auth/storage.mjs";
+import { selectWithKeyboard } from "../cli/input/select-with-keyboard.mjs";
+import { getProviderLabel } from "./presets.mjs";
+
+export async function runProviderRemoveCommand({
+  homeDir,
+  providerId,
+  input = process.stdin,
+  output = process.stdout,
+  select = selectWithKeyboard,
+  confirm = confirmRemoval,
+  authStorage = AuthStorage.create(getMarchAuthPath(homeDir)),
+} = {}) {
+  const removableProviders = listRemovableProviders({ homeDir, authStorage });
+  const selectedProviderId = providerId ?? await selectProviderToRemove({ removableProviders, input, output, select });
+  if (!selectedProviderId) {
+    if (!removableProviders.length) {
+      output.write("No configured providers to remove.\nRun `march provider --config` to add one.\n");
+    } else {
+      output.write("Provider removal cancelled.\n");
+    }
+    return 1;
+  }
+
+  const provider = removableProviders.find((item) => item.id === selectedProviderId) ?? {
+    id: selectedProviderId,
+    label: getProviderLabel(selectedProviderId),
+    sources: [],
+  };
+  const confirmed = await confirm({ input, output, provider });
+  if (!confirmed) {
+    output.write("Provider removal cancelled.\n");
+    return 1;
+  }
+
+  const configRemoved = removeProviderProfile({ path: globalConfigJsonPath(homeDir), id: selectedProviderId });
+  const credentialRemoved = removeProviderCredential({ authStorage, id: selectedProviderId });
+  if (!configRemoved && !credentialRemoved) {
+    output.write(`Provider not found: ${selectedProviderId}\n`);
+    return 1;
+  }
+
+  output.write(`Removed provider: ${provider.label} (${selectedProviderId})\n`);
+  return 0;
+}
+
+export function listRemovableProviders({ homeDir, authStorage }) {
+  const config = readConfigJson(globalConfigJsonPath(homeDir));
+  const providers = config.providers && typeof config.providers === "object" && !Array.isArray(config.providers)
+    ? config.providers
+    : {};
+  const ids = new Set(Object.keys(providers));
+  for (const id of safeListAuthProviders(authStorage)) ids.add(id);
+  return [...ids].sort((a, b) => getProviderLabel(a).localeCompare(getProviderLabel(b))).map((id) => {
+    const sources = [];
+    if (Object.prototype.hasOwnProperty.call(providers, id)) sources.push("config");
+    if (safeHasAuthProvider(authStorage, id)) sources.push("credential");
+    return {
+      id,
+      label: getProviderLabel(id),
+      sources,
+    };
+  });
+}
+
+async function selectProviderToRemove({ removableProviders, input, output, select }) {
+  if (!removableProviders.length) return null;
+  return await select({
+    input,
+    output,
+    message: "Select provider to remove",
+    items: removableProviders.map((provider) => ({
+      label: `${provider.label} (${provider.id})${formatSources(provider.sources)}`,
+      value: provider.id,
+    })),
+  });
+}
+
+function removeProviderCredential({ authStorage, id }) {
+  const existed = safeHasAuthProvider(authStorage, id);
+  if (typeof authStorage.remove === "function") authStorage.remove(id);
+  return existed;
+}
+
+function safeListAuthProviders(authStorage) {
+  if (typeof authStorage.list !== "function") return [];
+  try {
+    const providers = authStorage.list();
+    return Array.isArray(providers) ? providers.filter((id) => typeof id === "string" && id) : [];
+  } catch {
+    return [];
+  }
+}
+
+function safeHasAuthProvider(authStorage, id) {
+  if (typeof authStorage.get === "function") {
+    try {
+      return authStorage.get(id) != null;
+    } catch {
+      return false;
+    }
+  }
+  return safeListAuthProviders(authStorage).includes(id);
+}
+
+function formatSources(sources) {
+  if (!sources.length) return "";
+  return ` — ${sources.join(" + ")}`;
+}
+
+async function confirmRemoval({ input, output, provider }) {
+  const answer = String(await readLine({
+    input,
+    output,
+    prompt: `Remove provider "${provider.label}" (${provider.id})? This deletes local config and credentials. [y/N] `,
+  }) ?? "").trim().toLowerCase();
+  return answer === "y" || answer === "yes";
+}
+
+function readLine({ input = process.stdin, output = process.stdout, prompt }) {
+  const rl = createInterface({ input, output });
+  return new Promise((resolve) => rl.question(prompt, (answer) => {
+    rl.close();
+    resolve(answer);
+  }));
+}

package/src/session/control/controller-lease.mjs

@@ -0,0 +1,149 @@
+import { existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync, closeSync } from "node:fs";
+import { randomUUID, createHash } from "node:crypto";
+import { dirname, join, resolve } from "node:path";
+import { getMarchSessionStateDir, normalizeSessionId } from "../state/march-session-state.mjs";
+
+export const DEFAULT_SESSION_CONTROLLER_LEASE_TTL_MS = 30_000;
+export const DEFAULT_SESSION_CONTROLLER_HEARTBEAT_MS = 5_000;
+
+export class SessionControllerLeaseConflictError extends Error {
+  constructor({ sessionId, owner }) {
+    super(formatControllerLeaseConflict({ sessionId, owner }));
+    this.name = "SessionControllerLeaseConflictError";
+    this.code = "SESSION_CONTROLLER_LEASE_CONFLICT";
+    this.sessionId = sessionId;
+    this.owner = owner;
+  }
+}
+
+export function createSessionControllerLeaseManager({
+  instanceId = randomUUID(),
+  pid = process.pid,
+  cwd = process.cwd(),
+  now = () => Date.now(),
+  ttlMs = DEFAULT_SESSION_CONTROLLER_LEASE_TTL_MS,
+  heartbeatMs = DEFAULT_SESSION_CONTROLLER_HEARTBEAT_MS,
+} = {}) {
+  const ownerBase = { instanceId, pid, cwd: resolve(cwd) };
+
+  return {
+    instanceId,
+    acquire(session, options = {}) {
+      const target = resolveControllerLeaseTarget(session);
+      const path = getSessionControllerLeasePath(target);
+      const lease = writeLease({ path, target, ownerBase, now, ttlMs, force: Boolean(options.force) });
+      const heartbeat = heartbeatMs > 0 ? setInterval(() => {
+        try { refreshLease({ path, lease, now, ttlMs }); } catch {}
+      }, heartbeatMs) : null;
+      heartbeat?.unref?.();
+      return {
+        ...lease,
+        path,
+        target,
+        assertOwned() {
+          const current = readLease(path);
+          if (!current || current.owner?.instanceId !== lease.owner.instanceId || current.token !== lease.token || isExpired(current, now())) {
+            throw new SessionControllerLeaseConflictError({ sessionId: target.sessionId, owner: current?.owner ?? null });
+          }
+        },
+        release() {
+          if (heartbeat) clearInterval(heartbeat);
+          releaseLease({ path, lease });
+        },
+      };
+    },
+  };
+}
+
+export function getSessionControllerLeasePath({ sessionId, sessionPath = null, projectMarchDir = null }) {
+  if (sessionPath) {
+    const identity = resolve(sessionPath);
+    const key = createHash("sha256").update(identity).digest("hex").slice(0, 32);
+    return join(dirname(identity), ".march-controller-leases", `${key}.json`);
+  }
+  if (!projectMarchDir || !sessionId) throw new Error("session controller lease requires a session path or project March dir plus session id");
+  return join(getMarchSessionStateDir(projectMarchDir, sessionId), "controller-lease.json");
+}
+
+export function resolveControllerLeaseTarget({ sessionId, sessionPath = null, projectMarchDir = null }) {
+  const id = normalizeSessionId(sessionId);
+  return {
+    sessionId: id,
+    sessionPath: sessionPath ? resolve(sessionPath) : null,
+    projectMarchDir: projectMarchDir ? resolve(projectMarchDir) : null,
+  };
+}
+
+function writeLease({ path, target, ownerBase, now, ttlMs, force }) {
+  mkdirSync(dirname(path), { recursive: true });
+  const current = readLease(path);
+  if (current && !force && !isExpired(current, now()) && current.owner?.instanceId !== ownerBase.instanceId) {
+    throw new SessionControllerLeaseConflictError({ sessionId: target.sessionId, owner: current.owner });
+  }
+  const lease = createLease({ target, ownerBase, now, ttlMs });
+  if (force || current) {
+    writeFileSync(path, JSON.stringify(lease, null, 2), "utf8");
+    return lease;
+  }
+  let fd = null;
+  try {
+    fd = openSync(path, "wx");
+    writeFileSync(fd, JSON.stringify(lease, null, 2), "utf8");
+    return lease;
+  } catch {
+    const raced = readLease(path);
+    if (raced && !isExpired(raced, now())) throw new SessionControllerLeaseConflictError({ sessionId: target.sessionId, owner: raced.owner });
+    try { unlinkSync(path); } catch {}
+    writeFileSync(path, JSON.stringify(lease, null, 2), "utf8");
+    return lease;
+  } finally {
+    if (fd !== null) closeSync(fd);
+  }
+}
+
+function createLease({ target, ownerBase, now, ttlMs }) {
+  const acquiredAtMs = now();
+  return {
+    version: 1,
+    token: randomUUID(),
+    sessionId: target.sessionId,
+    sessionPath: target.sessionPath,
+    owner: ownerBase,
+    acquiredAt: new Date(acquiredAtMs).toISOString(),
+    heartbeatAt: new Date(acquiredAtMs).toISOString(),
+    expiresAt: new Date(acquiredAtMs + ttlMs).toISOString(),
+  };
+}
+
+function refreshLease({ path, lease, now, ttlMs }) {
+  const current = readLease(path);
+  if (!current || current.token !== lease.token || current.owner?.instanceId !== lease.owner.instanceId) return;
+  const heartbeatAtMs = now();
+  writeFileSync(path, JSON.stringify({
+    ...current,
+    heartbeatAt: new Date(heartbeatAtMs).toISOString(),
+    expiresAt: new Date(heartbeatAtMs + ttlMs).toISOString(),
+  }, null, 2), "utf8");
+}
+
+function releaseLease({ path, lease }) {
+  const current = readLease(path);
+  if (!current || current.token !== lease.token || current.owner?.instanceId !== lease.owner.instanceId) return;
+  try { unlinkSync(path); } catch {}
+}
+
+function readLease(path) {
+  if (!existsSync(path)) return null;
+  try { return JSON.parse(readFileSync(path, "utf8")); } catch { return null; }
+}
+
+function isExpired(lease, nowMs) {
+  return Date.parse(lease.expiresAt ?? 0) <= nowMs;
+}
+
+function formatControllerLeaseConflict({ sessionId, owner }) {
+  const parts = [`Session "${sessionId}" is already controlled by another March instance.`];
+  if (owner?.cwd) parts.push(`cwd: ${owner.cwd}`);
+  if (owner?.pid) parts.push(`pid: ${owner.pid}`);
+  return parts.join(" ");
+}

package/src/session/state/march-session-state.mjs

@@ -45,7 +45,7 @@ export function saveMarchSessionState({ projectMarchDir, sessionId, engine, back
 export function saveMarchSessionStateValue({ projectMarchDir, sessionId, state }) {
   if (!sessionId) throw new Error("March session id is required");
   const existing = loadMarchSessionState({ projectMarchDir, sessionId })?.state ?? null;
-  const nextState = normalizeMarchSessionStateForSave({ ...existing, ...state, renderTimeline: state.renderTimeline ?? existing?.renderTimeline });
+  const nextState = normalizeMarchSessionStateForSave({ ...existing, ...state });
   validateMarchSessionState(nextState);
   const dir = getMarchSessionStateDir(projectMarchDir, sessionId);
   mkdirSync(dir, { recursive: true });
@@ -135,22 +135,12 @@ function validateMarchSessionState(state) {
 function isValidMarchSessionState(state) {
   return state?.version === MARCH_SESSION_STATE_VERSION
     && Boolean(state.cwd)
-    && Array.isArray(state.turns)
-    && Array.isArray(state.renderTimeline);
+    && Array.isArray(state.turns);
 }
 
 function normalizeMarchSessionStateForSave(state) {
-  return {
-    ...state,
-    renderTimeline: normalizePersistedRenderTimeline(state.renderTimeline),
-  };
-}
-
-function normalizePersistedRenderTimeline(events) {
-  if (!Array.isArray(events)) return [];
-  return events
-    .filter((event) => typeof event?.method === "string" && Array.isArray(event.args))
-    .map((event) => ({ method: event.method, args: event.args, at: event.at ?? null }));
+  const { renderTimeline: _renderTimeline, renderTimelineUpdatedAt: _renderTimelineUpdatedAt, ...coreState } = state ?? {};
+  return coreState;
 }
 
 function normalizeSessionRef(sessionRef) {