@myagentroam/node 0.1.3 → 0.1.6

package/dist/service/workspace-file-service.js

@@ -0,0 +1,109 @@
+import { isAbsolute } from 'node:path';
+import { listWorkspaceFiles, mutateWorkspaceFile, readAllowedTextFile, readWorkspaceTextFile, WorkspaceFileIndex } from '../workspace.js';
+const INDEX_CACHE_LIMIT = 8;
+export class WorkspaceFileService {
+    state;
+    allowedRoots;
+    onInvalidated;
+    mutationTails = new Map();
+    constructor(state, allowedRoots, onInvalidated) {
+        this.state = state;
+        this.allowedRoots = allowedRoots;
+        this.onInvalidated = onInvalidated;
+    }
+    async list(workspace, input) {
+        if ((input.path !== undefined && typeof input.path !== 'string') ||
+            (input.cursor !== undefined && typeof input.cursor !== 'string') ||
+            (input.limit !== undefined &&
+                (!Number.isInteger(input.limit) ||
+                    input.limit < 1 ||
+                    input.limit > 200)))
+            throw new Error('DIRECTORY_CURSOR_INVALID');
+        return listWorkspaceFiles(workspace.path, typeof input.path === 'string' ? input.path : '.', typeof input.cursor === 'string' ? input.cursor : undefined, typeof input.limit === 'number' ? input.limit : undefined);
+    }
+    async read(workspace, input) {
+        if (typeof input.path !== 'string' ||
+            (input.offset !== undefined &&
+                (!Number.isInteger(input.offset) || input.offset < 0)) ||
+            (input.limit !== undefined &&
+                (!Number.isInteger(input.limit) ||
+                    input.limit < 1 ||
+                    input.limit > 512 * 1024)))
+            throw new Error('FILE_RANGE_INVALID');
+        const offset = typeof input.offset === 'number' ? input.offset : 0;
+        const limit = typeof input.limit === 'number' ? input.limit : 512 * 1024;
+        return isAbsolute(input.path)
+            ? readAllowedTextFile(input.path, this.allowedRoots(), offset, limit)
+            : readWorkspaceTextFile(workspace.path, input.path, offset, limit);
+    }
+    async search(workspace, input) {
+        if (typeof input.query !== 'string' ||
+            (input.cursor !== undefined && typeof input.cursor !== 'string') ||
+            (input.includeDirectories !== undefined && typeof input.includeDirectories !== 'boolean') ||
+            (input.limit !== undefined &&
+                (!Number.isInteger(input.limit) ||
+                    input.limit < 1 ||
+                    input.limit > 200)))
+            throw new Error('FILE_SEARCH_LIMIT_EXCEEDED');
+        return this.index(workspace).search(input.query, typeof input.cursor === 'string' ? input.cursor : undefined, typeof input.limit === 'number' ? input.limit : undefined, input.includeDirectories === true);
+    }
+    async mutate(workspace, input) {
+        const action = input.action;
+        if ((action !== 'CREATE_FILE' &&
+            action !== 'CREATE_DIRECTORY' &&
+            action !== 'MOVE' &&
+            action !== 'DELETE') ||
+            typeof input.path !== 'string' ||
+            (action === 'MOVE' && typeof input.destination !== 'string'))
+            throw new Error('FILE_MUTATION_INVALID');
+        const path = input.path;
+        const destination = typeof input.destination === 'string' ? input.destination : undefined;
+        return this.serializeMutation(workspace.id, async () => {
+            const result = await mutateWorkspaceFile(workspace.path, action === 'MOVE' ? { action, path, destination: destination } : { action, path });
+            this.dispose(workspace.id);
+            this.onInvalidated(workspace.id);
+            return result;
+        });
+    }
+    async serializeMutation(workspaceId, operation) {
+        const previous = this.mutationTails.get(workspaceId) ?? Promise.resolve();
+        const result = previous.then(operation, operation);
+        const tail = result.then(() => undefined, () => undefined);
+        this.mutationTails.set(workspaceId, tail);
+        try {
+            return await result;
+        }
+        finally {
+            if (this.mutationTails.get(workspaceId) === tail)
+                this.mutationTails.delete(workspaceId);
+        }
+    }
+    index(workspace) {
+        let index = this.state.fileIndexes.get(workspace.id);
+        if (index === undefined) {
+            if (this.state.fileIndexes.size >= INDEX_CACHE_LIMIT) {
+                const oldest = this.state.fileIndexes.entries().next().value;
+                if (oldest !== undefined) {
+                    oldest[1].dispose();
+                    this.state.fileIndexes.delete(oldest[0]);
+                }
+            }
+            index = new WorkspaceFileIndex(workspace.path, {
+                onInvalidated: () => this.onInvalidated(workspace.id)
+            });
+        }
+        this.state.fileIndexes.delete(workspace.id);
+        this.state.fileIndexes.set(workspace.id, index);
+        return index;
+    }
+    dispose(workspaceId) {
+        if (workspaceId !== undefined) {
+            this.state.fileIndexes.get(workspaceId)?.dispose();
+            this.state.fileIndexes.delete(workspaceId);
+            return;
+        }
+        for (const index of this.state.fileIndexes.values())
+            index.dispose();
+        this.state.fileIndexes.clear();
+    }
+}

package/dist/service/workspace-queue-workbench-service.d.ts

@@ -0,0 +1,55 @@
+import type { NodeOperationHandler } from '../connector/node-operation-router.js';
+import type { NodeRuntimeState } from '../runtime-state.js';
+import type { RunnerName } from '@myagentroam/protocol';
+export interface QueuedRunStart<TAttachment = unknown> {
+    readonly runId: string;
+    readonly sessionId: string;
+    readonly workspaceId: string;
+    readonly runner: RunnerName;
+    readonly input: string;
+    readonly attachments: readonly TAttachment[];
+    readonly attachmentPaths: readonly string[];
+    readonly cwd: string;
+    readonly externalSessionId: string | null;
+    readonly model: string | null;
+    readonly effort: string | null;
+    readonly access: string | null;
+    readonly collaborationMode: 'default' | 'plan';
+    readonly serviceTier?: 'fast';
+    readonly secretEnvironment: Readonly<Record<string, string>>;
+}
+export interface WorkspaceQueueWorkbenchServiceOptions {
+    readonly runtime: NodeRuntimeState;
+    readonly emit: (workspaceId: string, sessionId: string) => void;
+    readonly clearImages: (runId: string) => void;
+    readonly emitRun: (runId: string, eventType: string, payload: unknown, status?: 'FAILED' | 'CANCELLED') => void;
+    readonly emitConversation: (turn: unknown) => void;
+    readonly control: (operation: string, payload: Record<string, unknown>) => void;
+    readonly stopped: () => boolean;
+    readonly markInterrupted: (runId: string) => void;
+    readonly prepareInput: (runner: RunnerName, input: string, collaborationMode: 'default' | 'plan') => string;
+}
+export declare class WorkspaceQueueWorkbenchService<TAttachment> {
+    private readonly options;
+    private readonly starts;
+    constructor(options: WorkspaceQueueWorkbenchServiceOptions);
+    remember(start: QueuedRunStart<TAttachment>): void;
+    pending(runId: string): QueuedRunStart<TAttachment> | undefined;
+    remove(runId: string): void;
+    clear(): void;
+    migrateSession(previousId: string, nextId: string): void;
+    operations(): Readonly<Record<string, NodeOperationHandler>>;
+    private get;
+    private pauseOrResume;
+    private reorder;
+    private update;
+    private delete;
+    private execute;
+    private requireSession;
+    private requireRun;
+    replace(queuedRunId: string, activeRunId: string, prioritize?: boolean): void;
+    schedule(sessionId: string): void;
+    dispatch(sessionId: string): Promise<void>;
+    present(workspaceId: string, sessionId: string): unknown;
+    private updatePending;
+}

package/dist/service/workspace-queue-workbench-service.js

@@ -0,0 +1,226 @@
+import { isPlainRecord } from '../runner/codex/conversation-parser.js';
+import { isTerminalRunStatus } from '../util/node-operation-parsers.js';
+import { withNonImageAttachmentPrompt } from '../runner/codex/conversation-parser.js';
+export class WorkspaceQueueWorkbenchService {
+    options;
+    starts = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    remember(start) {
+        this.starts.set(start.runId, start);
+    }
+    pending(runId) {
+        return this.starts.get(runId);
+    }
+    remove(runId) {
+        this.starts.delete(runId);
+    }
+    clear() {
+        this.starts.clear();
+    }
+    migrateSession(previousId, nextId) {
+        for (const [runId, pending] of this.starts) {
+            if (pending.sessionId === previousId)
+                this.starts.set(runId, { ...pending, sessionId: nextId, externalSessionId: nextId });
+        }
+    }
+    operations() {
+        return {
+            'workspace.queue.get': (data) => this.get(record(data)),
+            'workspace.queue.resume': (data) => this.pauseOrResume('resume', record(data)),
+            'workspace.queue.pause': (data) => this.pauseOrResume('pause', record(data)),
+            'workspace.queue.reorder': (data) => this.reorder(record(data)),
+            'workspace.queue.message.update': (data) => this.update(record(data)),
+            'workspace.queue.message.delete': (data) => this.delete(record(data)),
+            'workspace.queue.message.execute': (data) => this.execute(record(data))
+        };
+    }
+    get(input) {
+        if (typeof input.workspaceId !== 'string' || typeof input.sessionId !== 'string')
+            throw new Error('WORKSPACE_NOT_FOUND');
+        return { queue: this.present(input.workspaceId, input.sessionId) };
+    }
+    pauseOrResume(mode, input) {
+        const session = this.requireSession(input);
+        if (mode === 'resume') {
+            this.options.runtime.resumeSessionQueue(session.id);
+            this.schedule(session.id);
+        }
+        else
+            this.options.runtime.pauseSessionQueue(session.id);
+        this.options.emit(session.workspaceId, session.id);
+        return { queue: this.present(session.workspaceId, session.id) };
+    }
+    reorder(input) {
+        if (!Number.isInteger(input.expectedVersion) ||
+            !Array.isArray(input.runIds) ||
+            input.runIds.some((id) => typeof id !== 'string'))
+            throw new Error('QUEUE_INVALID');
+        const session = this.requireSession(input);
+        this.options.runtime.reorderSessionQueue(session.id, input.expectedVersion, input.runIds);
+        this.options.emit(session.workspaceId, session.id);
+        return { queue: this.present(session.workspaceId, session.id) };
+    }
+    update(input) {
+        if (typeof input.runId !== 'string' ||
+            typeof input.content !== 'string' ||
+            input.content.trim().length === 0)
+            throw new Error('QUEUE_INVALID');
+        const run = this.requireRun(input.runId);
+        this.updatePending(run.id, input.content.trim());
+        this.options.emit(run.workspaceId, run.sessionId);
+        return { queue: this.present(run.workspaceId, run.sessionId) };
+    }
+    delete(input) {
+        if (typeof input.runId !== 'string')
+            throw new Error('QUEUE_INVALID');
+        const run = this.requireRun(input.runId);
+        this.options.runtime.deleteQueuedRun(run.id);
+        this.remove(run.id);
+        this.options.clearImages(run.id);
+        this.options.emit(run.workspaceId, run.sessionId);
+        return { queue: this.present(run.workspaceId, run.sessionId) };
+    }
+    execute(input) {
+        if (typeof input.runId !== 'string')
+            throw new Error('QUEUE_INVALID');
+        const queued = this.requireRun(input.runId);
+        if (!this.options.runtime.isQueuedRun(queued.id) || queued.status !== 'QUEUED')
+            throw new Error('QUEUE_ITEM_INVALID');
+        if (!this.starts.has(queued.id))
+            throw new Error('QUEUE_INPUT_LOST');
+        const session = this.options.runtime.getAgentSession(queued.sessionId);
+        if (session === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        this.options.runtime.resumeSessionQueue(session.id);
+        const active = this.options.runtime
+            .listRunsForSession(session.id)
+            .find((run) => run.status === 'STARTING' || run.status === 'RUNNING');
+        this.options.runtime.prioritizeQueuedRun(queued.id);
+        this.options.emit(queued.workspaceId, session.id);
+        if (active !== undefined) {
+            this.replace(queued.id, active.id, false);
+            return { run: queued, delivery: 'RESTARTING' };
+        }
+        this.schedule(session.id);
+        return { run: queued, delivery: 'STARTING' };
+    }
+    requireSession(input) {
+        if (typeof input.workspaceId !== 'string' || typeof input.sessionId !== 'string')
+            throw new Error('WORKSPACE_NOT_FOUND');
+        const session = this.options.runtime.getAgentSession(input.sessionId);
+        if (session?.workspaceId !== input.workspaceId)
+            throw new Error('SESSION_NOT_FOUND');
+        return session;
+    }
+    requireRun(runId) {
+        const run = this.options.runtime.getRun(runId);
+        if (run === undefined)
+            throw new Error('RUN_NOT_FOUND');
+        return run;
+    }
+    replace(queuedRunId, activeRunId, prioritize = true) {
+        const queued = this.options.runtime.getRun(queuedRunId);
+        const active = this.options.runtime.getRun(activeRunId);
+        if (queued === undefined ||
+            active === undefined ||
+            queued.sessionId !== active.sessionId ||
+            !this.options.runtime.isQueuedRun(queued.id))
+            throw new Error('QUEUE_ITEM_INVALID');
+        if (prioritize)
+            this.options.runtime.prioritizeQueuedRun(queued.id);
+        this.options.markInterrupted(active.id);
+        this.options.runtime.transitionRun(active.id, 'CANCELLING');
+        this.options.control('run.interrupt', { runId: active.id });
+    }
+    schedule(sessionId) {
+        const timer = setTimeout(() => {
+            if (!this.options.stopped())
+                void this.dispatch(sessionId);
+        }, 0);
+        timer.unref();
+    }
+    async dispatch(sessionId) {
+        const run = this.options.runtime.claimNextQueuedRun(sessionId);
+        if (run === undefined)
+            return;
+        this.options.emit(run.workspaceId, sessionId);
+        const pending = this.starts.get(run.id);
+        if (pending === undefined) {
+            this.options.emitRun(run.id, 'run.rejected', { code: 'QUEUE_INPUT_LOST' }, 'FAILED');
+            return;
+        }
+        try {
+            const turn = this.options.runtime.conversationTurnForRun(run.id);
+            if (turn !== undefined)
+                this.options.emitConversation(turn);
+            const current = this.options.runtime.getRun(run.id);
+            if (current !== undefined && isTerminalRunStatus(current.status))
+                return;
+            if (current?.status === 'CANCELLING') {
+                this.options.emitRun(run.id, 'run.completed', { status: 'CANCELLED' }, 'CANCELLED');
+                return;
+            }
+            this.options.control('run.start', {
+                runId: pending.runId,
+                sessionId: pending.sessionId,
+                workspaceId: pending.workspaceId,
+                runner: pending.runner,
+                input: pending.input,
+                ...(pending.attachments.length === 0 ? {} : { attachments: pending.attachments }),
+                cwd: pending.cwd,
+                ...(pending.externalSessionId === null
+                    ? {}
+                    : { externalSessionId: pending.externalSessionId }),
+                ...(pending.model === null ? {} : { model: pending.model }),
+                ...(pending.effort === null ? {} : { effort: pending.effort }),
+                ...(pending.access === null ? {} : { access: pending.access }),
+                collaborationMode: pending.collaborationMode,
+                ...(pending.serviceTier === undefined ? {} : { serviceTier: pending.serviceTier }),
+                secretEnvironment: pending.secretEnvironment
+            });
+        }
+        catch (error) {
+            this.options.emitRun(run.id, 'run.rejected', { code: error instanceof Error ? error.message : 'QUEUE_START_FAILED' }, 'FAILED');
+        }
+    }
+    present(workspaceId, sessionId) {
+        const session = this.options.runtime.getAgentSession(sessionId);
+        if (session?.workspaceId !== workspaceId)
+            throw new Error('SESSION_NOT_FOUND');
+        const queue = this.options.runtime.sessionQueue(sessionId);
+        return {
+            version: queue.version,
+            paused: queue.paused,
+            items: queue.runIds.flatMap((runId) => {
+                const run = this.options.runtime.getRun(runId);
+                if (run === undefined)
+                    return [];
+                const queuedSession = this.options.runtime.getAgentSession(run.sessionId);
+                return [
+                    {
+                        run,
+                        sessionId: run.sessionId,
+                        sessionTitle: queuedSession?.customTitle ?? queuedSession?.runnerTitle ?? '未命名会话',
+                        content: this.options.runtime.queuedMessageText(run.id)
+                    }
+                ];
+            })
+        };
+    }
+    updatePending(runId, content) {
+        const pending = this.starts.get(runId);
+        const runnerInput = withNonImageAttachmentPrompt(content, pending?.attachmentPaths ?? []);
+        this.options.runtime.updateQueuedMessage(runId, runnerInput);
+        if (pending === undefined)
+            return;
+        this.starts.set(runId, {
+            ...pending,
+            input: this.options.prepareInput(pending.runner, runnerInput, pending.collaborationMode)
+        });
+    }
+}
+function record(value) {
+    return isPlainRecord(value) ? value : {};
+}

package/dist/service/workspace-service.d.ts

@@ -0,0 +1,15 @@
+import type { NodeConfig } from '../config.js';
+import type { NodeOperationHandler } from '../connector/node-operation-router.js';
+import type { NodeDatabase } from '../database.js';
+import type { NodeRuntimeState } from '../runtime-state.js';
+export declare class WorkspaceService {
+    private readonly database;
+    private readonly config;
+    private readonly runtime;
+    private readonly onRemoved;
+    constructor(database: () => NodeDatabase, config: () => NodeConfig, runtime: NodeRuntimeState, onRemoved: (workspaceId: string) => void);
+    operations(): Readonly<Record<string, NodeOperationHandler>>;
+    private register;
+    private listDirectories;
+    private remove;
+}

package/dist/service/workspace-service.js

@@ -0,0 +1,67 @@
+import { rmdir } from 'node:fs/promises';
+import { createWorkspaceDirectory, inspectWorkspace, listWorkspaceDirectories } from '../workspace.js';
+export class WorkspaceService {
+    database;
+    config;
+    runtime;
+    onRemoved;
+    constructor(database, config, runtime, onRemoved) {
+        this.database = database;
+        this.config = config;
+        this.runtime = runtime;
+        this.onRemoved = onRemoved;
+    }
+    operations() {
+        return {
+            'workspace.register': (data) => this.register(data),
+            'workspace.directories.list': (data) => this.listDirectories(data),
+            'workspace.remove': (data) => this.remove(data),
+            'workspace.list': () => ({ workspaces: this.database().listWorkspaces() })
+        };
+    }
+    async register(data) {
+        const input = data;
+        if (typeof input.path !== 'string')
+            throw new Error('WORKSPACE_INVALID');
+        if (input.createDirectoryName !== undefined && typeof input.createDirectoryName !== 'string')
+            throw new Error('WORKSPACE_DIRECTORY_NAME_INVALID');
+        let createdPath;
+        try {
+            const path = typeof input.createDirectoryName === 'string'
+                ? (createdPath = await createWorkspaceDirectory(input.path, input.createDirectoryName, this.config().allowedRoots))
+                : input.path;
+            const inspected = await inspectWorkspace(path, this.config().allowedRoots);
+            return {
+                workspace: this.database().saveWorkspace({
+                    path: inspected.path,
+                    kind: inspected.kind,
+                    gitSummary: inspected.gitSummary ?? null
+                })
+            };
+        }
+        catch (error) {
+            if (createdPath !== undefined)
+                await rmdir(createdPath).catch(() => undefined);
+            throw error;
+        }
+    }
+    async listDirectories(data) {
+        const input = data;
+        if (input.path !== undefined && typeof input.path !== 'string')
+            throw new Error('WORKSPACE_DIRECTORY_INVALID');
+        return {
+            directory: await listWorkspaceDirectories(input.path, this.config().allowedRoots)
+        };
+    }
+    remove(data) {
+        const input = data;
+        if (typeof input.workspaceId !== 'string')
+            throw new Error('WORKSPACE_NOT_FOUND');
+        if (this.runtime.hasActiveWorkspaceLease(input.workspaceId))
+            throw new Error('WORKSPACE_BUSY');
+        const workspace = this.database().removeWorkspace(input.workspaceId);
+        this.runtime.removeWorkspace(input.workspaceId);
+        this.onRemoved(workspace.id);
+        return { workspace };
+    }
+}

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

@@ -0,0 +1,23 @@
+import type { NodeAgentSession } from '../database.js';
+import { WorkspaceDomainState } from './workspace-domain-state.js';
+export interface WorkspaceSessionServiceOptions {
+    discover: (workspaceId: string) => Promise<readonly NodeAgentSession[]>;
+    listPage: (workspaceId: string) => Promise<unknown>;
+    active: (workspaceId: string) => boolean;
+    emitRevision: (workspaceId: string, revision: number) => void;
+    onPending?: (workspaceId: string, waitMs: number) => void;
+}
+export declare class WorkspaceSessionService {
+    private readonly state;
+    private readonly options;
+    private readonly cacheGenerations;
+    constructor(state: WorkspaceDomainState, options: WorkspaceSessionServiceOptions);
+    ensureWatch(workspaceId: string): void;
+    stopWatch(workspaceId: string): void;
+    cached(workspaceId: string): Promise<readonly NodeAgentSession[]>;
+    clear(): void;
+    invalidate(workspaceId: string): void;
+    private bumpCacheGeneration;
+    private refreshWatch;
+    private performRefresh;
+}

package/dist/service/workspace-session-service.js

@@ -0,0 +1,139 @@
+const WATCH_INTERVAL_MS = 30_000;
+const CACHE_TTL_MS = 15_000;
+const INITIAL_WAIT_MS = 500;
+export class WorkspaceSessionService {
+    state;
+    options;
+    cacheGenerations = new Map();
+    constructor(state, options) {
+        this.state = state;
+        this.options = options;
+    }
+    ensureWatch(workspaceId) {
+        if (this.state.sessionWatchTimers.has(workspaceId))
+            return;
+        const timer = setInterval(() => void this.refreshWatch(workspaceId), WATCH_INTERVAL_MS);
+        timer.unref();
+        this.state.sessionWatchTimers.set(workspaceId, timer);
+        void this.refreshWatch(workspaceId);
+    }
+    stopWatch(workspaceId) {
+        const timer = this.state.sessionWatchTimers.get(workspaceId);
+        if (timer !== undefined)
+            clearInterval(timer);
+        this.state.sessionWatchTimers.delete(workspaceId);
+        this.state.sessionWatchSignatures.delete(workspaceId);
+        this.state.sessionWatchReads.delete(workspaceId);
+    }
+    async cached(workspaceId) {
+        const cached = this.state.sessionCache.get(workspaceId);
+        if (cached !== undefined && cached.expiresAt > Date.now())
+            return cached.sessions;
+        let initialDiscoveryTimedOut = false;
+        let discovery = this.state.sessionCacheReads.get(workspaceId);
+        if (discovery === undefined) {
+            const generation = this.cacheGenerations.get(workspaceId) ?? 0;
+            const read = this.options
+                .discover(workspaceId)
+                .then((sessions) => {
+                if ((this.cacheGenerations.get(workspaceId) ?? 0) !== generation)
+                    return sessions;
+                const previous = this.state.sessionCache.get(workspaceId)?.sessions;
+                this.state.sessionCache.set(workspaceId, {
+                    sessions,
+                    expiresAt: Date.now() + CACHE_TTL_MS
+                });
+                if (initialDiscoveryTimedOut ||
+                    (previous !== undefined && sessionSignature(previous) !== sessionSignature(sessions))) {
+                    const revision = (this.state.watchRevisions.get(workspaceId) ?? 0) + 1;
+                    this.state.watchRevisions.set(workspaceId, revision);
+                    this.options.emitRevision(workspaceId, revision);
+                }
+                return sessions;
+            })
+                .finally(() => {
+                if (this.state.sessionCacheReads.get(workspaceId) === read)
+                    this.state.sessionCacheReads.delete(workspaceId);
+                if (!this.state.sessionCacheReads.has(workspaceId) &&
+                    !this.state.sessionCache.has(workspaceId) &&
+                    (this.cacheGenerations.get(workspaceId) ?? 0) !== generation)
+                    this.cacheGenerations.delete(workspaceId);
+            });
+            discovery = read;
+            this.state.sessionCacheReads.set(workspaceId, discovery);
+        }
+        if (cached !== undefined)
+            return cached.sessions;
+        const discovered = await within(discovery, INITIAL_WAIT_MS);
+        if (discovered !== undefined)
+            return discovered;
+        initialDiscoveryTimedOut = true;
+        this.options.onPending?.(workspaceId, INITIAL_WAIT_MS);
+        return [];
+    }
+    clear() {
+        for (const timer of this.state.sessionWatchTimers.values())
+            clearInterval(timer);
+        this.state.sessionWatchTimers.clear();
+        this.state.sessionWatchSignatures.clear();
+        this.state.sessionWatchReads.clear();
+        for (const workspaceId of new Set([
+            ...this.state.sessionCache.keys(),
+            ...this.state.sessionCacheReads.keys()
+        ]))
+            this.bumpCacheGeneration(workspaceId);
+        this.state.sessionCache.clear();
+        this.state.sessionCacheReads.clear();
+    }
+    invalidate(workspaceId) {
+        this.bumpCacheGeneration(workspaceId);
+        this.state.sessionCache.delete(workspaceId);
+        this.state.sessionCacheReads.delete(workspaceId);
+        this.stopWatch(workspaceId);
+    }
+    bumpCacheGeneration(workspaceId) {
+        this.cacheGenerations.set(workspaceId, (this.cacheGenerations.get(workspaceId) ?? 0) + 1);
+    }
+    async refreshWatch(workspaceId) {
+        const current = this.state.sessionWatchReads.get(workspaceId);
+        if (current !== undefined)
+            return current;
+        const refresh = this.performRefresh(workspaceId).finally(() => this.state.sessionWatchReads.delete(workspaceId));
+        this.state.sessionWatchReads.set(workspaceId, refresh);
+        return refresh;
+    }
+    async performRefresh(workspaceId) {
+        if (!this.options.active(workspaceId))
+            return this.stopWatch(workspaceId);
+        try {
+            const signature = JSON.stringify(await this.options.listPage(workspaceId));
+            const previous = this.state.sessionWatchSignatures.get(workspaceId);
+            this.state.sessionWatchSignatures.set(workspaceId, signature);
+            if (previous === undefined || previous === signature)
+                return;
+            const revision = (this.state.watchRevisions.get(workspaceId) ?? 0) + 1;
+            this.state.watchRevisions.set(workspaceId, revision);
+            this.options.emitRevision(workspaceId, revision);
+        }
+        catch {
+            // The bounded interval retries without fabricating session state.
+        }
+    }
+}
+function sessionSignature(sessions) {
+    return JSON.stringify(sessions.map((session) => [
+        session.id,
+        session.runnerTitle,
+        session.customTitle,
+        session.lastActivityAt,
+        session.pinnedAt,
+        session.pinOrder,
+        session.externalDiscovered
+    ]));
+}
+async function within(promise, timeoutMs) {
+    return Promise.race([
+        promise,
+        new Promise((resolve) => setTimeout(resolve, timeoutMs))
+    ]);
+}

package/dist/service/workspace-upload-service.d.ts

@@ -0,0 +1,37 @@
+import type { NodeMessageAttachmentInput, NodeWorkspace } from '../database.js';
+import { WorkspaceDomainState } from './workspace-domain-state.js';
+export interface ResolvedComposerAttachment {
+    readonly attachment: NodeMessageAttachmentInput;
+    readonly path: string;
+}
+export declare class WorkspaceUploadService {
+    private readonly state;
+    private readonly onCompleted;
+    constructor(state: WorkspaceDomainState, onCompleted: (workspaceId: string) => void);
+    preflight(workspace: NodeWorkspace, input: Record<string, unknown>): Promise<({
+        name: string;
+        status: string;
+        path: null;
+    } | {
+        name: string;
+        status: import("../workspace.js").WorkspaceUploadPreflightStatus;
+        path: string | null;
+    })[]>;
+    create(workspace: NodeWorkspace, input: Record<string, unknown>): Promise<UploadStatus>;
+    write(input: Record<string, unknown>): Promise<UploadStatus>;
+    status(uploadId: unknown): UploadStatus;
+    complete(uploadId: unknown): Promise<UploadStatus>;
+    cancel(uploadId: unknown): Promise<void>;
+    resolve(workspaceId: string, ids: readonly string[]): Promise<readonly ResolvedComposerAttachment[]>;
+    shutdown(): Promise<void>;
+    private require;
+    private remove;
+    private attachmentTarget;
+}
+interface UploadStatus {
+    readonly uploadId: string;
+    readonly path: string;
+    readonly receivedBytes: number;
+    readonly size: number;
+}
+export {};