@someonegg/codex-hub 0.1.2 → 0.1.4

package/dist/server/server/interaction/session-runtime.js

@@ -1,5 +1,6 @@
 import { resolveResumeDirectory, } from "../management/session-manager.js";
 import { paneBindings } from "./pane-binding-manager.js";
+import { isCurrentObservation, observePaneBinding, } from "./pane-observation.js";
 /** Shared, bounded observations. Errors never prove that a pane exited. */
 export class SessionRuntime {
     transport;
@@ -43,23 +44,28 @@ export class SessionRuntime {
         void query.then(() => this.#pending.delete(key), () => this.#pending.delete(key));
         return query;
     }
-    async evaluate(session, sessions, detail = true) {
+    observe(sessionId) {
+        return observePaneBinding(sessionId, this.bindings, (attempt) => this.probe(attempt));
+    }
+    isCurrent(observation) {
+        return isCurrentObservation(observation, this.bindings);
+    }
+    async evaluate(session, sessions, detail = true, observation) {
         let status = session.archived ? "archived" : "normal";
         const deny = (reason) => ({ status, resume: { allowed: false, reason } });
         if (session.archived)
             return deny("Archived sessions cannot be resumed");
-        const attempt = this.bindings.latest(session.id);
-        if (!attempt)
+        const observed = observation ?? (await this.observe(session.id));
+        if (observed.sessionId !== session.id || !this.isCurrent(observed))
+            return deny("Pane binding changed during validation");
+        if (observed.state === "unbound")
             return deny("No pane binding has been recorded");
-        if (!attempt.valid)
+        if (observed.state === "invalid")
             return deny("The latest pane binding is invalid");
-        const replacement = this.bindings.replacement(session.id);
+        if (observed.state === "unknown")
+            return deny("Runtime or working directory validation failed");
         try {
-            const target = await this.probe(attempt);
-            if (attempt !== this.bindings.latest(session.id) ||
-                replacement !== this.bindings.replacement(session.id))
-                return deny("Pane binding changed during validation");
-            if (target && replacement === null)
+            if (observed.state === "alive" && observed.replacement === null)
                 status = "live";
             if (!detail)
                 return deny("Resume validation required");
@@ -72,8 +78,7 @@ export class SessionRuntime {
                 item.sourceId === session.sourceId).length !== 1)
                 return deny("Native session identity is ambiguous");
             await resolveResumeDirectory(manager, session);
-            if (attempt !== this.bindings.latest(session.id) ||
-                replacement !== this.bindings.replacement(session.id))
+            if (!this.isCurrent(observed))
                 return deny("Pane binding changed during validation");
             return { status, resume: { allowed: true, reason: null } };
         }

package/dist/server/server/interaction/terminal-activity-service.js

@@ -0,0 +1,82 @@
+const WINDOW_MS = 5000;
+const LEASE_MS = 60_000;
+/** Output activity is independent of terminal captures and connection health. */
+export class TerminalActivityService {
+    listen;
+    now;
+    #observations = new Map();
+    #timer;
+    #closed = false;
+    constructor(listen, now = () => performance.now()) {
+        this.listen = listen;
+        this.now = now;
+        this.#timer = setInterval(() => this.invalidate(() => true), 1000);
+        this.#timer.unref();
+    }
+    read(sessionId, binding) {
+        if (this.#closed)
+            return "unknown";
+        let observation = this.#observations.get(sessionId);
+        if (observation &&
+            (observation.failed ||
+                observation.expiresAt <= this.now() ||
+                observation.binding.socketPath !== binding.socketPath ||
+                observation.binding.paneId !== binding.paneId ||
+                observation.binding.sessionName !== binding.sessionName)) {
+            this.remove(sessionId);
+            observation = undefined;
+        }
+        if (!observation) {
+            observation = { binding, expiresAt: this.now() + LEASE_MS, failed: false };
+            this.#observations.set(sessionId, observation);
+            this.#subscribe(observation);
+        }
+        observation.expiresAt = this.now() + LEASE_MS;
+        if (observation.failed || observation.readyAt === undefined)
+            return "unknown";
+        if (observation.outputAt !== undefined && this.now() - observation.outputAt < WINDOW_MS)
+            return "working";
+        return this.now() - observation.readyAt >= WINDOW_MS ? "idle" : "unknown";
+    }
+    #subscribe(observation) {
+        const { binding } = observation;
+        const fail = () => {
+            observation.failed = true;
+            observation.readyAt = undefined;
+            observation.outputAt = undefined;
+            observation.subscription?.close();
+        };
+        try {
+            observation.subscription = this.listen(binding, (pane) => {
+                if (!observation.failed && pane === binding.paneId)
+                    observation.outputAt = this.now();
+            }, fail);
+            if (observation.failed)
+                observation.subscription.close();
+            void observation.subscription.ready.then(() => {
+                if (!observation.failed)
+                    observation.readyAt = this.now();
+            }, fail);
+        }
+        catch {
+            fail();
+        }
+    }
+    remove(sessionId) {
+        const observation = this.#observations.get(sessionId);
+        this.#observations.delete(sessionId);
+        observation?.subscription?.close();
+    }
+    invalidate(owns) {
+        for (const [id, observation] of this.#observations)
+            if (observation.expiresAt <= this.now() || !owns(id, observation.binding))
+                this.remove(id);
+    }
+    close() {
+        this.#closed = true;
+        clearInterval(this.#timer);
+        for (const id of this.#observations.keys())
+            this.remove(id);
+    }
+}
+//# sourceMappingURL=terminal-activity-service.js.map

package/dist/server/server/interaction/tmux-service.js

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { lstat } from "node:fs/promises";
 import { createConnection } from "node:net";
+import { setTimeout as delay } from "node:timers/promises";
 import { normalizeMessage } from "./message.js";
 import { InteractionTransportError, } from "./transport.js";
 export const MAX_TERMINAL_PREVIEW_BYTES = 256_000;
@@ -117,11 +118,15 @@ export class TmuxInteractionService {
             }
         });
     }
-    sendKeys(binding, keys, assertAvailable = () => { }) {
+    sendKeys(binding, steps, assertAvailable = () => { }) {
         return this.#serialize(binding, async () => {
-            await this.#revalidate(binding);
-            assertAvailable();
-            await this.#run(binding, ["send-keys", "-t", binding.paneId, ...keys]);
+            for (const step of steps) {
+                if (step.delayMs > 0)
+                    await delay(step.delayMs);
+                await this.#revalidate(binding);
+                assertAvailable();
+                await this.#run(binding, ["send-keys", "-t", binding.paneId, ...step.keys]);
+            }
         });
     }
     captureTerminal(binding, assertAvailable = () => { }) {

package/dist/server/server/management/operation-service.js

@@ -1,10 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { paneBindings } from "../interaction/pane-binding-manager.js";
 import { attachCommand } from "../interaction/tmux-launcher.js";
-import { SessionExitService } from "./session-exit-service.js";
-import { resolveResumeDirectory, SessionLaunchError, } from "./session-manager.js";
-class AssociationError extends Error {
-}
+import { AssociationError, } from "./operation-state.js";
+import { SessionLaunchExecutor } from "./session-launch-executor.js";
+import { SessionLifecycleExecutor } from "./session-lifecycle-executor.js";
+import { SessionLaunchError } from "./session-manager.js";
 export class ManagementError extends Error {
     status;
     constructor(status, message) {
@@ -13,34 +13,38 @@ export class ManagementError extends Error {
     }
 }
 export class OperationService {
-    sessions;
     interaction;
     managers;
     now;
     waitMs;
-    bindings;
-    runtime;
     #entries = new Map();
     #requests = new Map();
     #active = new Map();
     #results = new Map();
     #timer;
     #closed = false;
-    #exit;
+    #launch;
+    #lifecycle;
     constructor(sessions, interaction, managers, now = Date.now, waitMs = {
         create: 300_000,
         exit: 30_000,
         archive: 30_000,
         delete: 30_000,
     }, bindings = paneBindings, runtime) {
-        this.sessions = sessions;
         this.interaction = interaction;
         this.managers = managers;
         this.now = now;
         this.waitMs = waitMs;
-        this.bindings = bindings;
-        this.runtime = runtime;
-        this.#exit = new SessionExitService(interaction, now);
+        const control = {
+            pending: (entry) => this.#pending(entry),
+            transition: (entry, context, deadline) => this.#transition(entry, context, deadline),
+            finish: (entry, status, error) => this.#finish(entry, status, error),
+            error: (entry, error) => this.#error(entry, error),
+            timeout: (entry) => this.#timeout(entry),
+            observe: (entry) => this.#observe(entry),
+        };
+        this.#launch = new SessionLaunchExecutor(sessions, interaction, managers, bindings, control, now, waitMs, runtime);
+        this.#lifecycle = new SessionLifecycleExecutor(sessions, interaction, managers, control, now, waitMs);
         this.#timer = setInterval(() => {
             void this.poll();
         }, 1_000);
@@ -70,34 +74,7 @@ export class OperationService {
         entry.metadata.mode = "new";
         entry.sourceInstanceId = sourceInstanceId;
         this.#requests.set(input.requestId, { fingerprint, operationId: entry.metadata.operationId });
-        void (async () => {
-            try {
-                const manager = this.managers.get(entry.sourceInstanceId);
-                const resolved = await manager.resolveDirectory(input.directory);
-                if (!this.#pending(entry))
-                    return;
-                this.#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.#pending(entry))
-                    return;
-                this.#transition(entry, {
-                    kind: "create",
-                    phase: "observing",
-                    project: resolved.directory,
-                    target,
-                    startedAt: this.now(),
-                }, this.now() + this.waitMs.create);
-            }
-            catch (error) {
-                this.#error(entry, error);
-            }
-        })();
+        void this.#launch.create(entry, input);
         return this.#project(entry);
     }
     #resume(input) {
@@ -116,77 +93,7 @@ export class OperationService {
         this.#active.set(sessionId, entry);
         this.interaction.setBusy(sessionId, true);
         this.#requests.set(input.requestId, { fingerprint, operationId: entry.metadata.operationId });
-        void (async () => {
-            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.#pending(entry))
-                    return;
-                this.#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.#pending(entry))
-                    return;
-                this.#transition(entry, {
-                    kind: "create",
-                    phase: "observing",
-                    target,
-                    project: session.projectDirectory ?? resolved.directory,
-                    startedAt: this.now(),
-                }, this.now() + this.waitMs.create);
-            }
-            catch (error) {
-                this.#error(entry, error);
-            }
-        })();
+        void this.#launch.resume(entry, input);
         return this.#project(entry);
     }
     manage(type, sessionId) {
@@ -201,54 +108,7 @@ export class OperationService {
         this.interaction.setBusy(sessionId, true);
         this.#transition(entry, { kind: "manage", phase: "resolving" }, this.now() +
             (type === "exit" ? (this.waitMs.exit ?? this.waitMs.archive) : this.waitMs[type]));
-        void (async () => {
-            try {
-                const snapshot = await this.sessions.managementSnapshot();
-                if (!this.#pending(entry))
-                    return;
-                const session = snapshot.sessions.find((item) => item.id === sessionId);
-                if (!session) {
-                    if (type === "delete") {
-                        this.#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.#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.#transition(entry, { kind: "delete", phase: "deleting", nativeId });
-                    await manager.delete(nativeId);
-                    if (!this.#pending(entry))
-                        return;
-                    this.#transition(entry, { kind: "delete", phase: "confirming", nativeId });
-                }
-                else {
-                    this.#transition(entry, { kind: "archive", phase: "resolving_target", nativeId });
-                    await this.#startExit(entry, sessionId, nativeId);
-                }
-                if (this.#pending(entry))
-                    await this.#observe(entry);
-            }
-            catch (error) {
-                this.#error(entry, error);
-            }
-        })();
+        void this.#lifecycle.manage(entry, type, sessionId);
         return this.#project(entry);
     }
     async get(id) {
@@ -273,8 +133,8 @@ export class OperationService {
             }
             if ((context.kind === "create" && context.phase === "observing") ||
                 context.kind === "exiting" ||
-                (context.kind === "archive" && context.phase === "confirming") ||
-                (context.kind === "delete" && context.phase === "confirming")) {
+                ((context.kind === "archive" || context.kind === "delete") &&
+                    context.phase === "confirming")) {
                 checks.push(this.#observe(entry));
             }
         }
@@ -298,87 +158,10 @@ export class OperationService {
         if (!this.#pending(entry))
             return;
         try {
-            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.#pending(entry))
-                        return;
-                    const phase = context.task.phase;
-                    const exited = await context.task.advance();
-                    if (!this.#pending(entry))
-                        return;
-                    if (phase !== context.task.phase)
-                        entry.metadata.updatedAt = new Date(this.now()).toISOString();
-                    if (!exited)
-                        return;
-                    if (context.nativeId === null) {
-                        this.#finish(entry, "succeeded", null);
-                        return;
-                    }
-                    await this.#archive(entry, context.nativeId);
-                    if (!this.#pending(entry))
-                        return;
-                }
-                catch (error) {
-                    if (this.#pending(entry))
-                        this.#finish(entry, "unknown", error instanceof Error ? error.message : String(error));
-                    return;
-                }
-            }
-            const snapshot = await this.sessions.managementSnapshot();
-            if (!this.#pending(entry))
-                return;
-            context = entry.stage;
-            if (context.kind === "create" && context.phase === "observing") {
-                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) {
-                    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.#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.#pending(entry))
-                        return;
-                    if (!matchesTarget)
-                        throw new AssociationError("Binding does not match the launched target");
-                    entry.metadata.sessionId = match.id;
-                    this.#finish(entry, "succeeded", null);
-                }
-            }
-            else 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.#finish(entry, "succeeded", null);
-            }
+            if (entry.stage.kind === "create")
+                await this.#launch.observe(entry);
+            else
+                await this.#lifecycle.observe(entry);
         }
         catch (error) {
             // Read failures never prove disappearance or justify another command.
@@ -387,49 +170,14 @@ export class OperationService {
         }
         this.#timeout(entry);
     }
-    async #startExit(entry, sessionId, nativeId) {
-        const target = await this.interaction.resolveTarget(sessionId);
-        if (!this.#pending(entry))
-            return;
-        if (!target) {
-            if (nativeId === null)
-                this.#finish(entry, "succeeded", null);
-            else
-                await this.#archive(entry, nativeId);
-            return;
-        }
-        const task = this.#exit.start(sessionId, target, this.managers.get(entry.sourceInstanceId), () => {
-            this.#timeout(entry);
-            if (!this.#pending(entry))
-                throw new Error("Exit operation is no longer active");
-        });
-        this.#transition(entry, { kind: "exiting", task, nativeId }, this.now() + (this.waitMs.exit ?? this.waitMs.archive));
-        await this.#observe(entry);
-    }
-    async #archive(entry, nativeId) {
-        if (!this.#pending(entry))
-            return;
-        this.#transition(entry, { kind: "archive", phase: "archiving", nativeId }, this.now() + 25_000);
-        try {
-            await this.managers.get(entry.sourceInstanceId).archive(nativeId);
-            if (!this.#pending(entry))
-                return;
-            this.#transition(entry, { kind: "archive", phase: "confirming", nativeId }, this.now() + this.waitMs.archive);
-        }
-        catch (error) {
-            if (!this.#pending(entry))
-                return;
-            this.#error(entry, error);
-        }
-    }
     #transition(entry, context, deadline = entry.stage?.deadline ?? null) {
         if (!this.#pending(entry))
             return;
-        const previous = this.#project(entry).phase;
+        const previous = operationPhase(entry.stage);
         entry.stage = { ...context, deadline };
         if (context.kind === "create" && context.phase === "observing")
             entry.metadata.target = context.target;
-        if (previous !== this.#project(entry).phase)
+        if (previous !== operationPhase(entry.stage))
             entry.metadata.updatedAt = new Date(this.now()).toISOString();
     }
     #lookup(id) {
@@ -442,16 +190,7 @@ export class OperationService {
         const context = entry.stage;
         if (!context)
             throw new Error("Pending operation has no execution stage");
-        const phase = context.kind === "exiting"
-            ? context.task.phase
-            : context.kind === "archive"
-                ? context.phase === "confirming"
-                    ? "confirming_archive"
-                    : context.phase === "resolving_target"
-                        ? null
-                        : context.phase
-                : null;
-        return { ...entry.metadata, phase, status: "pending", error: null };
+        return { ...entry.metadata, phase: operationPhase(context), status: "pending", error: null };
     }
     #attach(entry, command) {
         if (!this.#pending(entry) || entry.metadata.attachCommand === command)
@@ -459,9 +198,6 @@ export class OperationService {
         entry.metadata.attachCommand = command;
         entry.metadata.updatedAt = new Date(this.now()).toISOString();
     }
-    #matches(snapshot, entry, nativeId) {
-        return snapshot.sessions.filter((session) => session.origin.sourceInstanceId === entry.sourceInstanceId && session.sourceId === nativeId);
-    }
     #pending(entry) {
         return !this.#closed && !entry.result && entry.stage !== null;
     }
@@ -550,4 +286,18 @@ export class OperationService {
         }
     }
 }
+function operationPhase(context) {
+    if (context.kind === "exiting")
+        return context.task.phase;
+    if (context.kind !== "archive")
+        return null;
+    switch (context.phase) {
+        case "confirming":
+            return "confirming_archive";
+        case "resolving_target":
+            return null;
+        case "archiving":
+            return context.phase;
+    }
+}
 //# sourceMappingURL=operation-service.js.map

package/dist/server/server/management/operation-state.js

@@ -0,0 +1,3 @@
+export class AssociationError extends Error {
+}
+//# sourceMappingURL=operation-state.js.map