opencode-muse 0.0.0-stage → 0.1.0

package/dist/session/registry.js

@@ -0,0 +1,330 @@
+import { createHash, randomUUID } from "node:crypto";
+import { closeSync, chmodSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve, sep, win32 } from "node:path";
+import { RegistryCorruptError, RegistryStorageError, RegistryValidationError, RegistryWorkspaceMismatchError, } from "../errors.js";
+const REGISTRY_VERSION = 1;
+const MAX_ENTRY_BYTES = 1_048_576;
+const HASH_PATTERN = /^[a-f0-9]{64}$/;
+const UUID_V7_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-7[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/;
+const IDENTIFIER_PATTERN = /^[A-Za-z0-9._:@+_-]{1,512}$/;
+const METHOD_PATTERN = /^[a-z][A-Za-z0-9]*(?:\/[A-Za-z][A-Za-z0-9]*)+$/;
+/** Refuse a caller-selected state root inside Muse's CLI-owned config directory. */
+export function assertSafeStateDirectory(path, options = {}) {
+    const env = options.env ?? process.env;
+    const homeDirectory = options.homeDirectory ?? homedir();
+    const platform = options.platform ?? process.platform;
+    const windows = platform === "win32";
+    const pathJoin = windows ? win32.join : join;
+    const pathResolve = windows ? win32.resolve : resolve;
+    const pathRelative = windows ? win32.relative : relative;
+    const pathSeparator = windows ? win32.sep : sep;
+    const pathIsAbsolute = windows ? win32.isAbsolute : isAbsolute;
+    const configuredHome = env.XDG_CONFIG_HOME;
+    const configHome = requiredString(configuredHome) && pathIsAbsolute(configuredHome)
+        ? configuredHome
+        : pathJoin(homeDirectory, ".config");
+    const museConfigDirectory = pathResolve(pathJoin(configHome, "muse"));
+    const relativePath = pathRelative(museConfigDirectory, pathResolve(path));
+    const outsideMuseConfig = relativePath === ".."
+        || relativePath.startsWith(`..${pathSeparator}`)
+        || pathIsAbsolute(relativePath);
+    if (!outsideMuseConfig)
+        throw new RegistryValidationError();
+    return path;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertOnlyKeys(value, allowed) {
+    if (Object.keys(value).some((key) => !allowed.includes(key)))
+        throw new RegistryValidationError();
+}
+function requiredString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function validHashList(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string" && HASH_PATTERN.test(item));
+}
+function normalizeEntry(input, now) {
+    if (!isRecord(input))
+        throw new RegistryValidationError();
+    assertOnlyKeys(input, [
+        "openCodeSessionId", "museSessionId", "hostId", "workspaceFingerprint", "providerId", "modelId", "profileId",
+        "viewCursor", "activeTurnId", "transcriptFingerprints", "compactionFingerprints", "pendingCommands", "updatedAt",
+    ]);
+    if (typeof input.openCodeSessionId !== "string"
+        || !IDENTIFIER_PATTERN.test(input.openCodeSessionId)
+        || typeof input.museSessionId !== "string"
+        || !IDENTIFIER_PATTERN.test(input.museSessionId)
+        || typeof input.hostId !== "string"
+        || !IDENTIFIER_PATTERN.test(input.hostId)
+        || typeof input.workspaceFingerprint !== "string"
+        || !HASH_PATTERN.test(input.workspaceFingerprint)
+        || !validHashList(input.transcriptFingerprints)
+        || !validHashList(input.compactionFingerprints)
+        || !isRecord(input.pendingCommands))
+        throw new RegistryValidationError();
+    for (const optional of ["providerId", "modelId", "profileId", "viewCursor", "activeTurnId"]) {
+        if (input[optional] !== undefined && !requiredString(input[optional]))
+            throw new RegistryValidationError();
+    }
+    if (input.updatedAt !== undefined && (typeof input.updatedAt !== "number" || !Number.isFinite(input.updatedAt))) {
+        throw new RegistryValidationError();
+    }
+    const pendingCommands = Object.create(null);
+    for (const [commandId, raw] of Object.entries(input.pendingCommands)) {
+        if (!UUID_V7_PATTERN.test(commandId) || !isRecord(raw))
+            throw new RegistryValidationError();
+        assertOnlyKeys(raw, ["method", "fingerprint"]);
+        if (typeof raw.method !== "string" || !METHOD_PATTERN.test(raw.method)
+            || typeof raw.fingerprint !== "string" || !HASH_PATTERN.test(raw.fingerprint)) {
+            throw new RegistryValidationError();
+        }
+        pendingCommands[commandId] = { method: raw.method, fingerprint: raw.fingerprint };
+    }
+    return {
+        openCodeSessionId: input.openCodeSessionId,
+        museSessionId: input.museSessionId,
+        hostId: input.hostId,
+        workspaceFingerprint: input.workspaceFingerprint,
+        ...(input.providerId !== undefined ? { providerId: input.providerId } : {}),
+        ...(input.modelId !== undefined ? { modelId: input.modelId } : {}),
+        ...(input.profileId !== undefined ? { profileId: input.profileId } : {}),
+        ...(input.viewCursor !== undefined ? { viewCursor: input.viewCursor } : {}),
+        ...(input.activeTurnId !== undefined ? { activeTurnId: input.activeTurnId } : {}),
+        transcriptFingerprints: [...input.transcriptFingerprints],
+        compactionFingerprints: [...input.compactionFingerprints],
+        pendingCommands,
+        updatedAt: input.updatedAt ?? now(),
+    };
+}
+function sessionFileName(openCodeSessionId) {
+    return `${createHash("sha256").update(openCodeSessionId).digest("hex")}.json`;
+}
+function ensurePrivateDirectory(path) {
+    mkdirSync(path, { recursive: true, mode: 0o700 });
+    chmodSync(path, 0o700);
+}
+function syncDirectory(path) {
+    let descriptor;
+    try {
+        descriptor = openSync(path, "r");
+        fsyncSync(descriptor);
+    }
+    catch {
+        // Some platforms do not permit fsync on a directory handle.
+    }
+    finally {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
+    }
+}
+export class SessionRegistry {
+    directory;
+    now;
+    constructor(options = {}) {
+        const stateDirectory = assertSafeStateDirectory(options.stateDirectory ?? SessionRegistry.resolveStateDirectory(options), options);
+        this.directory = join(stateDirectory, "sessions");
+        this.now = options.now ?? Date.now;
+    }
+    static resolveStateDirectory(options = {}) {
+        const env = options.env ?? process.env;
+        const homeDirectory = options.homeDirectory ?? homedir();
+        const platform = options.platform ?? process.platform;
+        let stateDirectory;
+        if (platform === "win32") {
+            const base = env.LOCALAPPDATA;
+            stateDirectory = joinWin32(requiredString(base) && win32.isAbsolute(base) ? base : win32.join(homeDirectory, "AppData", "Local"), "opencode-muse");
+        }
+        else {
+            const dataHome = env.XDG_DATA_HOME;
+            const base = requiredString(dataHome) && isAbsolute(dataHome) ? dataHome : join(homeDirectory, ".local", "share");
+            stateDirectory = join(base, "opencode-muse");
+        }
+        return assertSafeStateDirectory(stateDirectory, options);
+    }
+    async get(openCodeSessionId, workspaceFingerprint) {
+        this.assertLookup(openCodeSessionId, workspaceFingerprint);
+        const entry = await this.readEntry(openCodeSessionId);
+        if (entry && entry.workspaceFingerprint !== workspaceFingerprint)
+            throw new RegistryWorkspaceMismatchError();
+        return entry;
+    }
+    async getForOpenCodeSession(openCodeSessionId) {
+        if (!IDENTIFIER_PATTERN.test(openCodeSessionId))
+            throw new RegistryValidationError();
+        return this.readEntry(openCodeSessionId);
+    }
+    async recordCompactionCandidate(openCodeSessionId, fingerprint) {
+        if (!IDENTIFIER_PATTERN.test(openCodeSessionId) || !HASH_PATTERN.test(fingerprint))
+            throw new RegistryValidationError();
+        const entry = await this.readEntry(openCodeSessionId);
+        if (!entry)
+            return;
+        this.write({ ...entry, compactionFingerprints: [fingerprint], updatedAt: this.now() });
+    }
+    async clearCompactionCandidate(openCodeSessionId, fingerprint) {
+        if (!IDENTIFIER_PATTERN.test(openCodeSessionId) || !HASH_PATTERN.test(fingerprint))
+            throw new RegistryValidationError();
+        const entry = await this.readEntry(openCodeSessionId);
+        if (!entry || !entry.compactionFingerprints.includes(fingerprint))
+            return;
+        this.write({
+            ...entry,
+            compactionFingerprints: entry.compactionFingerprints.filter((candidate) => candidate !== fingerprint),
+            updatedAt: this.now(),
+        });
+    }
+    async readEntry(openCodeSessionId) {
+        const path = this.entryPath(openCodeSessionId);
+        if (!existsSync(path))
+            return undefined;
+        let stat;
+        try {
+            stat = statSync(path);
+        }
+        catch (error) {
+            if (isMissingFile(error))
+                return undefined;
+            throw new RegistryStorageError();
+        }
+        if (stat.size > MAX_ENTRY_BYTES)
+            return this.quarantine(path);
+        let contents;
+        try {
+            contents = readFileSync(path, "utf8");
+        }
+        catch (error) {
+            if (isMissingFile(error))
+                return undefined;
+            throw new RegistryStorageError();
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(contents);
+        }
+        catch {
+            return this.quarantine(path);
+        }
+        try {
+            if (!isRecord(parsed))
+                throw new RegistryValidationError();
+            assertOnlyKeys(parsed, ["version", "entry"]);
+            if (parsed.version !== REGISTRY_VERSION)
+                throw new RegistryValidationError();
+            if (!isRecord(parsed.entry) || typeof parsed.entry.updatedAt !== "number" || !Number.isFinite(parsed.entry.updatedAt)) {
+                throw new RegistryValidationError();
+            }
+            const entry = normalizeEntry(parsed.entry, this.now);
+            if (entry.openCodeSessionId !== openCodeSessionId)
+                throw new RegistryValidationError();
+            return entry;
+        }
+        catch (error) {
+            return this.quarantine(path);
+        }
+    }
+    async put(input) {
+        if (isRecord(input) && Object.hasOwn(input, "updatedAt"))
+            throw new RegistryValidationError();
+        const entry = normalizeEntry(input, this.now);
+        const previous = await this.get(entry.openCodeSessionId, entry.workspaceFingerprint);
+        if (previous && previous.workspaceFingerprint !== entry.workspaceFingerprint) {
+            throw new RegistryWorkspaceMismatchError();
+        }
+        this.write(entry);
+        return entry;
+    }
+    async updateCursor(openCodeSessionId, workspaceFingerprint, viewCursor) {
+        if (!requiredString(viewCursor))
+            throw new RegistryValidationError();
+        const entry = await this.requireEntry(openCodeSessionId, workspaceFingerprint);
+        this.write({ ...entry, viewCursor, updatedAt: this.now() });
+    }
+    async recordPendingCommand(openCodeSessionId, workspaceFingerprint, pending) {
+        if (!UUID_V7_PATTERN.test(pending.commandId) || !METHOD_PATTERN.test(pending.method) || !HASH_PATTERN.test(pending.fingerprint)) {
+            throw new RegistryValidationError();
+        }
+        const entry = await this.requireEntry(openCodeSessionId, workspaceFingerprint);
+        this.write({
+            ...entry,
+            pendingCommands: { ...entry.pendingCommands, [pending.commandId]: { method: pending.method, fingerprint: pending.fingerprint } },
+            updatedAt: this.now(),
+        });
+    }
+    async clearPendingCommand(openCodeSessionId, workspaceFingerprint, commandId) {
+        const entry = await this.requireEntry(openCodeSessionId, workspaceFingerprint);
+        if (!(commandId in entry.pendingCommands))
+            return;
+        const pendingCommands = { ...entry.pendingCommands };
+        delete pendingCommands[commandId];
+        this.write({ ...entry, pendingCommands, updatedAt: this.now() });
+    }
+    async requireEntry(openCodeSessionId, workspaceFingerprint) {
+        const entry = await this.get(openCodeSessionId, workspaceFingerprint);
+        if (!entry)
+            throw new RegistryValidationError();
+        return entry;
+    }
+    assertLookup(openCodeSessionId, workspaceFingerprint) {
+        if (!requiredString(openCodeSessionId) || !HASH_PATTERN.test(workspaceFingerprint))
+            throw new RegistryValidationError();
+    }
+    entryPath(openCodeSessionId) {
+        return join(this.directory, sessionFileName(openCodeSessionId));
+    }
+    write(entry) {
+        try {
+            ensurePrivateDirectory(dirname(this.directory));
+            ensurePrivateDirectory(this.directory);
+        }
+        catch {
+            throw new RegistryStorageError();
+        }
+        const path = this.entryPath(entry.openCodeSessionId);
+        const temporary = `${path}.${randomUUID()}.tmp`;
+        let descriptor;
+        try {
+            descriptor = openSync(temporary, "wx", 0o600);
+            writeFileSync(descriptor, `${JSON.stringify({ version: REGISTRY_VERSION, entry })}\n`, "utf8");
+            fsyncSync(descriptor);
+            closeSync(descriptor);
+            descriptor = undefined;
+            renameSync(temporary, path);
+            chmodSync(path, 0o600);
+            syncDirectory(this.directory);
+        }
+        catch {
+            if (descriptor !== undefined) {
+                try {
+                    closeSync(descriptor);
+                }
+                catch { /* preserve the original storage failure */ }
+            }
+            try {
+                unlinkSync(temporary);
+            }
+            catch { /* best-effort temp cleanup */ }
+            throw new RegistryStorageError();
+        }
+    }
+    quarantine(path) {
+        try {
+            const quarantinePath = `${path}.corrupt-${this.now()}-${randomUUID()}`;
+            renameSync(path, quarantinePath);
+            chmodSync(quarantinePath, 0o600);
+            syncDirectory(this.directory);
+        }
+        catch {
+            throw new RegistryCorruptError();
+        }
+        return undefined;
+    }
+}
+function joinWin32(base, child) {
+    return win32.join(base, child);
+}
+function isMissingFile(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}

package/dist/session/workspace-lock.d.ts

@@ -0,0 +1,26 @@
+import { type ResolveStateDirectoryOptions } from "./registry.js";
+export interface WorkspaceLockOptions extends ResolveStateDirectoryOptions {
+    stateDirectory?: string;
+    isProcessAlive?: (pid: number) => boolean;
+    now?: () => number;
+    ownerToken?: () => string;
+}
+export interface LockLease {
+    readonly workspaceFingerprint: string;
+    readonly openCodeSessionId: string;
+    release(): Promise<void>;
+}
+export declare class WorkspaceLock {
+    private readonly directory;
+    private readonly isProcessAlive;
+    private readonly now;
+    private readonly createOwnerToken;
+    constructor(options?: WorkspaceLockOptions);
+    acquire(workspaceFingerprint: string, openCodeSessionId: string): Promise<LockLease>;
+    private create;
+    private read;
+    /** Synchronous recheck narrows the stale-owner race before reclaiming its lock. */
+    private removeIfUnchanged;
+    private readRecoveryClaim;
+    private lease;
+}

package/dist/session/workspace-lock.js

@@ -0,0 +1,288 @@
+import { randomUUID } from "node:crypto";
+import { closeSync, chmodSync, existsSync, fsyncSync, linkSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { WorkspaceBusyError, WorkspaceLockCorruptError, RegistryValidationError, } from "../errors.js";
+import { assertSafeStateDirectory, SessionRegistry } from "./registry.js";
+const HASH_PATTERN = /^[a-f0-9]{64}$/;
+const IDENTIFIER_PATTERN = /^[A-Za-z0-9._:@+_-]{1,512}$/;
+const LOCK_VERSION = 1;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function decodeLock(value, workspaceFingerprint) {
+    if (!isRecord(value)
+        || value.version !== LOCK_VERSION
+        || value.workspaceFingerprint !== workspaceFingerprint
+        || typeof value.openCodeSessionId !== "string"
+        || !IDENTIFIER_PATTERN.test(value.openCodeSessionId)
+        || typeof value.ownerToken !== "string"
+        || value.ownerToken.length === 0
+        || typeof value.pid !== "number"
+        || !Number.isInteger(value.pid)
+        || value.pid <= 0
+        || typeof value.acquiredAt !== "number"
+        || !Number.isFinite(value.acquiredAt)
+        || Object.keys(value).some((key) => !["version", "workspaceFingerprint", "openCodeSessionId", "ownerToken", "pid", "acquiredAt"].includes(key))) {
+        throw new WorkspaceLockCorruptError();
+    }
+    return value;
+}
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        return code === "EPERM" || code !== "ESRCH";
+    }
+}
+function ensurePrivateDirectory(path) {
+    mkdirSync(path, { recursive: true, mode: 0o700 });
+    chmodSync(path, 0o700);
+}
+function syncDirectory(path) {
+    let descriptor;
+    try {
+        descriptor = openSync(path, "r");
+        fsyncSync(descriptor);
+    }
+    catch {
+        // Directory fsync is not available on every supported platform.
+    }
+    finally {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
+    }
+}
+export class WorkspaceLock {
+    directory;
+    isProcessAlive;
+    now;
+    createOwnerToken;
+    constructor(options = {}) {
+        const stateDirectory = assertSafeStateDirectory(options.stateDirectory ?? SessionRegistry.resolveStateDirectory(options), options);
+        this.directory = join(stateDirectory, "locks");
+        this.isProcessAlive = options.isProcessAlive ?? processIsAlive;
+        this.now = options.now ?? Date.now;
+        this.createOwnerToken = options.ownerToken ?? randomUUID;
+    }
+    async acquire(workspaceFingerprint, openCodeSessionId) {
+        if (!HASH_PATTERN.test(workspaceFingerprint) || !IDENTIFIER_PATTERN.test(openCodeSessionId))
+            throw new RegistryValidationError();
+        ensurePrivateDirectory(dirname(this.directory));
+        ensurePrivateDirectory(this.directory);
+        const path = join(this.directory, `${workspaceFingerprint}.lock`);
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            const record = {
+                version: LOCK_VERSION,
+                workspaceFingerprint,
+                openCodeSessionId,
+                ownerToken: this.createOwnerToken(),
+                pid: process.pid,
+                acquiredAt: this.now(),
+            };
+            try {
+                this.create(path, record);
+                return this.lease(path, record);
+            }
+            catch (error) {
+                if (!isExistsError(error))
+                    throw new WorkspaceLockCorruptError();
+            }
+            const existing = this.read(path, workspaceFingerprint);
+            if (!existing)
+                continue;
+            if (this.isProcessAlive(existing.pid))
+                throw new WorkspaceBusyError();
+            if (!this.removeIfUnchanged(path, existing))
+                throw new WorkspaceBusyError();
+        }
+        throw new WorkspaceBusyError();
+    }
+    create(path, record) {
+        let descriptor;
+        const temporary = `${path}.${record.ownerToken}.tmp`;
+        try {
+            descriptor = openSync(temporary, "wx", 0o600);
+            writeFileSync(descriptor, `${JSON.stringify(record)}\n`, "utf8");
+            fsyncSync(descriptor);
+            closeSync(descriptor);
+            descriptor = undefined;
+            linkSync(temporary, path);
+            try {
+                unlinkSync(temporary);
+            }
+            catch { /* the private temporary hard link is safe to clean later */ }
+            syncDirectory(dirname(path));
+        }
+        catch (error) {
+            if (descriptor !== undefined) {
+                try {
+                    closeSync(descriptor);
+                }
+                catch { /* preserve the original failure */ }
+            }
+            try {
+                unlinkSync(temporary);
+            }
+            catch { /* best-effort temp cleanup */ }
+            throw error;
+        }
+    }
+    read(path, workspaceFingerprint) {
+        try {
+            if (!existsSync(path))
+                return undefined;
+            if (statSync(path).size > 16_384)
+                throw new WorkspaceLockCorruptError();
+            return decodeLock(JSON.parse(readFileSync(path, "utf8")), workspaceFingerprint);
+        }
+        catch (error) {
+            if (isMissingError(error))
+                return undefined;
+            if (error instanceof WorkspaceLockCorruptError)
+                throw error;
+            throw new WorkspaceLockCorruptError();
+        }
+    }
+    /** Synchronous recheck narrows the stale-owner race before reclaiming its lock. */
+    removeIfUnchanged(path, observed) {
+        const claimPath = `${path}.reclaim`;
+        const claimToken = this.createOwnerToken();
+        const claim = { version: LOCK_VERSION, ownerToken: claimToken, pid: process.pid };
+        let claimDescriptor;
+        const temporaryClaimPath = `${claimPath}.${claimToken}.tmp`;
+        try {
+            claimDescriptor = openSync(temporaryClaimPath, "wx", 0o600);
+            writeFileSync(claimDescriptor, `${JSON.stringify(claim)}\n`, "utf8");
+            fsyncSync(claimDescriptor);
+            closeSync(claimDescriptor);
+            claimDescriptor = undefined;
+            linkSync(temporaryClaimPath, claimPath);
+            try {
+                unlinkSync(temporaryClaimPath);
+            }
+            catch { /* the private temporary hard link is safe to clean later */ }
+            syncDirectory(dirname(path));
+        }
+        catch (error) {
+            if (claimDescriptor !== undefined) {
+                try {
+                    closeSync(claimDescriptor);
+                }
+                catch { /* preserve the original failure */ }
+            }
+            try {
+                unlinkSync(temporaryClaimPath);
+            }
+            catch { /* best-effort temporary cleanup */ }
+            if (!isExistsError(error))
+                throw new WorkspaceLockCorruptError();
+            const existingClaim = this.readRecoveryClaim(claimPath);
+            if (this.isProcessAlive(existingClaim.pid))
+                throw new WorkspaceBusyError();
+            // A crashed recovery owner cannot be safely removed by a competing process;
+            // fail closed rather than risk deleting a newly acquired workspace lock.
+            throw new WorkspaceLockCorruptError();
+        }
+        try {
+            const before = statSync(path);
+            const current = this.read(path, observed.workspaceFingerprint);
+            if (!current)
+                return true;
+            const after = statSync(path);
+            if (current.ownerToken !== observed.ownerToken || before.dev !== after.dev || before.ino !== after.ino)
+                return false;
+            if (this.isProcessAlive(current.pid))
+                return false;
+            unlinkSync(path);
+            syncDirectory(dirname(path));
+            return true;
+        }
+        catch (error) {
+            if (isMissingError(error))
+                return true;
+            if (error instanceof WorkspaceLockCorruptError)
+                throw error;
+            return false;
+        }
+        finally {
+            try {
+                const currentClaim = this.readRecoveryClaim(claimPath);
+                if (currentClaim.ownerToken === claimToken && currentClaim.pid === process.pid)
+                    unlinkSync(claimPath);
+            }
+            catch {
+                // Do not remove a malformed or replaced recovery claim.
+            }
+        }
+    }
+    readRecoveryClaim(path) {
+        try {
+            const value = JSON.parse(readFileSync(path, "utf8"));
+            if (!isRecord(value)
+                || value.version !== LOCK_VERSION
+                || typeof value.ownerToken !== "string"
+                || typeof value.pid !== "number"
+                || !Number.isInteger(value.pid)
+                || Object.keys(value).some((key) => !["version", "ownerToken", "pid"].includes(key))) {
+                throw new WorkspaceLockCorruptError();
+            }
+            return { ownerToken: value.ownerToken, pid: value.pid };
+        }
+        catch (error) {
+            if (error instanceof WorkspaceLockCorruptError)
+                throw error;
+            throw new WorkspaceLockCorruptError();
+        }
+    }
+    lease(path, record) {
+        let released = false;
+        return {
+            workspaceFingerprint: record.workspaceFingerprint,
+            openCodeSessionId: record.openCodeSessionId,
+            release: async () => {
+                if (released)
+                    return;
+                released = true;
+                let current;
+                try {
+                    current = this.read(path, record.workspaceFingerprint);
+                }
+                catch (error) {
+                    throw error;
+                }
+                if (!current) {
+                    released = true;
+                    return;
+                }
+                if (current.ownerToken !== record.ownerToken || current.pid !== record.pid) {
+                    released = true;
+                    return;
+                }
+                try {
+                    unlinkSync(path);
+                    syncDirectory(dirname(path));
+                    released = true;
+                }
+                catch (error) {
+                    if (isMissingError(error)) {
+                        released = true;
+                        return;
+                    }
+                    throw new WorkspaceLockCorruptError();
+                }
+            },
+        };
+    }
+}
+function isExistsError(error) {
+    return isNodeErrorCode(error, "EEXIST");
+}
+function isMissingError(error) {
+    return isNodeErrorCode(error, "ENOENT");
+}
+function isNodeErrorCode(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}

package/dist/types.d.ts

@@ -0,0 +1,27 @@
+export type MuseRequestKind = "primary" | "title" | "compaction" | "generate";
+export interface MuseModelSelection {
+    providerId: string;
+    modelId: string;
+    profileId: string | null;
+    isActive: boolean;
+    isDefault: boolean;
+    defaultReasoningEffort?: string;
+    variantsKnown: boolean;
+    variants: string[];
+}
+export interface RequestContext {
+    sessionID: string;
+    directory: string;
+    kind: MuseRequestKind;
+    modelID: string;
+    providerID: string;
+    variant?: string;
+    effort?: string;
+    museSelection: MuseModelSelection;
+}
+export interface ContextError {
+    type: "context-error";
+    code: "missing" | "invalid" | "unknown-model" | "unsupported-variant";
+    field: string;
+}
+export type MuseErrorKind = "credentials" | "billing" | "unsupported" | "protocol" | "unknown";

package/dist/types.js

@@ -0,0 +1 @@
+export {};