@nanhara/hara 0.121.0 → 0.122.0

package/dist/serve/sessions.js

@@ -14,6 +14,25 @@ export class SessionHub {
     constructor(store = realStore) {
         this.store = store;
     }
+    /** Mutate an on-disk session under the same single-writer lock used by live sessions. The load happens
+     *  only AFTER acquisition, so a writer that finished immediately before us cannot be overwritten by a
+     *  stale pre-lock snapshot. */
+    mutateStored(id, mutate) {
+        const lock = this.store.acquire(id);
+        if (!lock.ok)
+            return false;
+        try {
+            const current = this.store.load(id);
+            if (!current)
+                return false;
+            mutate(current);
+            this.store.save(current.meta, current.history);
+            return true;
+        }
+        finally {
+            this.store.release(id);
+        }
+    }
     create(o) {
         const meta = {
             id: newSessionId(),
@@ -25,29 +44,66 @@ export class SessionHub {
             updatedAt: "",
             source: "interactive", // serve sessions are user-driven (desktop/IDE clients)
         };
-        this.store.acquire(meta.id); // fresh id — always ours; registers the single-writer claim
-        const s = { meta, history: [], provider: o.provider, approval: o.approval, autoApprove: new Set(), stats: { input: 0, output: 0 }, projectContext: o.projectContext, busy: false, abort: null };
-        this.sessions.set(meta.id, s);
-        return s;
+        const lock = this.store.acquire(meta.id); // fresh UUID, but filesystem errors must still fail closed
+        if (!lock.ok)
+            throw new Error(`could not acquire session lock for ${meta.id}${lock.pid ? ` (held by pid ${lock.pid})` : ""}`);
+        const s = { meta, history: [], provider: o.provider, approval: o.approval, autoApprove: new Set(), stats: { input: 0, output: 0 }, projectContext: o.projectContext, busy: false, configuring: false, pendingProviderTurns: 0, abort: null };
+        try {
+            this.sessions.set(meta.id, s);
+            this.store.save(meta, []); // an empty newly-created thread must survive restart and appear in lists
+            return s;
+        }
+        catch (error) {
+            this.sessions.delete(meta.id);
+            this.store.release(meta.id);
+            throw error;
+        }
     }
     /** Resume a persisted session. Returns the live session, or a lock/missing failure. */
     resume(id, o) {
         const live = this.sessions.get(id);
+        if (live?.busy || live?.configuring)
+            return { busy: true };
         if (live)
             return { session: live }; // already attached to this server
-        const prior = this.store.load(id);
-        if (!prior)
-            return { missing: true };
         const lock = this.store.acquire(id);
         if (!lock.ok)
             return { lockedBy: lock.pid ?? 0 };
-        const s = { meta: prior.meta, history: [...prior.history], provider: o.provider, approval: o.approval, autoApprove: new Set(), stats: { input: 0, output: 0 }, projectContext: o.projectContext, busy: false, abort: null };
-        this.sessions.set(id, s);
-        return { session: s };
+        let keepLock = false;
+        try {
+            const prior = this.store.load(id); // lock-before-load: this is the authoritative latest snapshot
+            if (!prior)
+                return { missing: true };
+            // Credential/provider routing is live, while the model remains the session's explicit pin.
+            prior.meta.provider = o.provider.id;
+            const s = { meta: prior.meta, history: [...prior.history], provider: o.provider, approval: o.approval, autoApprove: new Set(), stats: { input: 0, output: 0 }, projectContext: o.projectContext, busy: false, configuring: false, pendingProviderTurns: 0, abort: null, effort: prior.meta.effort };
+            this.sessions.set(id, s);
+            keepLock = true; // live session owns it until delete/releaseAll
+            return { session: s };
+        }
+        finally {
+            if (!keepLock)
+                this.store.release(id);
+        }
     }
     get(id) {
         return this.sessions.get(id);
     }
+    /** Drop an attached but idle session and release its lock without deleting persistence. This is used
+     * when resume attached successfully but live provider validation failed before the client got a handle. */
+    detach(id) {
+        const live = this.sessions.get(id);
+        if (!live || live.busy || live.configuring)
+            return false;
+        this.sessions.delete(id);
+        this.store.release(id);
+        return true;
+    }
+    /** Read model/cwd routing metadata without attaching the session. The authoritative resume still reloads
+     * after acquiring its lock; callers use this only to build the likely provider before that handoff. */
+    peekMeta(id) {
+        return this.sessions.get(id)?.meta ?? this.store.load(id)?.meta;
+    }
     list(cwd) {
         return this.store.list(cwd);
     }
@@ -64,36 +120,36 @@ export class SessionHub {
     rename(id, title) {
         const live = this.sessions.get(id);
         if (live) {
+            if (live.busy || live.configuring)
+                return false;
             live.meta.title = title;
             this.store.save(live.meta, live.history);
             return true;
         }
-        const prior = this.store.load(id);
-        if (!prior)
-            return false;
-        prior.meta.title = title;
-        this.store.save(prior.meta, prior.history);
-        return true;
+        return this.mutateStored(id, (current) => {
+            current.meta.title = title;
+        });
     }
     /** Archive/unarchive (hidden from lists, kept on disk). Returns false when unknown. */
     setArchived(id, on) {
         const live = this.sessions.get(id);
         if (live) {
+            if (live.busy || live.configuring)
+                return false;
             live.meta.archived = on;
             this.store.save(live.meta, live.history);
             return true;
         }
-        const prior = this.store.load(id);
-        if (!prior)
-            return false;
-        prior.meta.archived = on;
-        this.store.save(prior.meta, prior.history);
-        return true;
+        return this.mutateStored(id, (current) => {
+            current.meta.archived = on;
+        });
     }
     /** Fork: duplicate a session's history into a NEW session (codex thread/fork) — the non-destructive
      *  sibling of rewind. Source may be live or on-disk; the fork is always a fresh live session. */
     fork(id, o) {
         const live = this.sessions.get(id);
+        if (live?.busy || live?.configuring)
+            return { busy: true };
         const src = live ?? this.store.load(id);
         if (!src)
             return { missing: true };
@@ -106,8 +162,13 @@ export class SessionHub {
             createdAt: new Date().toISOString(),
             updatedAt: "",
             source: "interactive",
+            ...(src.meta.workingSet ? { workingSet: [...src.meta.workingSet] } : {}),
+            ...(src.meta.todos ? { todos: src.meta.todos.map((todo) => ({ ...todo, ...(todo.blockedBy ? { blockedBy: [...todo.blockedBy] } : {}) })) } : {}),
+            ...(src.meta.effort ? { effort: src.meta.effort } : {}),
         };
-        this.store.acquire(meta.id);
+        const lock = this.store.acquire(meta.id);
+        if (!lock.ok)
+            throw new Error(`could not acquire fork lock for ${meta.id}${lock.pid ? ` (held by pid ${lock.pid})` : ""}`);
         const s = {
             meta,
             history: [...src.history],
@@ -117,20 +178,30 @@ export class SessionHub {
             stats: { input: 0, output: 0 },
             projectContext: o.projectContext,
             busy: false,
+            configuring: false,
+            pendingProviderTurns: 0,
             abort: null,
+            effort: src.meta.effort,
         };
-        this.sessions.set(meta.id, s);
-        this.store.save(meta, s.history); // persist immediately — a fork should survive a crash unsent
-        return { session: s };
+        try {
+            this.sessions.set(meta.id, s);
+            this.store.save(meta, s.history); // persist immediately — a fork should survive a crash unsent
+            return { session: s };
+        }
+        catch (error) {
+            this.sessions.delete(meta.id);
+            this.store.release(meta.id);
+            throw error;
+        }
     }
     /** Permanently delete (live or on-disk). Refuses a busy live session. Returns:
      *  "gone" on success, "busy" when a turn is running, "missing" when unknown/held elsewhere. */
     delete(id) {
         const live = this.sessions.get(id);
-        if (live?.busy)
+        if (live?.busy || live?.configuring)
             return "busy";
         const ok = this.store.delete(id);
-        if (!ok && !live)
+        if (!ok)
             return "missing";
         if (live)
             this.sessions.delete(id);
@@ -143,4 +214,17 @@ export class SessionHub {
             this.store.release(id);
         this.sessions.clear();
     }
+    /** Snapshot live sessions for graceful shutdown/health handling. */
+    active() {
+        return [...this.sessions.values()];
+    }
+    /** Release only idle sessions; logical work and abandoned-but-physical provider turns retain their locks. */
+    releaseIdle() {
+        for (const [id, session] of this.sessions) {
+            if (session.busy || session.configuring || session.pendingProviderTurns > 0)
+                continue;
+            this.store.release(id);
+            this.sessions.delete(id);
+        }
+    }
 }