@myagentroam/node 0.9.2 → 0.9.4

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

@@ -1,7 +1,9 @@
+import { randomUUID } from 'node:crypto';
 import { isImageAttachment, isRunnerImageAttachment, parseComposerAttachmentIds, parseMessageAttachments, sessionTitleFromFirstMessage, withNonImageAttachmentPrompt } from '../util/node-operation-parsers.js';
 import { parseSecretEnvironment } from '../util/secret-environment.js';
 export class SessionMessageService {
     options;
+    pendingMessages = new Map();
     constructor(options) {
         this.options = options;
     }
@@ -19,20 +21,21 @@ export class SessionMessageService {
             typeof input.content !== 'string' ||
             input.content.length === 0)
             throw new Error('MESSAGE_INVALID');
+        const clientMessageId = input.clientMessageId;
+        const content = input.content;
         const inlineAttachments = parseMessageAttachments(input.attachments);
         const secretEnvironment = parseSecretEnvironment(input.secretEnvironment);
         const attachmentIds = parseComposerAttachmentIds(input.attachmentIds);
         if (inlineAttachments.length > 0 && attachmentIds.length > 0)
             throw new Error('MESSAGE_ATTACHMENTS_INVALID');
-        const session = this.options.runtime.setTemporaryTitleIfMissing((await this.options.resolve(input.sessionId)).id, sessionTitleFromFirstMessage(input.content));
-        this.options.emitSession(session);
+        const session = await this.options.resolve(input.sessionId);
         const intent = input.deliveryIntent;
         if (intent !== undefined &&
             intent !== 'SEND' &&
             intent !== 'QUEUE' &&
             intent !== 'REPLACE_CURRENT')
             throw new Error('MESSAGE_INVALID');
-        const existing = this.options.runtime.findMessageRun(session.id, input.clientMessageId);
+        const existing = this.options.runtime.findMessageRun(session.id, clientMessageId);
         if (existing !== undefined)
             return {
                 session: this.options.present(session),
@@ -40,92 +43,113 @@ export class SessionMessageService {
                 delivery: this.options.runtime.isQueuedRun(existing.id) ? 'QUEUED' : 'STARTED',
                 idempotent: true
             };
-        const uploaded = await this.options.uploads.resolve(session.workspaceId, attachmentIds);
-        const attachments = attachmentIds.length === 0
-            ? inlineAttachments
-            : uploaded.map((attachment) => attachment.attachment);
-        const imageAttachments = attachments.filter(isImageAttachment);
-        const runnerImageAttachments = attachments.filter(isRunnerImageAttachment);
-        const active = this.options.runtime
-            .listRunsForSession(session.id)
-            .find((run) => run.status === 'STARTING' || run.status === 'RUNNING');
-        const replaceCurrentRun = intent === 'REPLACE_CURRENT' ? active : undefined;
-        const queueWasPaused = this.options.runtime.sessionQueue(session.id).paused;
-        const queuedBeforeCreate = this.options.runtime.hasActiveSessionLease(session.id) || intent === 'QUEUE';
-        const created = this.options.runtime.createMessageRun({
-            sessionId: session.id,
-            clientMessageId: input.clientMessageId,
-            content: input.content,
-            ...(attachments.length === 0 ? {} : { attachments })
-        });
-        if (!created.created)
-            return {
-                session: this.options.present(session),
-                run: created.run,
-                delivery: this.options.runtime.isQueuedRun(created.run.id) ? 'QUEUED' : 'STARTED',
-                idempotent: true
-            };
-        this.options.attachments.cache(created.run.id, imageAttachments);
-        let attachmentPaths;
+        const pendingKey = `${session.id}\u0000${clientMessageId}`;
+        const pending = this.pendingMessages.get(pendingKey);
+        if (pending !== undefined)
+            return pending;
+        const operation = (async () => {
+            const runId = randomUUID();
+            let enqueued = false;
+            try {
+                const uploaded = await this.options.uploads.resolve(session.workspaceId, attachmentIds);
+                const attachments = attachmentIds.length === 0
+                    ? inlineAttachments
+                    : uploaded.map((attachment) => attachment.attachment);
+                const imageAttachments = attachments.filter(isImageAttachment);
+                const runnerImageAttachments = attachments.filter(isRunnerImageAttachment);
+                const attachmentPaths = await this.persistAttachments(session, runId, attachments);
+                const runnerInput = withNonImageAttachmentPrompt(content, attachmentPaths);
+                const planActive = this.options.commands
+                    .list(session.id)
+                    .some((state) => state.commandId === 'plan');
+                const runner = this.options.runners.require(session.runner);
+                const active = this.options.runtime
+                    .listRunsForSession(session.id)
+                    .find((run) => run.status === 'STARTING' || run.status === 'RUNNING');
+                const replaceCurrentRun = intent === 'REPLACE_CURRENT' ? active : undefined;
+                const queueWasPaused = this.options.runtime.sessionQueue(session.id).paused;
+                const queuedBeforeCreate = this.options.runtime.hasActiveSessionLease(session.id) || intent === 'QUEUE';
+                const created = this.options.queue.enqueue({
+                    runId,
+                    sessionId: session.id,
+                    workspaceId: session.workspaceId,
+                    runner: session.runner,
+                    input: runner.prepareMessageInput(runnerInput, planActive ? 'plan' : 'default'),
+                    attachments: runnerImageAttachments,
+                    attachmentPaths,
+                    cwd: session.cwd,
+                    externalSessionId: session.externalSessionId,
+                    model: session.model,
+                    effort: session.effort,
+                    access: session.access,
+                    collaborationMode: planActive ? 'plan' : 'default',
+                    secretEnvironment,
+                    ...(runner.serviceTier() === 'fast' ? { serviceTier: 'fast' } : {})
+                }, {
+                    runId,
+                    sessionId: session.id,
+                    clientMessageId,
+                    content: runnerInput,
+                    ...(Number.isSafeInteger(input.__requestUserId)
+                        ? { initiatedByUserId: input.__requestUserId }
+                        : {}),
+                    ...(attachments.length === 0 ? {} : { attachments })
+                });
+                enqueued = created.created;
+                if (!created.created) {
+                    this.options.attachments.cleanup(runId);
+                    return {
+                        session: this.options.present(session),
+                        run: created.run,
+                        delivery: this.options.runtime.isQueuedRun(created.run.id) ? 'QUEUED' : 'STARTED',
+                        idempotent: true
+                    };
+                }
+                const acceptedSession = this.options.runtime.setTemporaryTitleIfMissing(session.id, sessionTitleFromFirstMessage(content));
+                this.options.emitSession(acceptedSession);
+                this.options.attachments.cache(created.run.id, imageAttachments);
+                void this.options.uploads.consume(attachmentIds).catch(() => undefined);
+                if (queueWasPaused && active === undefined && intent !== 'QUEUE')
+                    this.options.runtime.prioritizeQueuedRun(created.run.id);
+                if (!queueWasPaused || intent !== 'QUEUE')
+                    this.options.runtime.resumeSessionQueue(session.id);
+                if (replaceCurrentRun !== undefined)
+                    this.options.queue.replace(created.run.id, replaceCurrentRun.id);
+                else if (intent !== 'QUEUE' ||
+                    !queuedBeforeCreate ||
+                    !this.options.runtime.hasActiveSessionLease(session.id))
+                    this.options.queue.schedule(session.id);
+                this.options.emitQueue(session.workspaceId, session.id);
+                return {
+                    session: this.options.present(acceptedSession),
+                    run: created.run,
+                    delivery: replaceCurrentRun !== undefined
+                        ? 'RESTARTING'
+                        : queuedBeforeCreate
+                            ? 'QUEUED'
+                            : 'STARTED',
+                    idempotent: false
+                };
+            }
+            catch (error) {
+                if (!enqueued) {
+                    this.options.attachments.clear(runId);
+                    this.options.attachments.cleanup(runId);
+                }
+                throw error;
+            }
+        })();
+        this.pendingMessages.set(pendingKey, operation);
         try {
-            attachmentPaths = await this.persistAttachments(session, created.run.id, attachmentIds, attachments, uploaded);
+            return await operation;
         }
-        catch (error) {
-            this.options.runtime.deleteQueuedRun(created.run.id);
-            this.options.attachments.clear(created.run.id);
-            throw error;
+        finally {
+            if (this.pendingMessages.get(pendingKey) === operation)
+                this.pendingMessages.delete(pendingKey);
         }
-        const runnerInput = withNonImageAttachmentPrompt(input.content, attachmentPaths);
-        this.options.runtime.updateQueuedMessage(created.run.id, runnerInput);
-        const planActive = this.options.commands
-            .list(session.id)
-            .some((state) => state.commandId === 'plan');
-        this.options.queue.remember({
-            runId: created.run.id,
-            sessionId: created.run.sessionId,
-            workspaceId: created.run.workspaceId,
-            runner: created.run.runner,
-            input: this.options.runners
-                .require(created.run.runner)
-                .prepareMessageInput(runnerInput, planActive ? 'plan' : 'default'),
-            attachments: runnerImageAttachments,
-            attachmentPaths,
-            cwd: session.cwd,
-            externalSessionId: session.externalSessionId,
-            model: session.model,
-            effort: session.effort,
-            access: session.access,
-            collaborationMode: planActive ? 'plan' : 'default',
-            secretEnvironment,
-            ...(this.options.runners.require(created.run.runner).serviceTier() === 'fast'
-                ? { serviceTier: 'fast' }
-                : {})
-        });
-        if (queueWasPaused && active === undefined && intent !== 'QUEUE')
-            this.options.runtime.prioritizeQueuedRun(created.run.id);
-        if (!queueWasPaused || intent !== 'QUEUE')
-            this.options.runtime.resumeSessionQueue(session.id);
-        this.options.emitQueue(session.workspaceId, session.id);
-        if (replaceCurrentRun !== undefined)
-            this.options.queue.replace(created.run.id, replaceCurrentRun.id);
-        else if (intent !== 'QUEUE' || !queuedBeforeCreate)
-            this.options.queue.schedule(session.id);
-        return {
-            session: this.options.present(session),
-            run: created.run,
-            delivery: replaceCurrentRun !== undefined ? 'RESTARTING' : queuedBeforeCreate ? 'QUEUED' : 'STARTED',
-            idempotent: false
-        };
     }
-    async persistAttachments(session, runId, attachmentIds, attachments, uploaded) {
-        return [
-            ...uploaded
-                .filter(({ attachment }) => !isRunnerImageAttachment(attachment))
-                .map(({ path }) => path),
-            ...(await this.options.attachments.persistFiles(session.cwd, runId, attachmentIds.length === 0
-                ? attachments.filter((attachment) => !isRunnerImageAttachment(attachment))
-                : []))
-        ];
+    async persistAttachments(session, runId, attachments) {
+        return this.options.attachments.persistFiles(session.cwd, runId, attachments.filter((attachment) => !isRunnerImageAttachment(attachment)));
     }
     channelMessage(input) {
         if (typeof input.sessionId !== 'string' ||

package/dist/service/skill-directory-service.d.ts

@@ -12,6 +12,8 @@ export interface LocalSkillTargetInspection {
     readonly skills: readonly LocalSkillInspection[];
 }
 export declare class SkillDirectoryService {
-    inspectNodeHome(home: string): Promise<LocalSkillTargetInspection>;
+    inspectNodeHome(home: string, options?: {
+        readonly includeClaudeCompatibility?: boolean;
+    }): Promise<LocalSkillTargetInspection>;
     inspectWorkspace(workspace: string): Promise<LocalSkillTargetInspection>;
 }

package/dist/service/skill-directory-service.js

@@ -6,14 +6,20 @@ const MAX_METADATA_BYTES = 64 * 1024;
 const SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
 const WINDOWS_DEVICE_NAME = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/u;
 export class SkillDirectoryService {
-    async inspectNodeHome(home) {
+    async inspectNodeHome(home, options = {}) {
         const agentsRoot = path.join(home, '.agents', 'skills');
         const claudeRoot = path.join(home, '.claude', 'skills');
-        const skills = await scanRoot(agentsRoot, 'AGENTS');
+        const compatibilityMode = await nodeCompatibilityMode(agentsRoot, claudeRoot);
+        const agents = await scanRoot(agentsRoot, 'AGENTS');
+        const claude = options.includeClaudeCompatibility === true && compatibilityMode !== 'UNAVAILABLE'
+            ? await scanRoot(claudeRoot, 'CLAUDE')
+            : [];
         return {
             targetKind: 'NODE',
-            compatibilityMode: await nodeCompatibilityMode(agentsRoot, claudeRoot),
-            skills
+            compatibilityMode,
+            skills: options.includeClaudeCompatibility === true
+                ? mergeNodeCompatibilityRoots(agents, claude)
+                : agents.map(withoutSource)
         };
     }
     async inspectWorkspace(workspace) {
@@ -147,6 +153,24 @@ function mergeWorkspaceCopies(agents, claude) {
         return withoutSource(copies.agents);
     });
 }
+function mergeNodeCompatibilityRoots(agents, claude) {
+    const byName = new Map();
+    for (const item of agents)
+        byName.set(item.name, { agents: item });
+    for (const item of claude)
+        byName.set(item.name, { ...byName.get(item.name), claude: item });
+    return [...byName.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, copies]) => {
+        if (copies.agents === undefined || copies.claude === undefined)
+            return withoutSource((copies.agents ?? copies.claude));
+        if (copies.agents.description !== copies.claude.description ||
+            copies.agents.localStatus !== copies.claude.localStatus ||
+            JSON.stringify(copies.agents.install) !== JSON.stringify(copies.claude.install))
+            return { name, description: copies.agents.description, localStatus: 'PARTIAL' };
+        return withoutSource(copies.agents);
+    });
+}
 function withoutSource(entry) {
     return {
         name: entry.name,

package/dist/service/skill-node-operation-service.d.ts

@@ -9,7 +9,7 @@ export declare class SkillNodeOperationService {
     private readonly jobs;
     constructor(database: () => NodeDatabase, config: () => NodeConfig);
     operations(): {
-        'node.skills.inspect': () => Promise<import("./skill-directory-service.js").LocalSkillTargetInspection>;
+        'node.skills.inspect': (data: unknown) => Promise<import("./skill-directory-service.js").LocalSkillTargetInspection>;
         'node.skills.install': (data: unknown) => Promise<{
             accepted: boolean;
             installJobId: `${string}-${string}-${string}-${string}-${string}`;

package/dist/service/skill-node-operation-service.js

@@ -17,9 +17,11 @@ export class SkillNodeOperationService {
     }
     operations() {
         return {
-            'node.skills.inspect': async () => {
+            'node.skills.inspect': async (data) => {
                 await this.installer.recoverNodeHome(homedir());
-                return this.directories.inspectNodeHome(homedir());
+                return this.directories.inspectNodeHome(homedir(), {
+                    includeClaudeCompatibility: record(data)['includeClaudeCompatibility'] === true
+                });
             },
             'node.skills.install': (data) => this.install('NODE', data),
             'node.skills.remove': (data) => this.remove('NODE', data),

package/dist/service/workbench-event-service.d.ts

@@ -1,21 +1,9 @@
-import type { NodeEnvelope, WorkbenchEvent, WorkbenchEventCategory } from '@myagentroam/protocol';
-import type { NodeOperationHandler } from '../connector/node-operation-router.js';
+import { type NodeEnvelope, type WorkbenchEventCategory } from '@myagentroam/protocol';
 export declare class WorkbenchEventService {
     private readonly send;
     private readonly accepts;
-    private readonly buffer;
     private sequence;
-    private readonly history;
     constructor(send: (envelope: NodeEnvelope) => void, accepts: (category: WorkbenchEventCategory, payload: unknown) => boolean);
     emit(category: WorkbenchEventCategory, payload: unknown): void;
-    read(after: number): {
-        readonly events: readonly WorkbenchEvent[];
-        readonly latestSequence: number;
-        readonly resyncRequired: boolean;
-    };
-    operations(): Readonly<Record<string, NodeOperationHandler>>;
     snapshotSequence(): number;
-    acknowledge(replyTo: string | undefined): boolean;
-    replay(): void;
-    get pendingCount(): number;
 }

package/dist/service/workbench-event-service.js

@@ -1,10 +1,8 @@
-import { ReliableWorkbenchEventBuffer } from '../event-buffer.js';
+import { createEnvelope } from '@myagentroam/protocol';
 export class WorkbenchEventService {
     send;
     accepts;
-    buffer = new ReliableWorkbenchEventBuffer();
     sequence = 0;
-    history = [];
     constructor(send, accepts) {
         this.send = send;
         this.accepts = accepts;
@@ -13,41 +11,9 @@ export class WorkbenchEventService {
         if (!this.accepts(category, payload))
             return;
         const event = { sequence: ++this.sequence, category, payload };
-        this.history.push(event);
-        if (this.history.length > 1_000)
-            this.history.shift();
-        this.send(this.buffer.queue(event));
-    }
-    read(after) {
-        const first = this.history[0]?.sequence;
-        const reset = after > this.sequence || (first !== undefined && after < first - 1);
-        return {
-            events: reset ? [] : this.history.filter((event) => event.sequence > after),
-            latestSequence: this.sequence,
-            resyncRequired: reset
-        };
-    }
-    operations() {
-        return {
-            'workbench.events.read': (data) => {
-                const afterValue = data?.after;
-                const after = typeof afterValue === 'number' && Number.isInteger(afterValue) && afterValue >= 0
-                    ? afterValue
-                    : 0;
-                return this.read(after);
-            }
-        };
+        this.send(createEnvelope('workbench.event', event));
     }
     snapshotSequence() {
         return this.sequence;
     }
-    acknowledge(replyTo) {
-        return this.buffer.acknowledge(replyTo);
-    }
-    replay() {
-        this.buffer.replay(this.send);
-    }
-    get pendingCount() {
-        return this.buffer.size;
-    }
 }

package/dist/service/workbench-manifest-service.d.ts

@@ -21,7 +21,6 @@ export declare class WorkbenchManifestService {
             reasonCode: null;
             itemVersions: number[];
             supportsSessionCursor: boolean;
-            supportsWorkspaceActivityCursor: boolean;
             supportsHistoryPaging: boolean;
             supportsItemFinalSnapshots: boolean;
             maxPageSize: number;

package/dist/service/workbench-manifest-service.js

@@ -30,7 +30,6 @@ export class WorkbenchManifestService {
                 reasonCode: null,
                 itemVersions: [1],
                 supportsSessionCursor: true,
-                supportsWorkspaceActivityCursor: true,
                 supportsHistoryPaging: true,
                 supportsItemFinalSnapshots: true,
                 maxPageSize: 500

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

@@ -60,7 +60,7 @@ export class WorkspaceChangeService {
                 additions: null,
                 deletions: null,
                 binary: false,
-                diffAvailable: change.state !== 'UNTRACKED'
+                diffAvailable: true
             });
             const value = {
                 branch: root.branch,

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

@@ -42,6 +42,7 @@ export interface CompletedComposerAttachment {
     readonly name: string;
     readonly mime: string;
     readonly size: number;
+    readonly timer: NodeJS.Timeout;
 }
 export declare class WorkspaceDomainState {
     readonly uploads: Map<string, ActiveWorkspaceUpload>;

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

@@ -1,7 +1,7 @@
 import type { NodeOperationHandler } from '../connector/node-operation-router.js';
 import type { NodeRuntimeState } from '../runtime-state.js';
 import type { RunnerName } from '@myagentroam/protocol';
-import type { NodeMcpInstallation } from '../database.js';
+import type { NodeAgentRun, NodeMcpInstallation, NodeMessageAttachmentInput } from '../database.js';
 export interface QueuedRunStart<TAttachment = unknown> {
     readonly runId: string;
     readonly sessionId: string;
@@ -23,6 +23,7 @@ export interface WorkspaceQueueWorkbenchServiceOptions {
     readonly runtime: NodeRuntimeState;
     readonly emit: (workspaceId: string, sessionId: string) => void;
     readonly clearImages: (runId: string) => void;
+    readonly cleanupAttachments: (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;
@@ -35,7 +36,17 @@ export declare class WorkspaceQueueWorkbenchService<TAttachment> {
     private readonly options;
     private readonly starts;
     constructor(options: WorkspaceQueueWorkbenchServiceOptions);
-    remember(start: QueuedRunStart<TAttachment>): void;
+    enqueue(start: QueuedRunStart<TAttachment>, message: {
+        readonly runId: string;
+        readonly sessionId: string;
+        readonly clientMessageId: string;
+        readonly content: string;
+        readonly initiatedByUserId?: number;
+        readonly attachments?: readonly NodeMessageAttachmentInput[];
+    }): {
+        readonly run: NodeAgentRun;
+        readonly created: boolean;
+    };
     pending(runId: string): QueuedRunStart<TAttachment> | undefined;
     remove(runId: string): void;
     clear(): void;

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

@@ -8,8 +8,13 @@ export class WorkspaceQueueWorkbenchService {
     constructor(options) {
         this.options = options;
     }
-    remember(start) {
-        this.starts.set(start.runId, start);
+    enqueue(start, message) {
+        if (message.runId !== start.runId || message.sessionId !== start.sessionId)
+            throw new Error('QUEUE_RUN_MISMATCH');
+        const created = this.options.runtime.createMessageRun(message);
+        if (created.created)
+            this.starts.set(start.runId, start);
+        return created;
     }
     pending(runId) {
         return this.starts.get(runId);
@@ -80,6 +85,7 @@ export class WorkspaceQueueWorkbenchService {
         this.options.runtime.deleteQueuedRun(run.id);
         this.remove(run.id);
         this.options.clearImages(run.id);
+        this.options.cleanupAttachments(run.id);
         this.options.emit(run.workspaceId, run.sessionId);
         return { queue: this.present(run.workspaceId, run.sessionId) };
     }

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

@@ -23,9 +23,11 @@ export declare class WorkspaceUploadService {
     complete(uploadId: unknown): Promise<UploadStatus>;
     cancel(uploadId: unknown): Promise<void>;
     resolve(workspaceId: string, ids: readonly string[]): Promise<readonly ResolvedComposerAttachment[]>;
+    consume(ids: readonly string[]): Promise<void>;
     shutdown(): Promise<void>;
     private require;
     private remove;
+    private removeCompleted;
     private attachmentTarget;
 }
 interface UploadStatus {

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

@@ -133,16 +133,25 @@ export class WorkspaceUploadService {
         clearTimeout(upload.timer);
         this.state.uploads.delete(upload.id);
         this.onCompleted(upload.workspaceId);
-        if (upload.composerAttachment !== undefined)
-            this.state.composerAttachments.set(upload.composerAttachment.id, {
+        if (upload.composerAttachment !== undefined) {
+            const attachmentId = upload.composerAttachment.id;
+            const timer = setTimeout(() => {
+                const attachment = this.state.composerAttachments.get(attachmentId);
+                if (attachment !== undefined)
+                    void this.removeCompleted(attachment);
+            }, TTL_MS);
+            timer.unref();
+            this.state.composerAttachments.set(attachmentId, {
                 id: upload.composerAttachment.id,
                 workspaceId: upload.workspaceId,
                 path: upload.path,
                 targetPath: upload.targetPath,
                 name: upload.composerAttachment.name,
                 mime: upload.composerAttachment.mime,
-                size: upload.size
+                size: upload.size,
+                timer
             });
+        }
         return {
             uploadId: upload.id,
             path: upload.path,
@@ -159,8 +168,7 @@ export class WorkspaceUploadService {
         const attachment = this.state.composerAttachments.get(uploadId);
         if (attachment === undefined)
             throw new Error('UPLOAD_NOT_FOUND');
-        this.state.composerAttachments.delete(uploadId);
-        await rm(dirname(attachment.targetPath), { recursive: true, force: true });
+        await this.removeCompleted(attachment);
     }
     async resolve(workspaceId, ids) {
         return Promise.all(ids.map(async (id) => {
@@ -184,10 +192,17 @@ export class WorkspaceUploadService {
             };
         }));
     }
+    async consume(ids) {
+        await Promise.all(ids.map(async (id) => {
+            const attachment = this.state.composerAttachments.get(id);
+            if (attachment !== undefined)
+                await this.removeCompleted(attachment);
+        }));
+    }
     async shutdown() {
         await Promise.allSettled([...this.state.uploads.values()].map((upload) => this.remove(upload)));
         for (const attachment of this.state.composerAttachments.values())
-            await rm(dirname(attachment.targetPath), { recursive: true, force: true });
+            await this.removeCompleted(attachment);
         this.state.composerAttachments.clear();
     }
     require(id) {
@@ -206,6 +221,13 @@ export class WorkspaceUploadService {
         if (upload.composerAttachment !== undefined)
             await rm(dirname(upload.targetPath), { recursive: true, force: true }).catch(() => undefined);
     }
+    async removeCompleted(attachment) {
+        if (this.state.composerAttachments.get(attachment.id) !== attachment)
+            return;
+        this.state.composerAttachments.delete(attachment.id);
+        clearTimeout(attachment.timer);
+        await rm(dirname(attachment.targetPath), { recursive: true, force: true }).catch(() => undefined);
+    }
     async attachmentTarget(workspacePath, id, name) {
         const mar = resolve(workspacePath, '.mar');
         await mkdir(mar, { recursive: true, mode: 0o700 });

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

@@ -1,13 +1,11 @@
 import type { NodeOperationHandler } from '../connector/node-operation-router.js';
 import type { NodeWorkspace } from '../database.js';
-import { NodeRuntimeState } from '../runtime-state.js';
 import { WorkspaceChangeService } from './workspace-change-service.js';
 import { WorkspaceFileService } from './workspace-file-service.js';
 import { WorkspaceUploadService } from './workspace-upload-service.js';
 import { WorkspaceWatchService } from './workspace-watch-service.js';
 export interface WorkspaceWorkbenchServiceOptions {
     readonly requireWorkspace: (workspaceId: unknown) => NodeWorkspace;
-    readonly runtime: NodeRuntimeState;
     readonly watch: WorkspaceWatchService;
     readonly files: WorkspaceFileService;
     readonly uploads: WorkspaceUploadService;
@@ -20,7 +18,6 @@ export declare class WorkspaceWorkbenchService {
     private readonly contentSearch;
     constructor(options: WorkspaceWorkbenchServiceOptions);
     operations(): Readonly<Record<string, NodeOperationHandler>>;
-    private activity;
     private watch;
     private unwatch;
     private listFiles;

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

@@ -9,7 +9,6 @@ export class WorkspaceWorkbenchService {
     }
     operations() {
         return {
-            'workspace.activity.read': (data) => this.activity(record(data)),
             'workspace.watch': (data) => this.watch(record(data)),
             'workspace.unwatch': (data) => this.unwatch(record(data)),
             'workspace.files.list': (data) => this.listFiles(record(data)),
@@ -35,20 +34,6 @@ export class WorkspaceWorkbenchService {
             'workspace.diff': (data) => this.diff(record(data))
         };
     }
-    activity(input) {
-        if (typeof input.workspaceId !== 'string' ||
-            (input.cursor !== undefined && typeof input.cursor !== 'string') ||
-            (input.limit !== undefined &&
-                (!Number.isInteger(input.limit) ||
-                    input.limit < 1 ||
-                    input.limit > 500)))
-            throw new Error('EVENT_CURSOR_INVALID');
-        return this.options.runtime.listWorkspaceActivity({
-            workspaceId: input.workspaceId,
-            ...(typeof input.cursor === 'string' ? { cursor: input.cursor } : {}),
-            ...(typeof input.limit === 'number' ? { limit: input.limit } : {})
-        });
-    }
     async watch(input) {
         if (typeof input.workspaceId !== 'string' ||
             typeof input.watchId !== 'string' ||
@@ -143,8 +128,6 @@ export class WorkspaceWorkbenchService {
             (input.state !== 'STAGED' && input.state !== 'UNSTAGED' && input.state !== 'UNTRACKED'))
             throw new Error('GIT_CHANGE_RESTORE_UNAVAILABLE');
         const workspace = this.gitWorkspace(input.workspaceId);
-        if (this.options.runtime.hasActiveWorkspaceLease(workspace.id))
-            throw new Error('WORKSPACE_BUSY');
         const repository = await resolveGitRepository(workspace.path, input.repositoryPath ?? '');
         await restoreCurrentChange(repository, input.path, input.state);
         this.options.invalidate(workspace.id);

package/dist/util/runner-error.d.ts

@@ -0,0 +1,6 @@
+export interface RunnerErrorProjection {
+    readonly code: string;
+    readonly message: string;
+    readonly httpStatus: number | null;
+}
+export declare function runnerErrorProjection(error: unknown, fallbackCode: string): RunnerErrorProjection;