opencode-muse 0.0.0-stage → 0.1.1

package/dist/session/manager.js

@@ -0,0 +1,353 @@
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import { MspHost } from "../msp/host.js";
+import { MspCommandRejectedError, MuseRecoveryChoiceRequiredError, MuseUnsupportedRequestError, RegistryWorkspaceMismatchError, } from "../errors.js";
+function canonicalWorkspacePath(directory) {
+    const absolute = resolve(directory);
+    return existsSync(absolute) ? realpathSync(absolute) : absolute;
+}
+export function workspaceFingerprint(directory) {
+    return createHash("sha256").update(canonicalWorkspacePath(directory)).digest("hex");
+}
+function sessionIdFrom(result) {
+    const session = result.session;
+    return typeof session?.sessionId === "string" ? session.sessionId : undefined;
+}
+function cursorFrom(result) {
+    return typeof result.viewCursor === "string" ? result.viewCursor : undefined;
+}
+function modelSelection(context) {
+    return {
+        providerId: context.museSelection.providerId,
+        modelId: context.museSelection.modelId,
+        profileId: context.museSelection.profileId,
+    };
+}
+function selectionMatches(entry, selected) {
+    return entry.providerId === selected.providerId
+        && entry.modelId === selected.modelId
+        && (entry.profileId ?? null) === selected.profileId;
+}
+export class MuseSessionManager {
+    options;
+    bindings = new Map();
+    contextBySession = new Map();
+    createHost;
+    closed = false;
+    constructor(options) {
+        this.options = options;
+        this.createHost = options.createHost ?? (async ({ museBin, cwd, args, capabilities }) => MspHost.start({
+            museBin,
+            cwd,
+            args,
+            capabilities,
+            startupTimeoutMs: 20_000,
+            commandTimeoutMs: 30_000,
+            requestTimeoutMs: 20_000,
+        }));
+    }
+    setContextForSession(openCodeSessionId, context) {
+        this.contextBySession.set(openCodeSessionId, {
+            supported: context.supported,
+            fragments: context.fragments.map((fragment) => ({ ...fragment })),
+        });
+        const binding = this.bindings.get(openCodeSessionId);
+        if (binding) {
+            binding.contextAllowlist = context.supported ? context.fragments.map((fragment) => ({ ...fragment })) : [];
+            binding.contextError = context.supported ? undefined : "agent-instructions-unrepresentable";
+        }
+    }
+    async resolveSession(context) {
+        if (this.closed)
+            throw new MuseUnsupportedRequestError("plugin-closed");
+        if (context.kind !== "primary")
+            throw new MuseUnsupportedRequestError(context.kind);
+        const canonicalDirectory = canonicalWorkspacePath(context.directory);
+        const fingerprint = workspaceFingerprint(canonicalDirectory);
+        const selected = modelSelection(context);
+        const existingBinding = this.bindings.get(context.sessionID);
+        if (existingBinding && existingBinding.workspaceFingerprint !== fingerprint) {
+            throw new RegistryWorkspaceMismatchError();
+        }
+        const lease = await this.options.workspaceLock.acquire(fingerprint, context.sessionID);
+        let host;
+        try {
+            const stored = await this.options.registry.get(context.sessionID, fingerprint);
+            if (stored && (Object.keys(stored.pendingCommands).length > 0 || stored.activeTurnId !== undefined)) {
+                throw new MuseRecoveryChoiceRequiredError();
+            }
+            if (existingBinding) {
+                existingBinding.lease = lease;
+                try {
+                    await this.applySelectionIfChanged(existingBinding, selected);
+                    await this.persistBinding(context.sessionID, existingBinding);
+                }
+                catch (error) {
+                    existingBinding.lease = undefined;
+                    await lease.release();
+                    throw error;
+                }
+                return existingBinding;
+            }
+            host = await this.createHost({
+                museBin: this.options.museBin,
+                cwd: canonicalDirectory,
+                args: ["serve", "--provider", stored?.providerId ?? selected.providerId],
+                capabilities: { userInputDialogs: false },
+            });
+            const durability = host.initializeResult.sessionDurability;
+            if (stored && durability === "ephemeral")
+                throw new MuseRecoveryChoiceRequiredError();
+            let museSessionId;
+            let viewCursor;
+            let replayAfterCursor;
+            if (stored && durability !== "ephemeral") {
+                const resumed = await host.command("session/resume", {
+                    commandId: host.mintCommandId(),
+                    sessionId: stored.museSessionId,
+                    ...(stored.viewCursor ? { cursor: stored.viewCursor } : {}),
+                });
+                const resumedSession = resumed.session;
+                if (!resumedSession || !Object.hasOwn(resumedSession, "activeTurnId") || resumedSession.activeTurnId !== null) {
+                    throw new MuseRecoveryChoiceRequiredError();
+                }
+                museSessionId = sessionIdFrom(resumed) ?? stored.museSessionId;
+                viewCursor = cursorFrom(resumed);
+                // session/resume attaches at its returned head; avoid a redundant
+                // view/subscribe at that same cursor. Task 12 owns older-cursor replay.
+            }
+            else {
+                const start = await host.command("session/start", {
+                    commandId: host.mintCommandId(),
+                    workspaceRoot: canonicalDirectory,
+                    providerId: selected.providerId,
+                    modelId: selected.modelId,
+                });
+                const startedSessionId = sessionIdFrom(start);
+                if (!startedSessionId)
+                    throw new MuseRecoveryChoiceRequiredError();
+                museSessionId = startedSessionId;
+                viewCursor = cursorFrom(start);
+            }
+            const initialSelection = stored
+                ? { providerId: stored.providerId ?? selected.providerId, modelId: stored.modelId ?? selected.modelId, profileId: stored.profileId ?? null }
+                : { providerId: selected.providerId, modelId: selected.modelId, profileId: null };
+            const sessionContext = this.contextBySession.get(context.sessionID);
+            const binding = {
+                host,
+                sessionId: museSessionId,
+                museSessionId,
+                hostId: randomUUID(),
+                workspaceFingerprint: fingerprint,
+                viewCursor,
+                replayAfterCursor,
+                currentSelection: initialSelection,
+                previousTranscriptFingerprints: stored?.transcriptFingerprints ?? [],
+                transcriptFingerprints: stored?.transcriptFingerprints ?? [],
+                compactionFingerprints: stored?.compactionFingerprints ?? [],
+                pendingCommands: stored?.pendingCommands ?? {},
+                contextAllowlist: sessionContext?.supported ? sessionContext.fragments.map((fragment) => ({ ...fragment })) : [],
+                contextError: sessionContext?.supported ? undefined : "agent-instructions-unrepresentable",
+                lease,
+                async recordPendingCommand(input) {
+                    binding.pendingCommands[input.commandId] = { method: input.method, fingerprint: input.fingerprint };
+                    await managerOptions.registry.recordPendingCommand(context.sessionID, fingerprint, input);
+                },
+                async clearPendingCommand(commandId) {
+                    await managerOptions.registry.clearPendingCommand(context.sessionID, fingerprint, commandId);
+                    delete binding.pendingCommands[commandId];
+                },
+                async recordTurnAccepted(_commandId, turnId) {
+                    const previous = binding.activeTurnId;
+                    binding.activeTurnId = turnId;
+                    try {
+                        await persist();
+                    }
+                    catch (error) {
+                        binding.activeTurnId = previous;
+                        throw error;
+                    }
+                },
+                async updateCursor(cursor) {
+                    const previous = binding.viewCursor;
+                    binding.viewCursor = cursor;
+                    try {
+                        await managerOptions.registry.updateCursor(context.sessionID, fingerprint, cursor);
+                    }
+                    catch {
+                        // Retaining the older durable cursor is safe: the next resume will
+                        // replay this suffix. Do not abandon an active turn because a
+                        // per-event cursor write temporarily failed.
+                        binding.viewCursor = previous;
+                    }
+                },
+                async recordTurnCompleted(_turnId, _terminal) {
+                    const previousActive = binding.activeTurnId;
+                    const previousPending = binding.pendingCommands;
+                    binding.activeTurnId = undefined;
+                    binding.replayAfterCursor = undefined;
+                    binding.pendingCommands = {};
+                    try {
+                        await persist();
+                    }
+                    catch (error) {
+                        binding.activeTurnId = previousActive;
+                        binding.pendingCommands = previousPending;
+                        throw error;
+                    }
+                },
+                async release() {
+                    const currentLease = binding.lease;
+                    binding.lease = undefined;
+                    await currentLease?.release();
+                },
+                async commitTranscriptFingerprints(fingerprints) {
+                    const previousTranscript = binding.transcriptFingerprints;
+                    const previousFingerprints = binding.previousTranscriptFingerprints;
+                    const previousCompactions = binding.compactionFingerprints;
+                    binding.transcriptFingerprints = [...fingerprints];
+                    binding.previousTranscriptFingerprints = [...fingerprints];
+                    binding.compactionFingerprints = [];
+                    try {
+                        await persist();
+                    }
+                    catch (error) {
+                        binding.transcriptFingerprints = [...previousTranscript];
+                        binding.previousTranscriptFingerprints = [...previousFingerprints];
+                        binding.compactionFingerprints = [...previousCompactions];
+                        throw error;
+                    }
+                },
+            };
+            const managerOptions = this.options;
+            const persist = async () => {
+                await this.persistBinding(context.sessionID, binding);
+            };
+            this.bindingSessionIDs.set(binding, context.sessionID);
+            this.bindings.set(context.sessionID, binding);
+            await persist();
+            await this.applySelectionIfChanged(binding, selected, stored);
+            await persist();
+            return binding;
+        }
+        catch (error) {
+            await lease.release();
+            if (host)
+                await host.close().catch(() => { });
+            throw error;
+        }
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        const bindings = [...this.bindings.values()];
+        this.bindings.clear();
+        await Promise.all(bindings.map(async (binding) => {
+            try {
+                await binding.host.close?.();
+            }
+            catch {
+                // The diagnostic may include CLI stderr; shutdown must still release
+                // the local lease once the owned process has been asked to stop.
+            }
+            finally {
+                await binding.release?.().catch(() => { });
+            }
+        }));
+    }
+    async recordCompactionCandidate(openCodeSessionId, fingerprint) {
+        const binding = this.bindings.get(openCodeSessionId);
+        if (binding) {
+            const lease = await this.options.workspaceLock.acquire(binding.workspaceFingerprint, openCodeSessionId);
+            try {
+                binding.compactionFingerprints = [fingerprint];
+                await this.persistBinding(openCodeSessionId, binding);
+            }
+            finally {
+                await lease.release();
+            }
+            return;
+        }
+        const stored = await this.options.registry.getForOpenCodeSession(openCodeSessionId);
+        if (!stored)
+            return;
+        const lease = await this.options.workspaceLock.acquire(stored.workspaceFingerprint, openCodeSessionId);
+        try {
+            await this.options.registry.recordCompactionCandidate(openCodeSessionId, fingerprint);
+        }
+        finally {
+            await lease.release();
+        }
+    }
+    async applySelectionIfChanged(binding, selected, stored) {
+        const currentMatches = stored
+            ? selectionMatches(stored, selected)
+            : binding.currentSelection.providerId === selected.providerId
+                && binding.currentSelection.modelId === selected.modelId
+                && binding.currentSelection.profileId === selected.profileId;
+        if (currentMatches) {
+            binding.currentSelection = selected;
+            return;
+        }
+        const commandId = binding.host.mintCommandId();
+        const method = "session/setModel";
+        const params = {
+            commandId,
+            sessionId: binding.sessionId,
+            model: selected,
+        };
+        const commandFingerprint = createHash("sha256").update(JSON.stringify({ method, params })).digest("hex");
+        const openCodeSessionId = this.openCodeSessionIdFor(binding);
+        const pending = { method, fingerprint: commandFingerprint };
+        binding.pendingCommands[commandId] = pending;
+        try {
+            await this.options.registry.recordPendingCommand(openCodeSessionId, binding.workspaceFingerprint, {
+                commandId,
+                ...pending,
+            });
+        }
+        catch (error) {
+            delete binding.pendingCommands[commandId];
+            throw error;
+        }
+        try {
+            await binding.host.command(method, params);
+        }
+        catch (error) {
+            if (error instanceof MspCommandRejectedError) {
+                await this.options.registry.clearPendingCommand(openCodeSessionId, binding.workspaceFingerprint, commandId);
+                delete binding.pendingCommands[commandId];
+            }
+            throw error;
+        }
+        await this.options.registry.clearPendingCommand(openCodeSessionId, binding.workspaceFingerprint, commandId);
+        delete binding.pendingCommands[commandId];
+        binding.currentSelection = selected;
+        await this.persistBinding(openCodeSessionId, binding);
+    }
+    bindingSessionIDs = new WeakMap();
+    openCodeSessionIdFor(binding) {
+        const sessionId = this.bindingSessionIDs.get(binding);
+        if (!sessionId)
+            throw new MuseRecoveryChoiceRequiredError();
+        return sessionId;
+    }
+    async persistBinding(openCodeSessionId, binding) {
+        await this.options.registry.put({
+            openCodeSessionId,
+            museSessionId: binding.museSessionId,
+            hostId: binding.hostId,
+            workspaceFingerprint: binding.workspaceFingerprint,
+            providerId: binding.currentSelection.providerId,
+            ...(binding.currentSelection.profileId !== null ? { profileId: binding.currentSelection.profileId } : {}),
+            modelId: binding.currentSelection.modelId,
+            ...(binding.viewCursor ? { viewCursor: binding.viewCursor } : {}),
+            ...(binding.activeTurnId ? { activeTurnId: binding.activeTurnId } : {}),
+            transcriptFingerprints: binding.transcriptFingerprints,
+            compactionFingerprints: binding.compactionFingerprints,
+            pendingCommands: binding.pendingCommands,
+        });
+    }
+}

package/dist/session/registry.d.ts

@@ -0,0 +1,55 @@
+export interface PendingCommandRecord {
+    method: string;
+    fingerprint: string;
+}
+export interface SessionRegistryEntry {
+    openCodeSessionId: string;
+    museSessionId: string;
+    hostId: string;
+    workspaceFingerprint: string;
+    providerId?: string;
+    modelId?: string;
+    profileId?: string;
+    viewCursor?: string;
+    activeTurnId?: string;
+    transcriptFingerprints: string[];
+    compactionFingerprints: string[];
+    pendingCommands: Record<string, PendingCommandRecord>;
+    updatedAt: number;
+}
+export type SessionRegistryEntryInput = Omit<SessionRegistryEntry, "updatedAt">;
+export interface ResolveStateDirectoryOptions {
+    env?: NodeJS.ProcessEnv;
+    homeDirectory?: string;
+    platform?: NodeJS.Platform | "win32";
+}
+export interface SessionRegistryOptions extends ResolveStateDirectoryOptions {
+    stateDirectory?: string;
+    now?: () => number;
+}
+/** Refuse a caller-selected state root inside Muse's CLI-owned config directory. */
+export declare function assertSafeStateDirectory(path: string, options?: ResolveStateDirectoryOptions): string;
+export declare class SessionRegistry {
+    private readonly directory;
+    private readonly now;
+    constructor(options?: SessionRegistryOptions);
+    static resolveStateDirectory(options?: ResolveStateDirectoryOptions): string;
+    get(openCodeSessionId: string, workspaceFingerprint: string): Promise<SessionRegistryEntry | undefined>;
+    getForOpenCodeSession(openCodeSessionId: string): Promise<SessionRegistryEntry | undefined>;
+    recordCompactionCandidate(openCodeSessionId: string, fingerprint: string): Promise<void>;
+    clearCompactionCandidate(openCodeSessionId: string, fingerprint: string): Promise<void>;
+    private readEntry;
+    put(input: SessionRegistryEntryInput): Promise<SessionRegistryEntry>;
+    updateCursor(openCodeSessionId: string, workspaceFingerprint: string, viewCursor: string): Promise<void>;
+    recordPendingCommand(openCodeSessionId: string, workspaceFingerprint: string, pending: {
+        commandId: string;
+        method: string;
+        fingerprint: string;
+    }): Promise<void>;
+    clearPendingCommand(openCodeSessionId: string, workspaceFingerprint: string, commandId: string): Promise<void>;
+    private requireEntry;
+    private assertLookup;
+    private entryPath;
+    private write;
+    private quarantine;
+}