@crouton-kit/capture 1.3.7 → 1.3.8

package/src/session-context.ts

@@ -2,16 +2,33 @@
  * Session Context — persists active session state so CDP commands
  * can auto-fill --target, --har, and --out without manual threading.
  *
- * State is written to /tmp/capture-sessions/.active (JSON).
+ * State is written to /tmp/capture-sessions/.active-<scope> (JSON), where
+ * <scope> isolates concurrent callers (see activeScopeKey() below) so one
+ * caller's `session start` never clobbers another's active pointer.
  * Stale sessions (dir deleted, crashed process) are cleaned up on read.
  */
 
 import * as fs from 'fs';
 import * as path from 'path';
-import * as os from 'os';
+import { CAPTURE_ROOT } from './session/artifacts.js';
 
-const CAPTURE_ROOT = path.join(os.tmpdir(), 'capture-sessions');
-const ACTIVE_PATH = path.join(CAPTURE_ROOT, '.active');
+/**
+ * The active-session pointer is scoped per caller so concurrent, unrelated
+ * capture invocations never clobber one another's "active session" — e.g.
+ * two crtr agent nodes each running `capture session start` in parallel.
+ * When invoked from a crtr node, CRTR_NODE_ID scopes the pointer to that
+ * node (stable across separate tool calls within the node's lifetime).
+ * Outside crtr (a bare interactive terminal), there's no such identity, so
+ * fall back to the single legacy pointer — the original single-user,
+ * single-session-at-a-time contract still holds there.
+ */
+function activeScopeKey(): string {
+  return process.env.CRTR_NODE_ID ?? 'default';
+}
+
+function getActivePath(): string {
+  return path.join(CAPTURE_ROOT, `.active-${activeScopeKey()}`);
+}
 
 export interface ActiveSessionState {
   sessionId: string;
@@ -21,12 +38,20 @@ export interface ActiveSessionState {
   stepCount: number;
   /** Unix socket of the session's held CDP bridge (`session start --hold`), if any. */
   bridgeSocket?: string | null;
+  /**
+   * The id of the recording (`motion/recs/{recId}`) currently live under
+   * this session, if `motion rec --start` has armed one. Cleared by
+   * `motion rec --stop` (or a stale-recorder reap). See
+   * {@link setActiveRecId}/{@link clearActiveRecId}/{@link getActiveRecId}.
+   */
+  activeRecId?: string | null;
 }
 
 export function getActiveSession(): ActiveSessionState | null {
   try {
-    if (!fs.existsSync(ACTIVE_PATH)) return null;
-    const state = JSON.parse(fs.readFileSync(ACTIVE_PATH, 'utf-8')) as ActiveSessionState;
+    const activePath = getActivePath();
+    if (!fs.existsSync(activePath)) return null;
+    const state = JSON.parse(fs.readFileSync(activePath, 'utf-8')) as ActiveSessionState;
     // Validate session dir still exists — clean up stale files
     if (!fs.existsSync(state.dir)) {
       clearActiveSession();
@@ -40,12 +65,12 @@ export function getActiveSession(): ActiveSessionState | null {
 
 export function setActiveSession(state: ActiveSessionState): void {
   fs.mkdirSync(CAPTURE_ROOT, { recursive: true });
-  fs.writeFileSync(ACTIVE_PATH, JSON.stringify(state, null, 2));
+  fs.writeFileSync(getActivePath(), JSON.stringify(state, null, 2));
 }
 
 export function clearActiveSession(): void {
   try {
-    fs.unlinkSync(ACTIVE_PATH);
+    fs.unlinkSync(getActivePath());
   } catch {
     // Already gone
   }
@@ -59,6 +84,21 @@ export function updateActiveSession(patch: Partial<ActiveSessionState>): ActiveS
   return updated;
 }
 
+/** Records `recId` as the active session's live recording. */
+export function setActiveRecId(recId: string): ActiveSessionState | null {
+  return updateActiveSession({ activeRecId: recId });
+}
+
+/** Clears the active session's live-recording pointer (on `rec --stop` / stale reap). */
+export function clearActiveRecId(): ActiveSessionState | null {
+  return updateActiveSession({ activeRecId: null });
+}
+
+/** Reads the active session's live recording id, or `null` if none. */
+export function getActiveRecId(): string | null {
+  return getActiveSession()?.activeRecId ?? null;
+}
+
 function sanitizeLabel(label: string): string {
   return label
     .toLowerCase()