march-cli 0.1.39 → 0.1.41

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

@@ -1,29 +1,45 @@
-import { existsSync, readFileSync } from "node:fs";
-import { getMarchSessionStatePath, loadMarchSessionState, saveMarchSessionStateValue } from "./march-session-state.mjs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getMarchSessionStatePath, loadMarchSessionState, normalizeSessionId } from "./march-session-state.mjs";
+
+export const TUI_SESSION_TIMELINE_VERSION = 1;
+
+export function getTuiSessionUiStateRoot(projectMarchDir) {
+  return join(projectMarchDir, "ui", "tui", "sessions");
+}
+
+export function getTuiSessionTimelinePath(projectMarchDir, sessionId) {
+  return join(getTuiSessionUiStateRoot(projectMarchDir), normalizeSessionId(sessionId), "timeline.json");
+}
 
 export function loadMarchSessionRenderTimeline({ projectMarchDir, sessionId }) {
-  const persistedRender = readPersistedRenderTimelineInfo({ projectMarchDir, sessionId });
+  const tuiTimeline = loadTuiRenderTimeline({ projectMarchDir, sessionId });
+  if (tuiTimeline) return tuiTimeline;
+
+  const legacyTimeline = loadLegacyCoreRenderTimeline({ projectMarchDir, sessionId });
+  if (legacyTimeline) return legacyTimeline;
+
   const stored = loadMarchSessionState({ projectMarchDir, sessionId });
   if (!stored) return null;
-  const renderTimeline = normalizeSessionRenderTimeline(stored.state.renderTimeline);
   return {
     path: stored.path,
-    renderTimeline: persistedRender.hasUiOwnedTimeline ? renderTimeline : renderTimelineFromTurns(stored.state.turns ?? []),
+    renderTimeline: renderTimelineFromTurns(stored.state.turns ?? []),
+    source: "core-turns",
   };
 }
 
 export function saveMarchSessionRenderTimeline({ projectMarchDir, sessionId, renderTimeline }) {
-  const stored = loadMarchSessionState({ projectMarchDir, sessionId });
-  if (!stored) return null;
-  return saveMarchSessionStateValue({
-    projectMarchDir,
+  if (!sessionId) throw new Error("March session id is required");
+  const state = {
+    version: TUI_SESSION_TIMELINE_VERSION,
+    savedAt: new Date().toISOString(),
     sessionId,
-    state: {
-      ...stored.state,
-      renderTimeline: normalizeSessionRenderTimeline(renderTimeline),
-      renderTimelineUpdatedAt: new Date().toISOString(),
-    },
-  });
+    renderTimeline: normalizeSessionRenderTimeline(renderTimeline),
+  };
+  const path = getTuiSessionTimelinePath(projectMarchDir, sessionId);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(state, null, 2), "utf8");
+  return { path, renderTimeline: state.renderTimeline, state };
 }
 
 export function normalizeSessionRenderTimeline(events) {
@@ -33,15 +49,28 @@ export function normalizeSessionRenderTimeline(events) {
     .map((event) => ({ method: event.method, args: event.args, at: event.at ?? null }));
 }
 
-function readPersistedRenderTimelineInfo({ projectMarchDir, sessionId }) {
+function loadTuiRenderTimeline({ projectMarchDir, sessionId }) {
+  try {
+    const path = getTuiSessionTimelinePath(projectMarchDir, sessionId);
+    if (!existsSync(path)) return null;
+    const state = JSON.parse(readFileSync(path, "utf8"));
+    if (state?.version !== TUI_SESSION_TIMELINE_VERSION) return null;
+    return { path, renderTimeline: normalizeSessionRenderTimeline(state.renderTimeline), source: "tui" };
+  } catch {
+    return null;
+  }
+}
+
+function loadLegacyCoreRenderTimeline({ projectMarchDir, sessionId }) {
   try {
     const path = getMarchSessionStatePath(projectMarchDir, sessionId);
-    if (!existsSync(path)) return { hasUiOwnedTimeline: false };
+    if (!existsSync(path)) return null;
     const raw = JSON.parse(readFileSync(path, "utf8"));
     const rawTimeline = normalizeSessionRenderTimeline(raw.renderTimeline);
-    return { hasUiOwnedTimeline: Boolean(raw.renderTimelineUpdatedAt) || rawTimeline.length > 0 };
+    if (!raw.renderTimelineUpdatedAt && rawTimeline.length === 0) return null;
+    return { path, renderTimeline: rawTimeline, source: "legacy-core-render" };
   } catch {
-    return { hasUiOwnedTimeline: false };
+    return null;
   }
 }
 

package/src/workspace/session-restore.mjs

@@ -0,0 +1,22 @@
+import { loadMarchSessionStateForPiBackend } from "../session/state/march-session-state.mjs";
+
+export function loadOptionalWorkspaceMarchSessionState({ runtime, session }) {
+  try {
+    return loadWorkspaceMarchSessionState({ runtime, session });
+  } catch {
+    return null;
+  }
+}
+
+export function loadWorkspaceMarchSessionState({ runtime, session }) {
+  const stored = loadMarchSessionStateForPiBackend({
+    projectMarchDir: runtime.projectMarchDir,
+    sessionId: session.id,
+    sessionRef: session.path,
+  });
+  if (!stored) throw new Error(`March session state not found for ${session.id}; refusing partial resume`);
+  if (stored.state.cwd && stored.state.cwd !== runtime.runner.engine.cwd) {
+    throw new Error(`March session state cwd mismatch for ${session.id}: ${stored.state.cwd}`);
+  }
+  return stored.state;
+}

package/src/workspace/supervisor.mjs

@@ -1,12 +1,15 @@
-import { join } from "node:path";
-import { loadMarchSessionStateForPiBackend } from "../session/state/march-session-state.mjs";
+import { basename, join } from "node:path";
+import { createSessionControllerLeaseManager } from "../session/control/controller-lease.mjs";
+import { loadOptionalWorkspaceMarchSessionState, loadWorkspaceMarchSessionState } from "./session-restore.mjs";
+import { createViewOnlyRuntime } from "./view-runtime.mjs";
 
-export function createWorkspaceSessionSupervisor({ initialRuntime, createProjectRuntime, viewSessionState = initialRuntime?.sessionState, onActivate = null }) {
+export function createWorkspaceSessionSupervisor({ initialRuntime, createProjectRuntime, viewSessionState = initialRuntime?.sessionState, onActivate = null, controllerLeases = createSessionControllerLeaseManager({ cwd: initialRuntime?.cwd }) }) {
   if (!initialRuntime?.project?.projectId) throw new Error("initial workspace runtime is missing project metadata");
   if (typeof createProjectRuntime !== "function") throw new Error("createProjectRuntime is required");
 
   const runtimes = new Map();
   let active = initialRuntime;
+  let activeView = null;
   let disposed = false;
   rememberRuntime(initialRuntime);
 
@@ -18,15 +21,21 @@ export function createWorkspaceSessionSupervisor({ initialRuntime, createProject
       if (prop === "activateWorkspaceSessionById") return activateWorkspaceSessionById;
       if (prop === "startNewWorkspaceSession") return startNewWorkspaceSession;
       if (prop === "refreshActiveRuntime") return refreshActiveRuntime;
-      const value = active.runner[prop];
-      return typeof value === "function" ? value.bind(active.runner) : value;
+      if (prop === "viewWorkspaceSession") return viewWorkspaceSession;
+      if (prop === "runTurn") return runActiveTurn;
+      if (prop === "abort") return abortActiveTurn;
+      if (prop === "startNewSession") return startActiveNewSession;
+      if (prop === "switchPiSession") return switchActivePiSession;
+      const current = getActive();
+      const value = current.runner[prop];
+      return typeof value === "function" ? value.bind(current.runner) : value;
     },
     set(_target, prop, value) {
-      active.runner[prop] = value;
+      getActive().runner[prop] = value;
       return true;
     },
     has(_target, prop) {
-      return prop === "dispose" || prop === "getActiveWorkspaceRuntime" || prop === "activateWorkspaceSession" || prop === "activateWorkspaceSessionById" || prop === "startNewWorkspaceSession" || prop === "refreshActiveRuntime" || prop in active.runner;
+      return prop === "dispose" || prop === "getActiveWorkspaceRuntime" || prop === "activateWorkspaceSession" || prop === "activateWorkspaceSessionById" || prop === "startNewWorkspaceSession" || prop === "refreshActiveRuntime" || prop === "viewWorkspaceSession" || prop === "runTurn" || prop === "abort" || prop === "startNewSession" || prop === "switchPiSession" || prop in getActive().runner;
     },
   });
 
@@ -37,6 +46,7 @@ export function createWorkspaceSessionSupervisor({ initialRuntime, createProject
     getRunningTurns,
     getRuntimeSummaries,
     refreshActiveRuntime,
+    viewWorkspaceSession,
     activateWorkspaceSession,
     activateWorkspaceSessionById,
     startNewWorkspaceSession,
@@ -44,7 +54,7 @@ export function createWorkspaceSessionSupervisor({ initialRuntime, createProject
   };
 
   function getActive() {
-    return active;
+    return activeView ?? active;
   }
 
   function hasRunningTurn() {
@@ -65,9 +75,10 @@ export function createWorkspaceSessionSupervisor({ initialRuntime, createProject
   }
 
   function refreshActiveRuntime() {
-    rememberRuntime(active);
-    mirrorSessionState(viewSessionState, active.sessionState);
-    onActivate?.({ projectId: active.project.projectId, sessionId: getRuntimeSessionId(active), runtime: active });
+    const current = getActive();
+    if (!current.viewOnly) rememberRuntime(current);
+    mirrorSessionState(viewSessionState, current.sessionState);
+    onActivate?.({ projectId: current.project.projectId, sessionId: getRuntimeSessionId(current), runtime: current });
   }
 
   async function activateWorkspaceSessionById({ projects = [], projectId, sessionId }) {
@@ -79,35 +90,64 @@ export function createWorkspaceSessionSupervisor({ initialRuntime, createProject
   }
 
   async function startNewWorkspaceSession(project) {
+    activeView = null;
+    const previous = active;
     const runtime = await getIdleRuntimeForProject(project);
     active = runtime;
     const result = await active.runner.startNewSession();
-    if (!result?.cancelled && result?.sessionId) syncSessionState(active, result.sessionId);
+    if (!result?.cancelled && result?.sessionId) {
+      syncSessionState(active, result.sessionId);
+      replaceRuntimeLease(active, acquireRuntimeLease(active, { sessionId: result.sessionId, sessionPath: result.sessionFile ?? null }));
+      releaseIdleRuntimeLease(previous, active);
+    }
     rememberRuntime(active);
     mirrorSessionState(viewSessionState, active.sessionState);
     onActivate?.({ projectId: active.project.projectId, sessionId: getRuntimeSessionId(active), runtime: active, restoreState: null });
     return { runtime: active, result };
   }
 
-  async function activateWorkspaceSession({ project, session = null }) {
+  async function activateWorkspaceSession({ project, session = null, force = false }) {
     if (disposed) throw new Error("workspace supervisor is already disposed");
     if (!project?.projectId) throw new Error("workspace project is required");
 
     let runtime = session?.id ? runtimes.get(runtimeKey(project.projectId, session.id)) : findIdleRuntime(project.projectId);
     if (!runtime) runtime = await createProjectRuntime(project);
 
-    let restoreState = null;
-    if (session?.path && getRuntimeSessionId(runtime) !== session.id) {
-      restoreState = loadWorkspaceMarchSessionState({ runtime, session });
-      await runtime.runner.switchPiSession(session.path, restoreState);
-      syncSessionState(runtime, session.id);
+    const targetSessionId = session?.id ?? null;
+    const lease = targetSessionId ? acquireRuntimeLease(runtime, { sessionId: targetSessionId, sessionPath: session?.path ?? null }, { force }) : null;
+    const previous = active;
+    try {
+      let restoreState = null;
+      if (session?.path && getRuntimeSessionId(runtime) !== targetSessionId) {
+        restoreState = loadWorkspaceMarchSessionState({ runtime, session });
+        await runtime.runner.switchPiSession(session.path, restoreState);
+      }
+      if (targetSessionId) syncSessionState(runtime, targetSessionId);
+
+      replaceRuntimeLease(runtime, lease);
+      releaseIdleRuntimeLease(previous, runtime);
+      activeView = null;
+      active = runtime;
+      rememberRuntime(runtime);
+      mirrorSessionState(viewSessionState, runtime.sessionState);
+      onActivate?.({ projectId: runtime.project.projectId, sessionId: getRuntimeSessionId(runtime), runtime, restoreState });
+      return active;
+    } catch (err) {
+      lease?.release?.();
+      throw err;
     }
+  }
 
-    active = runtime;
-    rememberRuntime(runtime);
-    mirrorSessionState(viewSessionState, runtime.sessionState);
-    onActivate?.({ projectId: runtime.project.projectId, sessionId: getRuntimeSessionId(runtime), runtime, restoreState });
-    return active;
+  function viewWorkspaceSession({ project, session }) {
+    if (disposed) throw new Error("workspace supervisor is already disposed");
+    if (!project?.projectId || !session?.id) throw new Error("workspace session is required");
+    const baseRuntime = findIdleRuntime(project.projectId, { allowSessionRuntime: false }) ?? active;
+    const restoreState = session.path ? loadOptionalWorkspaceMarchSessionState({ runtime: { ...baseRuntime, project, projectMarchDir: join(project.rootPath, ".march") }, session }) : null;
+    const view = createViewOnlyRuntime({ project, session, baseRuntime, restoreState });
+    activeView = view;
+    mirrorSessionState(viewSessionState, view.sessionState);
+    onActivate?.({ projectId: project.projectId, sessionId: session.id, runtime: view, restoreState, viewOnly: true });
+    return view;
   }
 
   async function getIdleRuntimeForProject(project) {
@@ -137,28 +177,98 @@ export function createWorkspaceSessionSupervisor({ initialRuntime, createProject
     disposed = true;
     const uniqueRuntimes = new Set(runtimes.values());
     await Promise.all(Array.from(uniqueRuntimes, async (runtime) => {
+      releaseRuntimeLease(runtime);
       await runtime.runner.dispose?.();
       runtime.memoryStore?.close?.();
     }));
   }
-}
 
-function loadWorkspaceMarchSessionState({ runtime, session }) {
-  const stored = loadMarchSessionStateForPiBackend({
-    projectMarchDir: runtime.projectMarchDir,
-    sessionId: session.id,
-    sessionRef: session.path,
-  });
-  if (!stored) throw new Error(`March session state not found for ${session.id}; refusing partial resume`);
-  if (stored.state.cwd && stored.state.cwd !== runtime.runner.engine.cwd) {
-    throw new Error(`March session state cwd mismatch for ${session.id}: ${stored.state.cwd}`);
+  async function runActiveTurn(...args) {
+    if (activeView) throw new Error("This session is view-only. Use /session and Take over control before sending prompts.");
+    ensureRuntimeLease(active);
+    return await active.runner.runTurn(...args);
+  }
+
+  function abortActiveTurn(...args) {
+    if (activeView) throw new Error("This session is view-only; there is no local turn to abort.");
+    ensureRuntimeLease(active);
+    return active.runner.abort(...args);
+  }
+
+  async function startActiveNewSession(...args) {
+    activeView = null;
+    const result = await active.runner.startNewSession(...args);
+    if (!result?.cancelled && result?.sessionId) {
+      syncSessionState(active, result.sessionId);
+      replaceRuntimeLease(active, acquireRuntimeLease(active, { sessionId: result.sessionId, sessionPath: result.sessionFile ?? null }));
+      rememberRuntime(active);
+      mirrorSessionState(viewSessionState, active.sessionState);
+    }
+    return result;
+  }
+
+  async function switchActivePiSession(sessionPath, restoreState = null, ...args) {
+    activeView = null;
+    const sessionId = sessionIdFromSessionPath(sessionPath);
+    const lease = acquireRuntimeLease(active, { sessionId, sessionPath });
+    try {
+      const result = await active.runner.switchPiSession(sessionPath, restoreState, ...args);
+      if (result?.cancelled) {
+        lease.release?.();
+        return result;
+      }
+      const stats = active.runner.getSessionStats?.() ?? {};
+      syncSessionState(active, stats.sessionId ?? sessionId);
+      replaceRuntimeLease(active, lease);
+      rememberRuntime(active);
+      mirrorSessionState(viewSessionState, active.sessionState);
+      return result;
+    } catch (err) {
+      lease.release?.();
+      throw err;
+    }
+  }
+
+  function acquireRuntimeLease(runtime, session, options = {}) {
+    if (!session?.sessionId) return null;
+    return controllerLeases.acquire({
+      sessionId: session.sessionId,
+      sessionPath: session.sessionPath ?? getRuntimeSessionFile(runtime),
+      projectMarchDir: runtime.projectMarchDir,
+    }, options);
+  }
+
+  function ensureRuntimeLease(runtime) {
+    const sessionId = getRuntimeSessionId(runtime);
+    if (!sessionId) return null;
+    if (!runtime.controllerLease) replaceRuntimeLease(runtime, acquireRuntimeLease(runtime, { sessionId }));
+    runtime.controllerLease.assertOwned();
+    return runtime.controllerLease;
+  }
+
+  function replaceRuntimeLease(runtime, lease) {
+    if (runtime.controllerLease === lease) return;
+    runtime.controllerLease?.release?.();
+    runtime.controllerLease = lease;
+  }
+
+  function releaseRuntimeLease(runtime) {
+    runtime.controllerLease?.release?.();
+    runtime.controllerLease = null;
+  }
+
+  function releaseIdleRuntimeLease(runtime, nextRuntime) {
+    if (!runtime || runtime === nextRuntime || runtime.turnTask) return;
+    releaseRuntimeLease(runtime);
   }
-  const { renderTimeline: _renderTimeline, ...contextState } = stored.state;
-  return contextState;
 }
 
 function getRuntimeSessionId(runtime) {
-  return runtime.runner.getSessionStats?.()?.sessionId ?? runtime.sessionState?.sessionId ?? null;
+  return runtime.sessionState?.sessionId ?? runtime.runner.getSessionStats?.()?.sessionId ?? null;
+}
+
+function getRuntimeSessionFile(runtime) {
+  return runtime.runner.getSessionStats?.()?.sessionFile ?? null;
 }
 
 function syncSessionState(runtime, sessionId) {
@@ -176,3 +286,7 @@ function mirrorSessionState(target, source) {
 function runtimeKey(projectId, sessionId = null) {
   return `${projectId}:${sessionId ?? ""}`;
 }
+
+function sessionIdFromSessionPath(sessionPath) {
+  return basename(String(sessionPath)).replace(/\.jsonl?$/i, "");
+}

package/src/workspace/view-runtime.mjs

@@ -0,0 +1,40 @@
+import { join, resolve } from "node:path";
+
+export function createViewOnlyRuntime({ project, session, baseRuntime, restoreState }) {
+  const projectRoot = resolveProjectRoot(project, baseRuntime);
+  const sessionState = {
+    sessionId: session.id,
+    sessionDir: join(projectRoot, ".march", "sessions", session.id),
+  };
+  const runner = {
+    engine: { cwd: projectRoot, turns: restoreState?.turns ?? [] },
+    runtimeState: { engine: { cwd: projectRoot } },
+    getSessionStats: () => ({ sessionId: session.id, sessionFile: session.path ?? null }),
+    estimateContextTokens: () => null,
+    canSwitchPiSession: () => false,
+    runTurn: rejectViewOnlyControl,
+    abort: rejectViewOnlyControl,
+    startNewSession: rejectViewOnlyControl,
+    switchPiSession: rejectViewOnlyControl,
+  };
+  return {
+    ...baseRuntime,
+    project,
+    cwd: projectRoot,
+    currentProject: project.displayName,
+    projectMarchDir: join(projectRoot, ".march"),
+    sessionsRoot: join(projectRoot, ".march", "sessions"),
+    sessionState,
+    runner,
+    turnTask: null,
+    viewOnly: true,
+  };
+}
+
+function rejectViewOnlyControl() {
+  throw new Error("This session is view-only. Use /session and Take over control before sending prompts.");
+}
+
+function resolveProjectRoot(project, fallbackRuntime) {
+  return project?.rootPath ? resolve(project.rootPath) : fallbackRuntime.cwd;
+}