@enderfga/claw-orchestrator 3.7.1 → 4.0.3

package/dist/src/session-manager.js

@@ -120,7 +120,124 @@ import { ClaudeAgentDispatcher } from './autoloop/dispatcher.js';
 import { DEFAULT_PUSH_POLICY } from './autoloop/types.js';
 import { Msg as AutoloopMsg } from './autoloop/messages.js';
 import { appendPushLog, notifyUserFallbackChain } from './autoloop/notify.js';
+import { UltraappManager } from './ultraapp/manager.js';
+import { UltraappStore, defaultStoreRoot } from './ultraapp/store.js';
 import { PERSIST_DISK_TTL_MS, DEBOUNCED_SAVE_MS, CLEANUP_INTERVAL_MS, TURN_TIMEOUT_MS, GREP_HISTORY_FETCH, RESULT_TTL_MS, ULTRAPLAN_TIMEOUT_MS, ULTRAREVIEW_POLL_INTERVAL_MS, STOP_SIGKILL_DELAY_MS, SESSION_EVENT, DEFAULT_HISTORY_LIMIT, } from './constants.js';
+// ─── Disk enumeration (cross-process visibility) ────────────────────────────
+//
+// When the dashboard's standalone clawo-serve and the OpenClaw plugin run as
+// separate processes, each has its own in-memory map of active runs. To make
+// past runs visible across processes we read what's persisted on disk:
+//   - Council: transcripts at ~/.openclaw/council-logs/council-*.md
+//   - Autoloop: registry at ~/.claw-orchestrator/autoloop-registry.jsonl
+const DEFAULT_COUNCIL_LOG_DIR = path.join(os.homedir(), '.openclaw', 'council-logs');
+const DEFAULT_AUTOLOOP_REGISTRY = path.join(os.homedir(), '.claw-orchestrator', 'autoloop-registry.jsonl');
+/** Append-only registry write. Safe under concurrent writers — append is atomic for short lines. */
+export function appendAutoloopRegistry(file, entry) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, JSON.stringify(entry) + '\n');
+}
+/**
+ * Read the registry, dedup by run_id (newest entry wins), drop entries whose
+ * ledger_dir no longer exists on disk (cleanup of moved/deleted workspaces).
+ * Returns entries newest-first.
+ */
+export function listAutoloopsFromRegistry(file = DEFAULT_AUTOLOOP_REGISTRY) {
+    if (!fs.existsSync(file))
+        return [];
+    const lines = fs.readFileSync(file, 'utf-8').split('\n').filter(Boolean);
+    const seen = new Set();
+    const out = [];
+    // Walk in reverse so the latest entry for a given run_id wins.
+    for (const line of [...lines].reverse()) {
+        try {
+            const e = JSON.parse(line);
+            if (seen.has(e.run_id))
+                continue;
+            seen.add(e.run_id);
+            if (!fs.existsSync(e.ledger_dir))
+                continue; // stale entry, ledger gone
+            out.push(e);
+        }
+        catch {
+            // malformed line; skip
+        }
+    }
+    return out; // already newest-first because we reversed
+}
+/**
+ * Rewrite the registry with every line for the given run_id filtered out.
+ * Used by autoloopDelete to scrub a run from cross-process visibility.
+ * No-op if the file does not exist. Returns the number of lines removed.
+ */
+export function removeAutoloopFromRegistry(file, runId) {
+    if (!fs.existsSync(file))
+        return 0;
+    const lines = fs.readFileSync(file, 'utf-8').split('\n');
+    let removed = 0;
+    const kept = [];
+    for (const line of lines) {
+        if (!line) {
+            kept.push(line);
+            continue;
+        }
+        try {
+            const e = JSON.parse(line);
+            if (e.run_id === runId) {
+                removed += 1;
+                continue;
+            }
+        }
+        catch {
+            // malformed line — keep it, we only filter recognizable entries
+        }
+        kept.push(line);
+    }
+    if (removed === 0)
+        return 0;
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, kept.join('\n'));
+    fs.renameSync(tmp, file);
+    return removed;
+}
+/**
+ * Enumerate council sessions from on-disk transcripts. Called by
+ * SessionManager.councilList() to surface runs that the current process didn't
+ * spawn itself (e.g. runs started in another process whose transcripts have
+ * already been flushed to ~/.openclaw/council-logs/).
+ *
+ * Format parsed (matches src/council.ts saveTranscript):
+ *   - **ID**: <session.id>
+ *   - **Time**: <iso>
+ *   - **Task**: <text>
+ *   - **Status**: <consensus|max_rounds|...>
+ *
+ * Legacy transcripts written before the ID field was added fall back to a
+ * filename-derived id (basename without .md). That's stable across reruns
+ * even if uncomfortable as a display id.
+ */
+export function listCouncilsFromDisk(logDir = DEFAULT_COUNCIL_LOG_DIR) {
+    if (!fs.existsSync(logDir))
+        return [];
+    const out = [];
+    for (const entry of fs.readdirSync(logDir)) {
+        if (!entry.startsWith('council-') || !entry.endsWith('.md'))
+            continue;
+        let head;
+        try {
+            head = fs.readFileSync(path.join(logDir, entry), 'utf-8').slice(0, 2000);
+        }
+        catch {
+            continue;
+        }
+        const id = /^-\s+\*\*ID\*\*:\s*([^\n]+)/m.exec(head)?.[1]?.trim() || entry.replace(/\.md$/, '');
+        const task = /^-\s+\*\*Task\*\*:\s*([^\n]+)/m.exec(head)?.[1]?.trim() || '(no task recorded)';
+        const startTime = /^-\s+\*\*Time\*\*:\s*([^\n]+)/m.exec(head)?.[1]?.trim() || '';
+        const status = /^-\s+\*\*Status\*\*:\s*([^\n]+)/m.exec(head)?.[1]?.trim() || 'unknown';
+        out.push({ id, task, status, startTime });
+    }
+    return out;
+}
 // ─── SessionManager ──────────────────────────────────────────────────────────
 export class SessionManager {
     sessions = new Map();
@@ -135,6 +252,9 @@ export class SessionManager {
     _circuitBreaker = new CircuitBreaker();
     _inbox = new InboxManager();
     logger;
+    _ultraappManager = null;
+    _ultraappRouter = null;
+    _ultraappRuntimeMode = 'host';
     constructor(config, logger) {
         this.logger = logger || createConsoleLogger('SessionManager');
         this.pluginConfig = {
@@ -158,6 +278,48 @@ export class SessionManager {
         // Start TTL cleanup timer
         this.cleanupTimer = setInterval(() => this._cleanupIdleSessions(), CLEANUP_INTERVAL_MS);
     }
+    /**
+     * Lazily-constructed ultraapp manager. The ultraapp manager itself uses
+     * `this` as its session-manager dependency; building it lazily avoids any
+     * circular initialisation concerns.
+     */
+    getUltraappManager() {
+        if (!this._ultraappManager) {
+            this._ultraappManager = new UltraappManager({
+                store: new UltraappStore(defaultStoreRoot()),
+                sessionManager: this,
+                router: this._ultraappRouter ?? undefined,
+                runtimeMode: this._ultraappRuntimeMode,
+            });
+        }
+        return this._ultraappManager;
+    }
+    /**
+     * Inject a started UltraappRouter so deploy + lifecycle wiring becomes
+     * available. Must be called BEFORE the first `getUltraappManager()` call —
+     * the manager is constructed lazily and reads the router reference at that
+     * point. Production: bin/cli.ts wires this. Tests: leave unset to keep
+     * v0.2-style "build-complete is resting state" behaviour.
+     */
+    setUltraappRouter(router) {
+        if (this._ultraappManager) {
+            throw new Error('setUltraappRouter must be called before getUltraappManager');
+        }
+        this._ultraappRouter = router;
+    }
+    /**
+     * Pick the ultraapp runtime mode. 'host' (default) spawns the generated
+     * app as a regular Node process — works anywhere Node works, no Docker
+     * required. 'docker' uses `docker build` + `docker run` for isolation,
+     * intended for shared production hosts. Must be called before the first
+     * `getUltraappManager()` call.
+     */
+    setUltraappRuntimeMode(mode) {
+        if (this._ultraappManager) {
+            throw new Error('setUltraappRuntimeMode must be called before getUltraappManager');
+        }
+        this._ultraappRuntimeMode = mode;
+    }
     // ─── Session Lifecycle ─────────────────────────────────────────────────
     async startSession(config) {
         const name = config.name || `session-${Date.now()}`;
@@ -1040,7 +1202,51 @@ export class SessionManager {
             const dir = path.dirname(SessionManager.PID_FILE);
             if (!fs.existsSync(dir))
                 fs.mkdirSync(dir, { recursive: true });
-            fs.writeFileSync(SessionManager.PID_FILE, JSON.stringify(Object.fromEntries(this._activePids)));
+            // The PID file is host-shared: any SessionManager (gateway, dashboard,
+            // standalone test runner) writes here. We MUST NOT overwrite entries
+            // owned by another live SessionManager process — that would erase its
+            // record of pids it spawned, and its next cleanup pass might decide
+            // they're orphans and kill them. Read-merge-write keyed by ownerPid.
+            let existing = {};
+            try {
+                existing = JSON.parse(fs.readFileSync(SessionManager.PID_FILE, 'utf8'));
+            }
+            catch {
+                /* missing or malformed — start fresh */
+            }
+            const merged = {};
+            const now = new Date().toISOString();
+            // Keep entries from OTHER LIVE owners untouched. Entries whose
+            // ownerPid is a dead process are stale bookkeeping — drop them so
+            // the file doesn't grow unboundedly across server restarts. The
+            // child processes those entries used to track were already reaped
+            // by _cleanupOrphanedPids (which runs at SessionManager init,
+            // before the first save).
+            for (const [name, raw] of Object.entries(existing)) {
+                if (typeof raw === 'number')
+                    continue; // legacy format — drop on first save
+                const entry = raw;
+                if (typeof entry.pid !== 'number' || typeof entry.ownerPid !== 'number')
+                    continue;
+                if (entry.ownerPid === process.pid)
+                    continue; // ours; we're about to rewrite
+                try {
+                    process.kill(entry.ownerPid, 0);
+                }
+                catch {
+                    continue; // owner dead — stale entry, drop it
+                }
+                merged[name] = {
+                    pid: entry.pid,
+                    ownerPid: entry.ownerPid,
+                    since: entry.since ?? now,
+                };
+            }
+            // Add OUR current entries
+            for (const [name, pid] of this._activePids) {
+                merged[name] = { pid, ownerPid: process.pid, since: now };
+            }
+            fs.writeFileSync(SessionManager.PID_FILE, JSON.stringify(merged));
         }
         catch {
             /* best effort */
@@ -1077,7 +1283,49 @@ export class SessionManager {
             if (!fs.existsSync(SessionManager.PID_FILE))
                 return;
             const data = JSON.parse(fs.readFileSync(SessionManager.PID_FILE, 'utf8'));
-            for (const [name, pid] of Object.entries(data)) {
+            for (const [name, raw] of Object.entries(data)) {
+                // Resolve entry shape: legacy = number; current = { pid, ownerPid, since }.
+                let pid;
+                let ownerPid;
+                if (typeof raw === 'number') {
+                    pid = raw;
+                    ownerPid = null; // unknown owner — treat conservatively (skip kill)
+                }
+                else if (raw && typeof raw === 'object') {
+                    const e = raw;
+                    if (typeof e.pid !== 'number')
+                        continue;
+                    pid = e.pid;
+                    ownerPid = typeof e.ownerPid === 'number' ? e.ownerPid : null;
+                }
+                else {
+                    continue;
+                }
+                // Cross-process safety: if this PID has a known owner SessionManager
+                // and that owner is still alive, the child is NOT an orphan — it's
+                // owned by another live manager. Only kill if owner is dead or unknown
+                // AND the conservative legacy-format path has been ruled out.
+                if (ownerPid !== null && ownerPid !== process.pid) {
+                    let ownerAlive = false;
+                    try {
+                        process.kill(ownerPid, 0);
+                        ownerAlive = true;
+                    }
+                    catch {
+                        /* owner dead */
+                    }
+                    if (ownerAlive) {
+                        this.logger.info(`PID ${pid} (session: ${name}) owned by live SessionManager pid=${ownerPid} — skipping`);
+                        continue;
+                    }
+                }
+                else if (ownerPid === null) {
+                    // Legacy format with no owner info — too risky to kill if a host
+                    // shares the file across managers. Skip; the entry will be cleaned
+                    // up on the next save (read-merge-write drops legacy format).
+                    this.logger.info(`PID ${pid} (session: ${name}) is legacy-format (no ownerPid) — skipping kill`);
+                    continue;
+                }
                 try {
                     process.kill(pid, 0); // check if alive
                     // Alive — but verify it's actually a coding CLI, not a recycled PID
@@ -1230,11 +1478,32 @@ export class SessionManager {
         const council = this.councils.get(id);
         return council?.getSession();
     }
-    /** List all council sessions known to this manager (running, terminal, awaiting-user). */
+    /**
+     * List all council sessions visible to this process.
+     *
+     * Includes (a) in-memory sessions managed by this SessionManager and (b)
+     * sessions reconstructed from on-disk transcripts at ~/.openclaw/council-logs/.
+     * The disk path lets the dashboard see runs started in OTHER processes
+     * (e.g. plugin-managed runs visible to a standalone clawo-serve dashboard).
+     * Dedup by id; in-memory wins. Sorted by startTime descending so the newest
+     * appears at the top of the sidebar.
+     */
     councilList() {
-        return Array.from(this.councils.values())
+        const inMemory = Array.from(this.councils.values())
             .map((c) => c.getSession())
             .filter((s) => s !== null && s !== undefined);
+        const inMemIds = new Set(inMemory.map((s) => s.id));
+        const fromDisk = listCouncilsFromDisk()
+            .filter((r) => !inMemIds.has(r.id))
+            .map((r) => ({
+            id: r.id,
+            task: r.task,
+            status: r.status,
+            startTime: r.startTime,
+            responses: [],
+            config: { agents: [], maxRounds: 0, projectDir: '' },
+        }));
+        return [...inMemory, ...fromDisk].sort((a, b) => (b.startTime || '').localeCompare(a.startTime || ''));
     }
     /** Used by embedded-server to subscribe to a council's event stream. */
     getCouncil(id) {
@@ -1598,6 +1867,21 @@ export class SessionManager {
             pushPolicy,
         });
         await runner.start();
+        // Record into the cross-process registry so the dashboard / another
+        // SessionManager instance can list this run even after it ends. Best
+        // effort — registry failure should not block the run.
+        try {
+            appendAutoloopRegistry(DEFAULT_AUTOLOOP_REGISTRY, {
+                run_id: opts.runId,
+                workspace: opts.workspace,
+                ledger_dir: ledgerDir,
+                started_at: runner.state.started_at,
+                planner_session: dispatcher.sessionNames.planner,
+            });
+        }
+        catch (err) {
+            this.logger.warn?.(`[autoloop/${runId}] registry append failed: ${err.message}`);
+        }
         return {
             runId: opts.runId,
             plannerSession: dispatcher.sessionNames.planner,
@@ -1631,7 +1915,26 @@ export class SessionManager {
         return this.autoloops.get(runId)?.runner.state;
     }
     autoloopList() {
-        return Array.from(this.autoloops.values()).map((c) => c.runner.state);
+        const inMemory = Array.from(this.autoloops.values()).map((c) => c.runner.state);
+        const inMemIds = new Set(inMemory.map((s) => s.run_id));
+        const fromDisk = listAutoloopsFromRegistry()
+            .filter((e) => !inMemIds.has(e.run_id))
+            .map((e) => ({
+            run_id: e.run_id,
+            status: 'terminated',
+            iter: 0,
+            subagents_spawned: false,
+            started_at: e.started_at,
+            workspace: e.workspace,
+            ledger_dir: e.ledger_dir,
+            push_log_count: 0,
+            status_reason: 'reconstructed from registry — not in current process memory',
+            consecutive_phase_errors: 0,
+            recent_phase_errors: [],
+            metric_history: [],
+            last_activity_at: 0,
+        }));
+        return [...inMemory, ...fromDisk].sort((a, b) => (b.started_at || '').localeCompare(a.started_at || ''));
     }
     /**
      * Reset a single subagent on a v2 run. Useful when an agent has drifted
@@ -1655,6 +1958,38 @@ export class SessionManager {
         this.autoloops.delete(runId);
         return true;
     }
+    /**
+     * Delete a run from the system: stop the runner if it's still alive in this
+     * process, then scrub the row from the cross-process registry so it stops
+     * appearing in `autoloop_list` / the dashboard. The ledger directory on disk
+     * is NOT removed — postmortem artifacts (chat history, push log, plan.md)
+     * are kept for the user to inspect or `rm` manually.
+     *
+     * Returns true if anything was removed (in-memory entry OR registry row).
+     */
+    async autoloopDelete(runId) {
+        const ctx = this.autoloops.get(runId);
+        let touched = false;
+        if (ctx) {
+            try {
+                await ctx.runner.send(AutoloopMsg.terminate(ctx.runner.state.iter, { reason: 'user-delete' }));
+            }
+            catch (err) {
+                this.logger.warn?.(`[autoloop/${runId}] terminate during delete failed: ${err.message}`);
+            }
+            this.autoloops.delete(runId);
+            touched = true;
+        }
+        try {
+            const removed = removeAutoloopFromRegistry(DEFAULT_AUTOLOOP_REGISTRY, runId);
+            if (removed > 0)
+                touched = true;
+        }
+        catch (err) {
+            this.logger.warn?.(`[autoloop/${runId}] registry scrub failed: ${err.message}`);
+        }
+        return touched;
+    }
     /** Used by embedded-server to attach SSE listeners. */
     getAutoloop(runId) {
         const ctx = this.autoloops.get(runId);