@someonegg/codex-hub 0.1.1 → 0.1.3

package/dist/server/server/management/session-launch-executor.js

@@ -0,0 +1,174 @@
+import { AssociationError, } from "./operation-state.js";
+import { resolveResumeDirectory, } from "./session-manager.js";
+/** Adapter launch and association checks; OperationService owns idempotency and occupancy. */
+export class SessionLaunchExecutor {
+    sessions;
+    interaction;
+    managers;
+    bindings;
+    control;
+    now;
+    waitMs;
+    runtime;
+    constructor(sessions, interaction, managers, bindings, control, now, waitMs, runtime) {
+        this.sessions = sessions;
+        this.interaction = interaction;
+        this.managers = managers;
+        this.bindings = bindings;
+        this.control = control;
+        this.now = now;
+        this.waitMs = waitMs;
+        this.runtime = runtime;
+    }
+    async create(entry, input) {
+        try {
+            const manager = this.managers.get(entry.sourceInstanceId);
+            const resolved = await manager.resolveDirectory(input.directory);
+            if (!this.control.pending(entry))
+                return;
+            this.control.transition(entry, { kind: "create", phase: "launching" });
+            const target = await manager.launch({
+                operationId: entry.metadata.operationId,
+                directory: resolved.directory,
+                worktree: input.worktree,
+                yolo: input.yolo ?? false,
+                projectDirectory: resolved.directory,
+            });
+            if (!this.control.pending(entry))
+                return;
+            this.control.transition(entry, {
+                kind: "create",
+                phase: "observing",
+                project: resolved.directory,
+                target,
+                startedAt: this.now(),
+            }, this.now() + this.waitMs.create);
+        }
+        catch (error) {
+            this.control.error(entry, error);
+        }
+    }
+    async resume(entry, input) {
+        const sessionId = input.resumeSessionId;
+        try {
+            if (!this.runtime)
+                throw new Error("Resume is unavailable");
+            let snapshot = await this.sessions.managementSnapshot();
+            let session = snapshot.sessions.find((item) => item.id === sessionId);
+            if (!session)
+                throw new Error("Session not found");
+            let capability = await this.runtime.evaluate(session, snapshot.sessions);
+            if (!capability.resume.allowed)
+                throw new Error(capability.resume.reason);
+            entry.sourceInstanceId = session.origin.sourceInstanceId;
+            entry.resumeNativeId = session.sourceId ?? undefined;
+            const manager = this.managers.get(entry.sourceInstanceId);
+            const attempt = this.bindings.latest(session.id);
+            const replacement = this.bindings.replacement(session.id);
+            await resolveResumeDirectory(manager, session);
+            // Refresh the source after asynchronous checks, then revalidate immediately before launch.
+            snapshot = await this.sessions.managementSnapshot();
+            const latest = snapshot.sessions.find((item) => item.id === sessionId);
+            if (!latest ||
+                latest.sourceId !== session.sourceId ||
+                latest.origin.sourceInstanceId !== entry.sourceInstanceId ||
+                latest.workingDirectory !== session.workingDirectory ||
+                latest.projectDirectory !== session.projectDirectory ||
+                attempt !== this.bindings.latest(session.id) ||
+                replacement !== this.bindings.replacement(session.id))
+                throw new Error("Session identity or directory changed during validation");
+            session = latest;
+            capability = await this.runtime.evaluate(session, snapshot.sessions);
+            if (!capability.resume.allowed)
+                throw new Error(capability.resume.reason);
+            const resolved = await resolveResumeDirectory(manager, session);
+            const finalSnapshot = await this.sessions.managementSnapshot();
+            const finalSession = finalSnapshot.sessions.find((item) => item.id === sessionId);
+            if (!finalSession ||
+                finalSession.sourceId !== session.sourceId ||
+                finalSession.origin.sourceInstanceId !== session.origin.sourceInstanceId ||
+                finalSession.archived ||
+                finalSession.workingDirectory !== session.workingDirectory ||
+                finalSession.projectDirectory !== session.projectDirectory ||
+                finalSnapshot.sessions.filter((item) => item.sourceId === session.sourceId &&
+                    item.origin.sourceInstanceId === session.origin.sourceInstanceId).length !== 1 ||
+                attempt !== this.bindings.latest(session.id) ||
+                replacement !== this.bindings.replacement(session.id))
+                throw new Error("Session identity, binding or directory changed during validation");
+            if (!this.control.pending(entry))
+                return;
+            this.control.transition(entry, { kind: "create", phase: "launching" });
+            const target = await manager.launch({
+                operationId: entry.metadata.operationId,
+                directory: resolved.directory,
+                worktree: false,
+                yolo: input.yolo ?? false,
+                resumeNativeId: session.sourceId,
+                projectDirectory: session.projectDirectory,
+            });
+            if (!this.control.pending(entry))
+                return;
+            this.control.transition(entry, {
+                kind: "create",
+                phase: "observing",
+                target,
+                project: session.projectDirectory ?? resolved.directory,
+                startedAt: this.now(),
+            }, this.now() + this.waitMs.create);
+        }
+        catch (error) {
+            this.control.error(entry, error);
+        }
+    }
+    async observe(entry) {
+        const snapshot = await this.sessions.managementSnapshot();
+        if (!this.control.pending(entry))
+            return;
+        const context = entry.stage;
+        if (context.kind !== "create" || context.phase !== "observing")
+            return;
+        const matches = snapshot.sessions.filter((session) => {
+            const attempt = this.bindings.latest(session.id);
+            return (session.origin.sourceInstanceId === entry.sourceInstanceId &&
+                attempt?.valid &&
+                attempt.operationId === entry.metadata.operationId);
+        });
+        if (matches.length > 1)
+            throw new AssociationError("Multiple sessions claimed this operation ID");
+        const match = matches[0];
+        if (!match)
+            return;
+        if (entry.metadata.mode === "resume" &&
+            (match.id !== entry.metadata.sessionId ||
+                match.archived ||
+                match.sourceId !== entry.resumeNativeId ||
+                !match.sourceId ||
+                this.#matches(snapshot, entry, match.sourceId).length !== 1))
+            throw new AssociationError("Resume did not bind the original unique session");
+        const attempt = this.bindings.latest(match.id);
+        if (!attempt?.valid ||
+            attempt.socketPath !== context.target.socketPath ||
+            attempt.paneId !== context.target.paneId ||
+            match.projectDirectory !== context.project) {
+            throw new AssociationError("Binding does not match the launched target/project");
+        }
+        const binding = await this.interaction.describe(match.id);
+        if (!this.control.pending(entry))
+            return;
+        if (binding?.supported && binding.state === "unknown")
+            return;
+        if (!binding?.supported || binding.state !== "connected")
+            throw new AssociationError("The new session binding failed validation");
+        const matchesTarget = await this.interaction.matchesTarget(match.id, context.target);
+        if (!this.control.pending(entry))
+            return;
+        if (!matchesTarget)
+            throw new AssociationError("Binding does not match the launched target");
+        entry.metadata.sessionId = match.id;
+        this.control.finish(entry, "succeeded", null);
+    }
+    #matches(snapshot, entry, nativeId) {
+        return snapshot.sessions.filter((session) => session.origin.sourceInstanceId === entry.sourceInstanceId && session.sourceId === nativeId);
+    }
+}
+//# sourceMappingURL=session-launch-executor.js.map

package/dist/server/server/management/session-lifecycle-executor.js

@@ -0,0 +1,151 @@
+import { SessionExitService } from "./session-exit-service.js";
+/** Exit, archive and delete execution, including confirmation of native effects. */
+export class SessionLifecycleExecutor {
+    sessions;
+    interaction;
+    managers;
+    control;
+    now;
+    waitMs;
+    #exit;
+    constructor(sessions, interaction, managers, control, now, waitMs) {
+        this.sessions = sessions;
+        this.interaction = interaction;
+        this.managers = managers;
+        this.control = control;
+        this.now = now;
+        this.waitMs = waitMs;
+        this.#exit = new SessionExitService(interaction, now);
+    }
+    async manage(entry, type, sessionId) {
+        try {
+            const snapshot = await this.sessions.managementSnapshot();
+            if (!this.control.pending(entry))
+                return;
+            const session = snapshot.sessions.find((item) => item.id === sessionId);
+            if (!session) {
+                if (type === "delete") {
+                    this.control.finish(entry, "succeeded", null);
+                    return;
+                }
+                throw new Error("Session not found");
+            }
+            entry.sourceInstanceId = session.origin.sourceInstanceId;
+            const manager = this.managers.get(entry.sourceInstanceId);
+            if (type === "archive" && session.archived) {
+                this.control.finish(entry, "succeeded", null);
+                return;
+            }
+            if (type === "exit") {
+                await this.#startExit(entry, sessionId, null);
+                return;
+            }
+            const nativeId = session.sourceId;
+            if (!nativeId?.trim())
+                throw new Error("Session has no valid native identity");
+            if (this.#matches(snapshot, entry, nativeId).length !== 1)
+                throw new Error("Native session identity is ambiguous");
+            if (type === "delete") {
+                if (!session.archived)
+                    throw new Error("Only archived sessions can be deleted");
+                this.control.transition(entry, { kind: "delete", phase: "deleting", nativeId });
+                await manager.delete(nativeId);
+                if (!this.control.pending(entry))
+                    return;
+                this.control.transition(entry, { kind: "delete", phase: "confirming", nativeId });
+            }
+            else {
+                this.control.transition(entry, { kind: "archive", phase: "resolving_target", nativeId });
+                await this.#startExit(entry, sessionId, nativeId);
+            }
+            if (this.control.pending(entry))
+                await this.control.observe(entry);
+        }
+        catch (error) {
+            this.control.error(entry, error);
+        }
+    }
+    async observe(entry) {
+        if (!this.control.pending(entry))
+            return;
+        let context = entry.stage;
+        if (context.kind === "exiting") {
+            try {
+                // Refresh adapter bindings before observing or acting on the fixed target.
+                await this.sessions.managementSnapshot();
+                if (!this.control.pending(entry))
+                    return;
+                const phase = context.task.phase;
+                const exited = await context.task.advance();
+                if (!this.control.pending(entry))
+                    return;
+                if (phase !== context.task.phase)
+                    entry.metadata.updatedAt = new Date(this.now()).toISOString();
+                if (!exited)
+                    return;
+                if (context.nativeId === null) {
+                    this.control.finish(entry, "succeeded", null);
+                    return;
+                }
+                await this.#archive(entry, context.nativeId);
+                if (!this.control.pending(entry))
+                    return;
+            }
+            catch (error) {
+                if (this.control.pending(entry))
+                    this.control.finish(entry, "unknown", error instanceof Error ? error.message : String(error));
+                return;
+            }
+        }
+        const snapshot = await this.sessions.managementSnapshot();
+        if (!this.control.pending(entry))
+            return;
+        context = entry.stage;
+        if ((context.kind === "archive" || context.kind === "delete") &&
+            context.phase === "confirming") {
+            const matches = this.#matches(snapshot, entry, context.nativeId);
+            if ((context.kind === "archive" && matches.length === 1 && matches[0]?.archived) ||
+                (context.kind === "delete" && matches.length === 0))
+                this.control.finish(entry, "succeeded", null);
+        }
+    }
+    async #startExit(entry, sessionId, nativeId) {
+        const target = await this.interaction.resolveTarget(sessionId);
+        if (!this.control.pending(entry))
+            return;
+        if (!target) {
+            if (nativeId === null)
+                this.control.finish(entry, "succeeded", null);
+            else
+                await this.#archive(entry, nativeId);
+            return;
+        }
+        const task = this.#exit.start(sessionId, target, this.managers.get(entry.sourceInstanceId), () => {
+            this.control.timeout(entry);
+            if (!this.control.pending(entry))
+                throw new Error("Exit operation is no longer active");
+        });
+        this.control.transition(entry, { kind: "exiting", task, nativeId }, this.now() + (this.waitMs.exit ?? this.waitMs.archive));
+        await this.control.observe(entry);
+    }
+    async #archive(entry, nativeId) {
+        if (!this.control.pending(entry))
+            return;
+        this.control.transition(entry, { kind: "archive", phase: "archiving", nativeId }, this.now() + 25_000);
+        try {
+            await this.managers.get(entry.sourceInstanceId).archive(nativeId);
+            if (!this.control.pending(entry))
+                return;
+            this.control.transition(entry, { kind: "archive", phase: "confirming", nativeId }, this.now() + this.waitMs.archive);
+        }
+        catch (error) {
+            if (!this.control.pending(entry))
+                return;
+            this.control.error(entry, error);
+        }
+    }
+    #matches(snapshot, entry, nativeId) {
+        return snapshot.sessions.filter((session) => session.origin.sourceInstanceId === entry.sourceInstanceId && session.sourceId === nativeId);
+    }
+}
+//# sourceMappingURL=session-lifecycle-executor.js.map

package/dist/server/server/updates/session-updates-service.js

@@ -1,5 +1,5 @@
-import { reconcileSessionState } from "../interaction/reconcile-session-state.js";
-import { createProcessUpdateRevisionFactory, withUpdateRevision, } from "./update-revision.js";
+import { assembleSessionResponse } from "../application/session-response.js";
+import { createProcessUpdateRevisionFactory, } from "./update-revision.js";
 export const UPDATES_PROBE_INTERVAL_MS = 1_500;
 export const UPDATES_WAIT_TIMEOUT_MS = 25_000;
 export const MAX_UPDATES_WAITERS = 100;
@@ -74,18 +74,7 @@ export class SessionUpdatesService {
         if (snapshot === null) {
             throw new SessionUpdatesError("session_not_found", "Session not found");
         }
-        const interaction = await this.#describeInteraction(sessionId, snapshot.interactionSession);
-        return withUpdateRevision(reconcileSessionState({
-            session: snapshot.session,
-            cursor: snapshot.cursor,
-            hasMore: snapshot.hasMore,
-            interaction,
-        }), this.#createRevision);
-    }
-    #describeInteraction(sessionId, input) {
-        if (this.options.interaction === undefined)
-            return Promise.resolve({ supported: false, attachCommand: null });
-        return this.options.interaction.describeSnapshot(sessionId, input);
+        return assembleSessionResponse(snapshot, this.options.interaction, this.#createRevision);
     }
     #acquire(sessionId, signal) {
         this.#throwIfAborted(signal);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@someonegg/codex-hub",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Local project and session hub for Codex",
   "type": "module",
   "engines": {