@myagentroam/node 0.11.36 → 0.11.38

package/dist/service/runner-interaction-service.js

@@ -1,5 +1,6 @@
-import { denyPermission } from '../claude-agent-sdk.js';
-import { boundedConversationItemId, isTerminalRunStatus } from '../util/node-operation-parsers.js';
+import { denyPermission } from '../runner/claude/claude-agent-sdk.js';
+import { boundedConversationItemId } from '../runner/normalization.js';
+import { isTerminalRunStatus } from '../session/runtime/type-guards.js';
 import { claudeUserInputQuestions } from '../runner/claude/conversation-parser.js';
 export class RunnerInteractionService {
     options;
@@ -223,7 +224,6 @@ export class RunnerInteractionService {
         finally {
             codex.execution.runs.delete(runId);
             codex.releaseEnvironment(runId);
-            this.options.state.active.delete(runId);
         }
     }
     respondUserInput(runId, requestId, rawAnswers) {
@@ -260,13 +260,14 @@ export class RunnerInteractionService {
         if (run === undefined)
             return false;
         if (run.status === 'CANCELLING') {
-            const status = this.options.state.interruptRequested.has(runId) ? 'INTERRUPTED' : 'CANCELLED';
+            const status = this.options.runtime.isExecutionInterruptRequested(runId)
+                ? 'INTERRUPTED'
+                : 'CANCELLED';
             this.options.emitRun(runId, 'run.completed', { status }, status);
         }
         else if (!isTerminalRunStatus(run.status))
             return false;
         this.options.codex().execution.runs.delete(runId);
-        this.options.state.active.delete(runId);
         return true;
     }
     respondCodexUserInput(runId, requestId, rawAnswers) {

package/dist/service/runner-service.js

@@ -1,5 +1,5 @@
 import { runnerDefaultConfigurationSchema } from '@myagentroam/protocol';
-import { parseSecretEnvironment } from '../util/secret-environment.js';
+import { parseSecretEnvironment } from '../mcp/secret-environment.js';
 export class RunnerService {
     database;
     capabilities;

package/dist/service/session-recent-activity.js

@@ -1,4 +1,5 @@
-import { isPlainRecord, isTerminalRunStatus } from '../util/node-operation-parsers.js';
+import { isPlainRecord } from '../util/records.js';
+import { isTerminalRunStatus } from '../session/runtime/type-guards.js';
 /** Projects only already-observed, process-local public facts. Never reads native history. */
 function activity(runtime, sessionId) {
     const candidate = runtime.activeSessionRun(sessionId);

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

@@ -1,7 +1,7 @@
 import { lstat, open, readdir, readlink, realpath } from 'node:fs/promises';
 import path from 'node:path';
 import { skillInstallMetadataSchema } from '@myagentroam/protocol';
-import { hasBrokenWorkspaceSkillGitExclude } from './workspace-git-exclude-service.js';
+import { hasBrokenWorkspaceSkillGitExclude } from '../workspace/workspace-git-exclude-service.js';
 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;

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

@@ -4,8 +4,8 @@ import { promisify } from 'node:util';
 import { lstat, mkdir, readFile, readdir, readlink, realpath, rename, rm, symlink, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { skillInstallMetadataSchema } from '@myagentroam/protocol';
-import { GitCommandError, resolveWorkspaceGitRoot } from '../workspace.js';
-import { rewriteWorkspaceGitExclude, updateWorkspaceSkillGitExclude } from './workspace-git-exclude-service.js';
+import { GitCommandError, resolveWorkspaceGitRoot } from '../workspace/git.js';
+import { rewriteWorkspaceGitExclude, updateWorkspaceSkillGitExclude } from '../workspace/workspace-git-exclude-service.js';
 export class SkillInstallService {
     async recoverNodeHome(home) {
         const agentsRoot = path.join(home, '.agents', 'skills');

package/dist/service/terminal-service.js

@@ -1,4 +1,4 @@
-import { parseSecretEnvironment } from '../util/secret-environment.js';
+import { parseSecretEnvironment } from '../mcp/secret-environment.js';
 export class TerminalService {
     database;
     terminalManager;

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

@@ -1,6 +1,7 @@
 import { conversationSegmentIdentityForItem, conversationSegments } from './conversation-segment-service.js';
-import { runConversationItemId } from '../runtime-state.js';
-import { isNodeAgentRun, isNodeConversationTurn, isPlainRecord } from '../util/node-operation-parsers.js';
+import { runConversationItemId } from '../session/runtime/conversation-projection.js';
+import { isNodeAgentRun, isNodeConversationTurn } from '../session/runtime/type-guards.js';
+import { isPlainRecord } from '../util/records.js';
 export function workbenchPayloadSessionId(getRun, category, payload) {
     if (!isPlainRecord(payload))
         return undefined;

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

@@ -1,5 +1,5 @@
 import { createEnvelope } from '@myagentroam/protocol';
-import { isPlainRecord } from '../util/node-operation-parsers.js';
+import { isPlainRecord } from '../util/records.js';
 import { projectWorkbenchPayload, workbenchPayloadSessionId } from './workbench-event-projection.js';
 export class WorkbenchEventService {
     options;

package/dist/service/workspace-service.js

@@ -1,6 +1,7 @@
 import { realpath, rmdir } from 'node:fs/promises';
-import { createWorkspaceDirectory, inspectWorkspace, listWorkspaceDirectories } from '../workspace.js';
-import { ensureWorkspaceGitExclude } from './workspace-git-exclude-service.js';
+import { createWorkspaceDirectory, listWorkspaceDirectories } from '../workspace/files.js';
+import { inspectWorkspace } from '../workspace/git.js';
+import { ensureWorkspaceGitExclude } from '../workspace/workspace-git-exclude-service.js';
 import { workspaceGitSettingsSchema } from '@myagentroam/protocol';
 export class WorkspaceService {
     database;

package/dist/session/attachments.js

@@ -0,0 +1,110 @@
+import { serializeComposerTag, parseComposerTags } from '@myagentroam/protocol';
+import { isPlainRecord } from '../util/records.js';
+const MAX_COMPOSER_ATTACHMENT_BYTES = 5 * 1024 * 1024;
+const MAX_COMPOSER_ATTACHMENTS_BYTES = 10 * 1024 * 1024;
+const COMPOSER_IMAGE_MIME_TYPES = new Set([
+    'image/png',
+    'image/jpeg',
+    'image/gif',
+    'image/webp'
+]);
+export function parseComposerAttachmentUpload(input) {
+    if (input.composerAttachmentId === undefined && input.mime === undefined)
+        return undefined;
+    if (typeof input.composerAttachmentId !== 'string' ||
+        !isUuid(input.composerAttachmentId) ||
+        typeof input.name !== 'string' ||
+        !validComposerAttachmentName(input.name) ||
+        typeof input.mime !== 'string' ||
+        input.mime.length === 0 ||
+        input.mime.length > 120)
+        throw new Error('COMPOSER_ATTACHMENT_INVALID');
+    return { id: input.composerAttachmentId, name: input.name, mime: input.mime };
+}
+export function parseComposerAttachmentIds(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > 5 || value.some((id) => typeof id !== 'string'))
+        throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+    const ids = value;
+    if (ids.some((id) => !isUuid(id)) || new Set(ids).size !== ids.length)
+        throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+    return ids;
+}
+export function validComposerAttachmentName(name) {
+    return (name.trim().length > 0 &&
+        name.length <= 255 &&
+        name !== '.' &&
+        name !== '..' &&
+        !name.includes('/') &&
+        !name.includes('\\') &&
+        !Array.from(name).some((character) => {
+            const code = character.charCodeAt(0);
+            return code <= 31 || code === 127 || '<>:"|?*'.includes(character);
+        }));
+}
+export function isUuid(value) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+export function parseMessageAttachments(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > 5)
+        throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+    let totalBytes = 0;
+    return value.map((attachment) => {
+        if (!isPlainRecord(attachment))
+            throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+        if (typeof attachment.name !== 'string' ||
+            typeof attachment.mime !== 'string' ||
+            typeof attachment.dataBase64 !== 'string')
+            throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+        if (!validComposerAttachmentName(attachment.name) ||
+            attachment.mime.length === 0 ||
+            attachment.mime.length > 120 ||
+            !isCanonicalBase64(attachment.dataBase64))
+            throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+        const byteSize = Buffer.byteLength(attachment.dataBase64, 'base64');
+        if (byteSize === 0 || byteSize > MAX_COMPOSER_ATTACHMENT_BYTES)
+            throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+        totalBytes += byteSize;
+        if (totalBytes > MAX_COMPOSER_ATTACHMENTS_BYTES)
+            throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+        return { name: attachment.name, mime: attachment.mime, dataBase64: attachment.dataBase64 };
+    });
+}
+export function parseRunnerImageAttachments(value) {
+    return parseMessageAttachments(value).map((attachment) => {
+        if (!isRunnerImageAttachment(attachment))
+            throw new Error('MESSAGE_ATTACHMENT_UNSUPPORTED');
+        return attachment;
+    });
+}
+export function isRunnerImageAttachment(attachment) {
+    return COMPOSER_IMAGE_MIME_TYPES.has(attachment.mime);
+}
+export function isImageAttachment(attachment) {
+    return attachment.mime.startsWith('image/');
+}
+export function withNonImageAttachmentPrompt(input, paths, files) {
+    if (paths.length === 0)
+        return input;
+    const tag = serializeComposerTag('mar_attachments', {
+        files: files
+            ? [...files]
+            : paths.map((path) => ({
+                name: path.split(/[\\/]/u).at(-1),
+                mime: 'application/octet-stream',
+                path
+            }))
+    });
+    const body = parseComposerTags(input)
+        .filter((part) => part.kind !== 'mar_attachments')
+        .map((part) => (part.kind === 'text' ? part.text : part.raw))
+        .join('')
+        .trimEnd();
+    return `${body}\n${tag}`;
+}
+export function isCanonicalBase64(value) {
+    return value.length > 0 && value.length % 4 === 0 && /^[A-Za-z0-9+/]+={0,2}$/.test(value);
+}

package/dist/session/contracts.js

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

package/dist/{util → session}/conversation-identity.js

@@ -1,4 +1,4 @@
-import { isPlainRecord } from './node-operation-parsers.js';
+import { isPlainRecord } from '../util/records.js';
 export function conversationClientMessageId(turn) {
     for (const item of turn.items) {
         if (item.kind !== 'user_message' || !isPlainRecord(item.payload))

package/dist/session/input-validation.js

@@ -0,0 +1,15 @@
+import { composerVisibleText } from '@myagentroam/protocol';
+export function validSessionOption(value) {
+    return (value === undefined ||
+        (typeof value === 'string' && value.trim().length > 0 && value.length <= 120));
+}
+export function validSessionEffort(value) {
+    return value === undefined || (typeof value === 'string' && value.length <= 120);
+}
+export function validSessionTitle(value) {
+    return (value === undefined ||
+        (typeof value === 'string' && value.trim().length > 0 && value.length <= 160));
+}
+export function sessionTitleFromFirstMessage(content) {
+    return composerVisibleText(content).replace(/\s+/g, ' ').slice(0, 160);
+}

package/dist/{service → session}/native-session-projection-service.js

@@ -1,6 +1,10 @@
-import { deduplicateDirectSessions } from '../util/runner-native-session-parsers.js';
+import { deduplicateDirectSessions } from './runner-native-session-parsers.js';
 export class NativeSessionProjectionService {
     options;
+    directNative = new Map();
+    cachedNative() {
+        return [...this.directNative.values()];
+    }
     constructor(options) {
         this.options = options;
     }
@@ -54,7 +58,7 @@ export class NativeSessionProjectionService {
         return sessions;
     }
     async resolve(sessionId, registeredOnly = false) {
-        const cached = this.options.state.directNative.get(sessionId);
+        const cached = this.directNative.get(sessionId);
         if (cached !== undefined)
             return cached;
         const database = this.options.database();
@@ -152,20 +156,45 @@ export class NativeSessionProjectionService {
     async rename(session, input) {
         if (session.externalSessionId === null)
             return;
-        await this.options.runners
-            .require(session.runner)
-            .renameNative(session, input, this.requireDatabase());
+        const runner = this.options.runners.require(session.runner);
+        const database = this.requireDatabase();
+        await runner.renameNative(session, input);
+        const runnerTitle = runner.usesRunnerTitleForRename();
+        database.saveNativeSessionMetadata({
+            runner: session.runner,
+            externalSessionId: session.externalSessionId,
+            workspaceId: session.workspaceId,
+            ...(input.title === undefined
+                ? {}
+                : runnerTitle
+                    ? {
+                        runnerTitle: input.title,
+                        runnerTitlePending: input.title !== null && input.title.trim().length > 0
+                    }
+                    : { customTitle: input.title }),
+            ...(input.pinned === undefined ? {} : { pinned: input.pinned })
+        });
     }
     project(input) {
         const timestamp = input.lastActivityAt ?? 0;
         const database = this.options.database();
         const metadata = database?.getNativeSessionMetadata(input.runner, input.externalSessionId, input.workspace.id);
-        const runnerTitle = this.options.runners.require(input.runner).projectedRunnerTitle(metadata, {
+        const projection = this.options.runners.require(input.runner).projectedRunnerTitle(metadata, {
             externalSessionId: input.externalSessionId,
             workspaceId: input.workspace.id,
             ...(input.title === undefined ? {} : { title: input.title }),
             ...(input.titleOrigin === undefined ? {} : { titleOrigin: input.titleOrigin })
-        }, database);
+        });
+        if (projection.clearPending) {
+            database?.saveNativeSessionMetadata({
+                runner: input.runner,
+                externalSessionId: input.externalSessionId,
+                workspaceId: input.workspace.id,
+                runnerTitle: projection.title,
+                runnerTitlePending: false
+            });
+        }
+        const runnerTitle = projection.title;
         return {
             id: input.externalSessionId,
             nodeId: this.options.nodeId(),
@@ -199,7 +228,7 @@ export class NativeSessionProjectionService {
     remember(sessions) {
         const database = this.options.database();
         for (const session of sessions) {
-            this.options.state.directNative.set(session.id, session);
+            this.directNative.set(session.id, session);
             if (database === undefined || session.externalSessionId === null)
                 continue;
             const metadata = database.getNativeSessionMetadata(session.runner, session.externalSessionId, session.workspaceId);
@@ -224,7 +253,7 @@ export class NativeSessionProjectionService {
             record.metadata.customTitle ?? record.metadata.runnerTitle ?? 'Untitled session'
         ]));
         for (const session of [
-            ...this.options.state.directNative.values(),
+            ...this.directNative.values(),
             ...this.options.runtime.listAgentSessions()
         ]) {
             if (session.workspaceId !== workspaceId)
@@ -312,13 +341,13 @@ export class NativeSessionProjectionService {
             }
         }
         const directIds = new Set();
-        for (const [directId, direct] of this.options.state.directNative) {
+        for (const [directId, direct] of this.directNative) {
             if (direct.runner === session.runner &&
                 direct.cwd === session.cwd &&
                 direct.externalSessionId !== null &&
                 nativeIds.has(direct.externalSessionId)) {
                 directIds.add(directId);
-                this.options.state.directNative.delete(directId);
+                this.directNative.delete(directId);
             }
         }
         for (const projectionId of projectionIds) {

package/dist/session/pagination.js

@@ -0,0 +1,77 @@
+export const DEFAULT_SESSION_PAGE_SIZE = 10;
+export const MAX_SESSION_PAGE_SIZE = 100;
+export function sessionPage(sessions, input) {
+    const limit = typeof input.limit === 'number' &&
+        Number.isInteger(input.limit) &&
+        input.limit >= 1 &&
+        input.limit <= MAX_SESSION_PAGE_SIZE
+        ? input.limit
+        : DEFAULT_SESSION_PAGE_SIZE;
+    const cursor = typeof input.cursor === 'string' ? input.cursor : undefined;
+    const ordered = [...sessions].sort(compareSessionPageEntries);
+    const cursorEntry = cursor === undefined ? undefined : parseSessionPageCursor(cursor);
+    const afterCursor = cursor === undefined
+        ? ordered
+        : cursorEntry === undefined
+            ? []
+            : ordered.filter((session) => compareSessionPageEntries(session, cursorEntry) > 0);
+    const pinned = ordered.filter((session) => session.pinOrder !== null && session.pinOrder !== undefined);
+    const pinnedIndexes = new Map(pinned.map((session, index) => [session.id, index]));
+    const page = afterCursor.slice(0, limit).map((session) => {
+        const pinIndex = pinnedIndexes.get(session.id);
+        if (pinIndex === undefined)
+            return session;
+        return {
+            ...session,
+            canMovePinUp: pinIndex > 0,
+            canMovePinDown: pinIndex < pinned.length - 1
+        };
+    });
+    const last = page.at(-1);
+    return {
+        sessions: page,
+        nextCursor: last !== undefined && afterCursor.length > page.length ? createSessionPageCursor(last) : null
+    };
+}
+export function parseSessionPageCursor(cursor) {
+    try {
+        const value = JSON.parse(decodeURIComponent(cursor));
+        if (!Array.isArray(value) || value.length !== 3)
+            return undefined;
+        const [pinOrder, lastActivityAt, id] = value;
+        if ((pinOrder !== null && (typeof pinOrder !== 'number' || !Number.isFinite(pinOrder))) ||
+            (lastActivityAt !== null &&
+                (typeof lastActivityAt !== 'number' || !Number.isFinite(lastActivityAt))) ||
+            typeof id !== 'string')
+            return undefined;
+        return {
+            id,
+            lastActivityAt: lastActivityAt ?? 0,
+            pinOrder,
+            externalDiscovered: lastActivityAt !== null
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function createSessionPageCursor(session) {
+    return encodeURIComponent(JSON.stringify([
+        session.pinOrder ?? null,
+        session.externalDiscovered === false ? null : session.lastActivityAt,
+        session.id
+    ]));
+}
+export function compareSessionPageEntries(left, right) {
+    const leftPinned = left.pinOrder !== null && left.pinOrder !== undefined;
+    const rightPinned = right.pinOrder !== null && right.pinOrder !== undefined;
+    if (leftPinned !== rightPinned)
+        return leftPinned ? -1 : 1;
+    if (leftPinned && rightPinned)
+        return (left.pinOrder - right.pinOrder || left.id.localeCompare(right.id));
+    const leftFound = left.externalDiscovered !== false;
+    const rightFound = right.externalDiscovered !== false;
+    if (leftFound !== rightFound)
+        return leftFound ? -1 : 1;
+    return right.lastActivityAt - left.lastActivityAt || left.id.localeCompare(right.id, 'en');
+}

package/dist/{util → session}/runner-native-session-parsers.js

@@ -1,6 +1,7 @@
 import { nativeTranscriptAdapter } from '../native-transcript-adapters.js';
 import { createHash } from 'node:crypto';
-import { compactRunnerText, isPlainRecord, nativePageEnd } from './node-operation-parsers.js';
+import { compactRunnerText, nativePageEnd } from '../runner/normalization.js';
+import { isPlainRecord } from '../util/records.js';
 export async function settleWithin(promise, milliseconds) {
     let timer;
     try {

package/dist/session/runtime/approvals.js

@@ -0,0 +1,90 @@
+export class RuntimeApprovals {
+    getRun;
+    currentExecutionId;
+    canonicalRunId;
+    now;
+    approvals = new Map();
+    constructor(getRun, currentExecutionId, canonicalRunId, now) {
+        this.getRun = getRun;
+        this.currentExecutionId = currentExecutionId;
+        this.canonicalRunId = canonicalRunId;
+        this.now = now;
+    }
+    createApproval(input) {
+        const run = this.getRun(input.runId);
+        if (run === undefined)
+            throw new Error('RUN_NOT_FOUND');
+        if (input.runId !== run.id && this.currentExecutionId(run.id) !== input.runId)
+            throw new Error('RUN_EXECUTION_NOT_CURRENT');
+        if (this.approvals.has(input.approvalId))
+            throw new Error('APPROVAL_ALREADY_EXISTS');
+        if (input.expiresAt <= this.now())
+            throw new Error('APPROVAL_EXPIRED');
+        const value = {
+            id: input.approvalId,
+            runId: input.runId,
+            status: 'PENDING',
+            payload: input.payload,
+            expiresAt: input.expiresAt,
+            createdAt: this.now(),
+            decidedAt: null
+        };
+        this.approvals.set(value.id, value);
+        return value;
+    }
+    getApproval(id) {
+        const value = this.approvals.get(id);
+        if (value?.status === 'PENDING' && value.expiresAt <= this.now())
+            return this.expireApproval(id);
+        return value;
+    }
+    listApprovals(runId) {
+        const canonicalRunId = this.canonicalRunId(runId);
+        return [...this.approvals.values()]
+            .filter((value) => this.canonicalRunId(value.runId) === canonicalRunId)
+            .map((value) => this.getApproval(value.id));
+    }
+    expireApproval(id) {
+        const value = this.requireApproval(id);
+        if (value.status !== 'PENDING')
+            return value;
+        if (value.expiresAt > this.now())
+            throw new Error('APPROVAL_NOT_EXPIRED');
+        const next = { ...value, status: 'EXPIRED', decidedAt: this.now() };
+        this.approvals.set(id, next);
+        return next;
+    }
+    decideApproval(id, decision) {
+        const value = this.getApproval(id);
+        if (value === undefined)
+            throw new Error('APPROVAL_NOT_FOUND');
+        if (value.status === 'EXPIRED')
+            throw new Error('APPROVAL_EXPIRED');
+        if (value.status !== 'PENDING')
+            throw new Error('APPROVAL_ALREADY_DECIDED');
+        const next = { ...value, status: decision, decidedAt: this.now() };
+        this.approvals.set(id, next);
+        return next;
+    }
+    expireDueApprovals() {
+        return [...this.approvals.values()]
+            .filter((value) => value.status === 'PENDING' && value.expiresAt <= this.now())
+            .map((value) => this.expireApproval(value.id));
+    }
+    requireApproval(id) {
+        const value = this.approvals.get(id);
+        if (value === undefined)
+            throw new Error('APPROVAL_NOT_FOUND');
+        return value;
+    }
+    removeRuns(runIds, executionIds) {
+        for (const [id, approval] of this.approvals)
+            if (runIds.has(approval.runId) || executionIds.has(approval.runId))
+                this.approvals.delete(id);
+    }
+    removeRun(runId, executionIds) {
+        for (const [id, approval] of this.approvals)
+            if (runId === approval.runId || executionIds.has(approval.runId))
+                this.approvals.delete(id);
+    }
+}