@myagentroam/agent 0.10.59 → 0.10.61

package/dist/agent-core/session/store/images.js

@@ -0,0 +1,248 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { copyFile, lstat, mkdir, open, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { MarAgentError } from '../../error.js';
+export const MAX_INPUT_IMAGES = 5;
+const MAX_INPUT_IMAGE_BYTES = 5 * 1024 * 1024;
+const MAX_INPUT_IMAGES_BYTES = 10 * 1024 * 1024;
+const INPUT_IMAGE_MIME_TYPES = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp']);
+export function generatedImageFileNames(records) {
+    const names = new Set();
+    for (const record of records) {
+        if (record.type !== 'tool.completed' || !isObject(record.payload))
+            continue;
+        const artifacts = record.payload.artifacts;
+        if (!Array.isArray(artifacts))
+            continue;
+        for (const artifact of artifacts) {
+            if (!isObject(artifact) ||
+                artifact.kind !== 'image' ||
+                typeof artifact.fileName !== 'string' ||
+                basename(artifact.fileName) !== artifact.fileName ||
+                !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}\.png$/u.test(artifact.fileName))
+                continue;
+            names.add(artifact.fileName);
+        }
+    }
+    return [...names];
+}
+export async function copyGeneratedImages(sourceSessionDirectory, targetSessionDirectory, fileNames) {
+    if (fileNames.length === 0)
+        return;
+    const source = join(sourceSessionDirectory, 'generated_images');
+    const target = join(targetSessionDirectory, 'generated_images');
+    await mkdir(target, { recursive: true });
+    for (const fileName of fileNames)
+        await copyFile(join(source, fileName), join(target, fileName));
+}
+export function inputImageReferencesFromRecords(records) {
+    const references = new Map();
+    for (const record of records) {
+        if (record.type !== 'turn.user' || !isObject(record.payload))
+            continue;
+        for (const reference of inputImageReferences(record.payload.images)) {
+            const existing = references.get(reference.fileName);
+            if (existing !== undefined &&
+                (existing.mimeType !== reference.mimeType ||
+                    existing.byteSize !== reference.byteSize ||
+                    existing.sha256 !== reference.sha256))
+                throw corruptInputImageReference();
+            references.set(reference.fileName, reference);
+        }
+    }
+    return [...references.values()];
+}
+export function inputImageReferences(value) {
+    if (!Array.isArray(value))
+        return [];
+    const references = [];
+    let totalBytes = 0;
+    for (const image of value) {
+        const reference = inputImageReference(image);
+        if (reference === undefined)
+            continue;
+        totalBytes += reference.byteSize;
+        if (references.length >= MAX_INPUT_IMAGES || totalBytes > MAX_INPUT_IMAGES_BYTES)
+            throw corruptInputImageReference();
+        references.push(reference);
+    }
+    return references;
+}
+export function inputImageReference(value) {
+    if (!isObject(value) || !Object.hasOwn(value, 'fileName'))
+        return undefined;
+    if (typeof value.name !== 'string' ||
+        typeof value.mimeType !== 'string' ||
+        !INPUT_IMAGE_MIME_TYPES.has(value.mimeType) ||
+        typeof value.byteSize !== 'number' ||
+        !Number.isSafeInteger(value.byteSize) ||
+        value.byteSize <= 0 ||
+        value.byteSize > MAX_INPUT_IMAGE_BYTES ||
+        typeof value.fileName !== 'string' ||
+        !validInputImageFileName(value.fileName) ||
+        typeof value.sha256 !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(value.sha256))
+        throw corruptInputImageReference();
+    return {
+        name: value.name,
+        fileName: value.fileName,
+        mimeType: value.mimeType,
+        byteSize: value.byteSize,
+        sha256: value.sha256
+    };
+}
+export function validInputImageFileName(fileName) {
+    return (basename(fileName) === fileName && /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}\.bin$/u.test(fileName));
+}
+export async function readInputImageBytes(directory, reference) {
+    const path = join(directory, reference.fileName);
+    for (let attempt = 0; attempt < 2; attempt++) {
+        let handle;
+        try {
+            const before = await lstat(path);
+            if (!before.isFile() || before.size !== reference.byteSize)
+                throw corruptInputImageReference();
+            const flags = process.platform === 'win32'
+                ? constants.O_RDONLY
+                : constants.O_RDONLY | constants.O_NOFOLLOW;
+            handle = await open(path, flags);
+            const opened = await handle.stat();
+            if (!opened.isFile() ||
+                opened.size !== reference.byteSize ||
+                opened.dev !== before.dev ||
+                opened.ino !== before.ino)
+                continue;
+            const data = await readExactBytes(handle, reference.byteSize);
+            const after = await handle.stat();
+            if (after.size !== opened.size ||
+                after.mtimeMs !== opened.mtimeMs ||
+                after.ctimeMs !== opened.ctimeMs)
+                continue;
+            if (createHash('sha256').update(data).digest('hex') !== reference.sha256)
+                throw corruptInputImageReference();
+            return data;
+        }
+        catch (cause) {
+            if (cause instanceof MarAgentError)
+                throw cause;
+            throw corruptInputImageReference(cause);
+        }
+        finally {
+            await handle?.close();
+        }
+    }
+    throw corruptInputImageReference();
+}
+async function readExactBytes(handle, byteSize) {
+    const data = Buffer.alloc(byteSize);
+    let offset = 0;
+    while (offset < byteSize) {
+        const { bytesRead } = await handle.read(data, offset, byteSize - offset, offset);
+        if (bytesRead === 0)
+            throw corruptInputImageReference();
+        offset += bytesRead;
+    }
+    const extra = Buffer.allocUnsafe(1);
+    if ((await handle.read(extra, 0, 1, byteSize)).bytesRead !== 0)
+        throw corruptInputImageReference();
+    return data;
+}
+export async function copyInputImages(sourceSessionDirectory, targetSessionDirectory, references) {
+    if (references.length === 0)
+        return;
+    const source = join(sourceSessionDirectory, 'input_images');
+    const target = join(targetSessionDirectory, 'input_images');
+    await mkdir(target, { recursive: true, mode: 0o700 });
+    for (const reference of references) {
+        const data = await readInputImageBytes(source, reference);
+        await writeFile(join(target, reference.fileName), data, { mode: 0o600, flag: 'wx' });
+    }
+}
+function corruptInputImageReference(cause) {
+    return new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session input image is corrupt.', {
+        ...(cause === undefined ? {} : { cause })
+    });
+}
+/** A pending marker is removable only after the committed JSONL references are checked. */
+export async function recoverPendingInputImages(sessionDirectory, readHistory) {
+    const directory = join(sessionDirectory, 'input_images');
+    let names;
+    try {
+        names = await readdir(directory);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    const pending = names.filter((name) => /^\.[0-9a-f-]{36}\.bin\.pending$/iu.test(name));
+    const temporary = names.filter((name) => /^\.[0-9a-f-]{36}\.bin\.[0-9a-f-]{36}\.tmp$/iu.test(name));
+    if (pending.length === 0 && temporary.length === 0)
+        return;
+    const referenced = pending.length === 0
+        ? new Set()
+        : new Set(inputImageReferencesFromRecords(await readHistory()).map((image) => image.fileName));
+    for (const name of pending) {
+        const fileName = name.slice(1, -'.pending'.length);
+        if (!referenced.has(fileName))
+            await rm(join(directory, fileName), { force: true });
+        await rm(join(directory, name), { force: true });
+    }
+    for (const name of temporary)
+        await rm(join(directory, name), { force: true });
+}
+export async function writeInputImages(directory, images) {
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const written = [];
+    const pending = [];
+    let temporary;
+    let totalBytes = 0;
+    try {
+        const metadata = [];
+        for (const image of images) {
+            if (!INPUT_IMAGE_MIME_TYPES.has(image.mimeType))
+                throw new MarAgentError('MAR_AGENT_INPUT_CAPABILITY_UNSUPPORTED', 'Image input MIME type is unsupported.');
+            const data = Buffer.from(image.dataBase64, 'base64');
+            totalBytes += data.byteLength;
+            if (data.byteLength === 0 ||
+                data.byteLength > MAX_INPUT_IMAGE_BYTES ||
+                totalBytes > MAX_INPUT_IMAGES_BYTES)
+                throw new MarAgentError('MAR_AGENT_HOST_LIMIT_EXCEEDED', 'Image input exceeds the supported size limit.');
+            const fileName = `${randomUUID()}.bin`;
+            temporary = join(directory, `.${fileName}.${randomUUID()}.tmp`);
+            const handle = await open(temporary, 'wx', 0o600);
+            try {
+                await handle.writeFile(data);
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            const marker = join(directory, `.${fileName}.pending`);
+            await writeFile(marker, '', { mode: 0o600, flag: 'wx', flush: true });
+            pending.push(marker);
+            await rename(temporary, join(directory, fileName));
+            temporary = undefined;
+            written.push(fileName);
+            metadata.push({
+                name: image.name,
+                mimeType: image.mimeType,
+                byteSize: data.byteLength,
+                fileName,
+                sha256: createHash('sha256').update(data).digest('hex')
+            });
+        }
+        return metadata;
+    }
+    catch (error) {
+        if (temporary !== undefined)
+            await rm(temporary, { force: true }).catch(() => undefined);
+        await Promise.all(pending.map((marker) => rm(marker, { force: true })));
+        await Promise.all(written.map((fileName) => rm(join(directory, fileName), { force: true }).catch(() => undefined)));
+        throw error;
+    }
+}
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/agent-core/session/store/index.d.ts

@@ -0,0 +1,4 @@
+export type { SessionListInput, SessionSource } from '../types.js';
+export { compactSummaryFromCheckpoint, inputMetadataFromRecord, parseModelInputMetadata, replacementHistoryFromCheckpoint } from './execution-state.js';
+export { JsonlSessionStore } from './jsonl-store.js';
+export type { CompactHistoryMessage, CompactUserInput, RestoredSessionInputImage, SessionExecutionState, SessionInputImage, SessionInputImageData, SessionInputImageMetadata, SessionRecord } from './types.js';

package/dist/agent-core/session/store/index.js

@@ -0,0 +1,2 @@
+export { compactSummaryFromCheckpoint, inputMetadataFromRecord, parseModelInputMetadata, replacementHistoryFromCheckpoint } from './execution-state.js';
+export { JsonlSessionStore } from './jsonl-store.js';

package/dist/agent-core/session/{jsonl-store.d.ts → store/jsonl-store.d.ts}

@@ -1,23 +1,11 @@
-import { type ToolResultResourceInput } from './tool-result-resources.js';
-import { type CoreCheckpoint, type CoreJsonValue } from '../extensions/data.js';
-import type { ModelInputMetadata, ModelMessage, ModelUsage } from '../model/contracts.js';
-import type { EnvironmentContextState } from '../runtime/context/contracts.js';
-import { type CodeModeStateEntry } from '../tools/code-mode/state.js';
-import { type TodoSnapshot } from '../tools/agent/todo.js';
-import { type ContextGcCheckpointDraft } from './context-gc-checkpoint.js';
-import type { SessionListInput, SessionSource, SessionTitleUpdateInput } from './types.js';
-export type { SessionListInput, SessionSource } from './types.js';
-export interface SessionRecord {
-    schemaVersion: 1;
-    recordId: string;
-    sequence: number;
-    timestamp: string;
-    sessionId: string;
-    executionId?: string;
-    turnId?: string;
-    type: string;
-    payload: unknown;
-}
+import { type CoreCheckpoint, type CoreJsonValue } from '../../extensions/data.js';
+import type { ModelMessage, ModelUsage } from '../../model/contracts.js';
+import type { EnvironmentContextState } from '../../runtime/context/contracts.js';
+import { type CodeModeStateEntry } from '../../tools/code-mode/state.js';
+import { type ContextGcCheckpointDraft } from '../context-gc-checkpoint.js';
+import { type ToolResultResourceInput } from '../tool-result-resources.js';
+import type { SessionListInput, SessionSource, SessionTitleUpdateInput } from '../types.js';
+import type { CompactHistoryMessage, RestoredSessionInputImage, SessionExecutionState, SessionInputImage, SessionInputImageData, SessionInputImageMetadata, SessionMeta, SessionRecord } from './types.js';
 interface SessionRecordInput {
     type: string;
     payload: unknown;
@@ -25,70 +13,6 @@ interface SessionRecordInput {
     turnId?: string;
     timestamp?: string;
 }
-export interface SessionExecutionState {
-    automaticTitlePending: boolean;
-    todo: TodoSnapshot;
-    contextRecords: SessionRecord[];
-}
-export interface CompactUserInput {
-    content: string;
-    metadata?: ModelInputMetadata;
-}
-export interface CompactHistoryMessage extends CompactUserInput {
-    role: 'user';
-    kind: 'user_input' | 'extension_input' | 'summary';
-}
-export interface SessionInputImage {
-    readonly name: string;
-    readonly mimeType: string;
-    readonly dataBase64: string;
-}
-export interface SessionInputImageMetadata {
-    readonly name: string;
-    readonly mimeType: string;
-    readonly byteSize: number;
-    readonly fileName: string;
-    readonly sha256: string;
-}
-export interface RestoredSessionInputImage {
-    readonly mimeType: string;
-    readonly dataBase64: string;
-}
-export interface SessionInputImageData extends SessionInputImageMetadata {
-    readonly dataBase64: string;
-}
-interface SessionMeta {
-    id: string;
-    title: string;
-    workspace: string;
-    createdAt: string;
-    lastActivityAt: string;
-    source?: SessionSource;
-    nextSequence: number;
-    automaticTitlePending?: boolean;
-    storageTransactionId?: string;
-    resume?: {
-        version: 1;
-        compactSequence?: number;
-        gcSequence?: number;
-        gcGeneration?: number;
-        gcBaseSequence?: number;
-        todoSequence?: number;
-        todoRevision: number;
-        executionModelIndexed?: true;
-        firstUserMessageIndexed?: true;
-        firstUserMessagePreview?: string;
-        modelId?: string;
-        modelName?: string;
-        reasoningEffort?: string;
-    };
-    segments?: Array<{
-        number: number;
-        firstSequence: number;
-        lastSequence: number;
-        bytes: number;
-    }>;
-}
 /** SDK-owned JSONL history with per-HOME in-process sharing and cross-process file locks. */
 export declare class JsonlSessionStore {
     #private;
@@ -100,7 +24,6 @@ export declare class JsonlSessionStore {
         workspace: string;
         source?: SessionSource;
     }): Promise<SessionMeta>;
-    sessionDirectory(sessionId: string): string;
     readContextualWorldState(sessionId: string): Promise<unknown | undefined>;
     writeContextualWorldState(sessionId: string, state: unknown): Promise<void>;
     /** Mark each image pending before publication; turn.user or lease recovery resolves ownership. */
@@ -112,7 +35,7 @@ export declare class JsonlSessionStore {
         byteSize: number;
         sha256: string;
     }>;
-    readToolResultResource(sessionId: string, input: ToolResultResourceInput): Promise<import("./tool-result-resources.js").ToolResultResourcePage>;
+    readToolResultResource(sessionId: string, input: ToolResultResourceInput): Promise<import("../tool-result-resources.js").ToolResultResourcePage>;
     readInputImages(sessionId: string, value: unknown): Promise<RestoredSessionInputImage[]>;
     readInputImage(sessionId: string, input: {
         readonly sequence: number;
@@ -178,10 +101,8 @@ export declare class JsonlSessionStore {
         readonly expectedState?: readonly CodeModeStateEntry[];
     }): Promise<CodeModeStateEntry[]>;
     readExecutionState(sessionId: string): Promise<SessionExecutionState>;
-    readContext(sessionId: string): Promise<SessionRecord[]>;
-    contextGcProjectionHash(sessionId: string, boundarySequence: number): Promise<string>;
-    /** Recheck a planned GC checkpoint against authoritative records before appending it. */
-    commitContextGc(sessionId: string, draft: ContextGcCheckpointDraft): Promise<SessionRecord>;
+    /** Compare the planned sequence inside the existing record writer queue. */
+    commitContextGc(sessionId: string, draft: ContextGcCheckpointDraft, planningRecords?: readonly SessionRecord[]): Promise<SessionRecord>;
     readPage(sessionId: string, input?: {
         limit?: number;
         beforeSequence?: number;
@@ -254,13 +175,12 @@ export declare class JsonlSessionStore {
         readonly reasoningEffort?: string;
     } | undefined>;
     sessionTree(sessionId: string): Promise<readonly string[]>;
+    /** Counts native input records, not the post-Compact model context. */
+    userTurnCount(sessionId: string): Promise<number>;
     firstUserMessagePreview(sessionId: string): Promise<string | undefined>;
     delete(sessionId: string): Promise<{
         readonly deleted: boolean;
     }>;
     close(): Promise<void>;
 }
-export declare function compactSummaryFromCheckpoint(record: SessionRecord | undefined): string | undefined;
-export declare function replacementHistoryFromCheckpoint(record: SessionRecord): CompactHistoryMessage[] | undefined;
-export declare function parseModelInputMetadata(value: unknown): ModelInputMetadata | undefined;
-export declare function inputMetadataFromRecord(record: SessionRecord): ModelInputMetadata;
+export {};