@myagentroam/node 0.9.3 → 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,84 +43,110 @@ 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, attachments);
-            await this.options.uploads.consume(attachmentIds);
+            return await operation;
         }
-        catch (error) {
-            this.options.runtime.deleteQueuedRun(created.run.id);
-            this.options.attachments.clear(created.run.id);
-            this.options.attachments.cleanup(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, attachments) {
         return this.options.attachments.persistFiles(session.cwd, runId, attachments.filter((attachment) => !isRunnerImageAttachment(attachment)));

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-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;
@@ -36,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);

package/dist/util/runner-native-session-parsers.d.ts

@@ -15,6 +15,7 @@ export interface ConversationHistoryPage {
     readonly source: ConversationHistorySource;
     readonly readAt: number;
     readonly latestVisibleAt: number;
+    readonly deferredOlderHistory?: boolean;
 }
 export declare function extractId(result: unknown, key: 'thread' | 'turn'): string;
 export declare function settleWithin<T>(promise: Promise<T>, milliseconds: number): Promise<T | undefined>;
@@ -50,7 +51,7 @@ export declare function nativeConversationPage(session: NodeAgentSession, histor
  */
 export declare function nativeUserClientMessageId(entry: Extract<NativeSessionHistory['items'][number], {
     readonly kind: 'message';
-}>, createdAt: number, runtimeTurns: readonly NodeConversationTurn[]): string | null;
+}>, createdAt: number | null, runtimeTurns: readonly NodeConversationTurn[]): string | null;
 /**
  * Normalize the documented App Server `thread/read(includeTurns: true)`
  * result.  Only items with a user-visible Workbench representation are kept;

package/dist/util/runner-native-session-parsers.js

@@ -165,14 +165,18 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
         .slice(start, end)
         .map((entries, relativeIndex) => {
         const firstIndex = entries[0]?.index ?? 0;
-        const turnId = `${session.id}:native:${firstIndex}`;
-        const nativeItems = entries.map(({ entry, index }) => nativeTranscriptConversationItem(session, entry, index, turnId, runtimeTurns, registerImages));
-        const clientMessageId = nativeItems.flatMap((item) => item.kind === 'user_message' && isPlainRecord(item.payload)
-            ? [item.payload.clientMessageId]
-            : [])[0];
-        const runtimeTurn = typeof clientMessageId === 'string'
-            ? runtimeTurns.find((turn) => runtimeTurnClientMessageId(turn) === clientMessageId)
+        const nativeUser = entries.find(({ entry }) => entry.kind === 'message' && entry.role === 'USER')?.entry;
+        const matchedClientMessageId = nativeUser?.kind === 'message'
+            ? nativeUserClientMessageId(nativeUser, nativeUser.createdAt, runtimeTurns)
+            : null;
+        const runtimeTurn = typeof matchedClientMessageId === 'string'
+            ? runtimeTurns.find((turn) => runtimeTurnClientMessageId(turn) === matchedClientMessageId)
             : undefined;
+        const turnId = runtimeTurn?.id ?? `${session.id}:native:${firstIndex}`;
+        const nativeItems = entries.map(({ entry, index }) => ({
+            ...nativeTranscriptConversationItem(session, entry, index, turnId, runtimeTurns, registerImages),
+            runId: runtimeTurn?.runId ?? null
+        }));
         const runtimeErrors = (runtimeTurn?.items ?? [])
             .filter((item) => item.kind === 'error')
             .map((item) => ({ ...item, turnId, runId: runtimeTurn?.runId ?? null }));
@@ -180,7 +184,7 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
             ...nativeItems,
             ...runtimeErrors.filter((error) => !nativeItems.some((item) => item.id === error.id))
         ];
-        const startedAt = items[0]?.startedAt ?? firstIndex;
+        const startedAt = items[0]?.startedAt ?? null;
         const completedAt = items.at(-1)?.completedAt ?? startedAt;
         const after = lastNativeItemId(entries);
         return {
@@ -205,7 +209,7 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
             completedAt
         };
     });
-    const combined = [...nativePageTurns, ...missingRuntimeErrorTurns].sort((left, right) => (left.startedAt ?? 0) - (right.startedAt ?? 0));
+    const combined = [...nativePageTurns, ...missingRuntimeErrorTurns];
     const dropped = combined.slice(0, Math.max(0, combined.length - limit));
     const turns = combined.slice(-limit);
     const nativePageIds = new Set(nativePageTurns.map((turn) => turn.id));
@@ -241,7 +245,7 @@ function nativeTranscriptTurns(items) {
     return turns;
 }
 function nativeTranscriptConversationItem(session, entry, index, turnId, runtimeTurns, registerImages) {
-    const time = entry.createdAt ?? index;
+    const time = entry.createdAt;
     const isToolCall = entry.kind === 'tool_call';
     const isUnknown = entry.kind === 'unknown';
     const isReasoning = entry.kind === 'reasoning_summary';
@@ -336,6 +340,7 @@ function nativeTranscriptConversationItem(session, entry, index, turnId, runtime
  * runtime user messages by content and creation time so native history replaces the optimistic Turn.
  */
 export function nativeUserClientMessageId(entry, createdAt, runtimeTurns) {
+    const candidates = [];
     for (const turn of runtimeTurns) {
         const user = turn.items.find((item) => item.kind === 'user_message');
         if (user === undefined || !isPlainRecord(user.payload))
@@ -346,13 +351,19 @@ export function nativeUserClientMessageId(entry, createdAt, runtimeTurns) {
         if (clientMessageId === null || payload.text !== stripClaudePlanTag(entry.text))
             continue;
         const runtimeCreatedAt = user.startedAt ?? turn.startedAt;
-        if (runtimeCreatedAt !== null &&
-            runtimeCreatedAt !== undefined &&
-            Math.abs(createdAt - runtimeCreatedAt) > 60_000)
-            continue;
-        return clientMessageId;
+        candidates.push({ clientMessageId, createdAt: runtimeCreatedAt ?? null });
     }
-    return null;
+    if (createdAt === null)
+        return candidates.length === 1 ? candidates[0].clientMessageId : null;
+    const timed = candidates
+        .filter((candidate) => candidate.createdAt !== null)
+        .map((candidate) => ({
+        ...candidate,
+        distance: Math.abs(createdAt - candidate.createdAt)
+    }))
+        .filter((candidate) => candidate.distance <= 60_000)
+        .sort((left, right) => left.distance - right.distance);
+    return timed[0]?.clientMessageId ?? null;
 }
 /**
  * Normalize the documented App Server `thread/read(includeTurns: true)`

package/dist/workspace.js

@@ -1232,14 +1232,7 @@ export async function readCurrentChanges(workspacePath) {
 export async function readCurrentChangeDiff(workspacePath, requestedPath) {
     const path = safeGitWorkspacePath(requestedPath);
     await assertCurrentChangePathAccessible(workspacePath, path);
-    const result = await runGit(workspacePath, [
-        'diff',
-        '--no-ext-diff',
-        '--no-textconv',
-        'HEAD',
-        '--',
-        `:(literal)${path}`
-    ]);
+    const result = await readCurrentChangeGitDiff(workspacePath, path);
     const after = await readWorkingTreeText(workspacePath, path);
     const binary = result.output.includes(0) || result.text.includes('Binary files ') || after?.binary === true;
     if (binary) {
@@ -1263,6 +1256,38 @@ export async function readCurrentChangeDiff(workspacePath, requestedPath) {
         ...(after === undefined ? {} : { afterTruncated: after.truncated })
     };
 }
+async function readCurrentChangeGitDiff(workspacePath, path) {
+    const untracked = await runGit(workspacePath, [
+        'ls-files',
+        '--others',
+        '--exclude-standard',
+        '-z',
+        '--',
+        `:(literal)${path}`
+    ]);
+    if (untracked.text.split('\0').includes(path)) {
+        const result = await runGitAllowFailure(workspacePath, [
+            'diff',
+            '--no-index',
+            '--no-ext-diff',
+            '--no-textconv',
+            '--',
+            '/dev/null',
+            path
+        ]);
+        if (result.code !== 0 && result.code !== 1)
+            throw new GitCommandError(result.code, result.stderr);
+        return result;
+    }
+    return runGit(workspacePath, [
+        'diff',
+        '--no-ext-diff',
+        '--no-textconv',
+        'HEAD',
+        '--',
+        `:(literal)${path}`
+    ]);
+}
 /** Current Changes must not expose an external link. */
 export async function isWorkspaceChangeVisible(workspacePath, requestedPath) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "description": "MyAgentRoam Node runtime CLI.",
   "type": "module",
   "files": [
@@ -24,7 +24,7 @@
     "node-pty": "1.1.0",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/protocol": "^0.9.3"
+    "@myagentroam/protocol": "^0.9.4"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"