@aiwg/cli 2026.7.20 → 2026.7.21

package/dist/src/sessions/adapters/copilot.js

@@ -0,0 +1,226 @@
+import { basename, extname } from 'node:path';
+import { z } from 'zod';
+import { SessionContractError, assertSupportedSchemaMajor, } from '../contracts.js';
+import { readBoundedJson } from '../readers.js';
+export const COPILOT_ADAPTER_VERSION = '1.0.0';
+export const COPILOT_EXPORT_SCHEMA_VERSION = '1.0.0';
+const ResponsePartSchema = z.object({
+    value: z.string().optional(),
+    kind: z.string().optional(),
+}).passthrough();
+const RequestSchema = z.object({
+    requestId: z.string().min(1).optional(),
+    message: z.union([
+        z.string(),
+        z.object({ text: z.string() }).passthrough(),
+    ]),
+    response: z.union([
+        z.string(),
+        z.array(ResponsePartSchema),
+    ]).optional(),
+    timestamp: z.union([z.string(), z.number()]).optional(),
+    modelId: z.string().optional(),
+}).passthrough();
+const ExportSchema = z.object({
+    version: z.union([z.number().int().positive(), z.string()]),
+    schemaVersion: z.string().optional(),
+    sessionId: z.string().min(1).optional(),
+    creationDate: z.union([z.string(), z.number()]).optional(),
+    lastMessageDate: z.union([z.string(), z.number()]).optional(),
+    requests: z.array(RequestSchema),
+    requesterUsername: z.string().optional(),
+    responderUsername: z.string().optional(),
+    state: z.string().optional(),
+    isArchived: z.boolean().optional(),
+    syncStatus: z.string().optional(),
+    workspace: z.object({
+        id: z.string().optional(),
+        repository: z.string().optional(),
+    }).passthrough().optional(),
+}).passthrough();
+export class CopilotSessionAdapter {
+    limits;
+    provider = 'copilot';
+    adapterVersion = COPILOT_ADAPTER_VERSION;
+    disposition = 'implemented';
+    supportedOperations = ['inspect', 'stream'];
+    acquisitionModes = ['manual-export'];
+    constructor(limits) {
+        this.limits = limits;
+    }
+    async *discover(_scope) {
+        // Supported VS Code exports require explicit user selection. Versioned
+        // workspaceStorage JSON/JSONL is intentionally not treated as a stable source.
+    }
+    async inspect(source) {
+        const parsed = await this.readSource(source);
+        return {
+            sourceSchemaVersion: parsed.schemaVersion,
+            consistency: parsed.consistency,
+            operationalState: 'available',
+        };
+    }
+    async *stream(source, cursor) {
+        const parsed = await this.readSource(source);
+        const start = parseCursor(cursor?.value);
+        for (const record of parsed.records.slice(start))
+            yield record;
+    }
+    async readSource(source) {
+        if (source.locatorClass !== 'copilot-chat-json-export') {
+            throw new SessionContractError('UNSUPPORTED_OPERATION', 'Copilot workspace-store parsing is experimental and not enabled by this adapter');
+        }
+        const { value } = await readBoundedJson({
+            selectedPath: source.locator,
+            allowedRoots: source.authorizedScope.allowedRoots,
+        }, this.limits);
+        const parsed = ExportSchema.safeParse(value);
+        if (!parsed.success) {
+            throw new SessionContractError('MALFORMED_SOURCE', 'Copilot chat export is malformed');
+        }
+        const schemaVersion = declaredSchemaVersion(parsed.data);
+        assertSupportedSchemaMajor(schemaVersion);
+        return {
+            schemaVersion,
+            consistency: parsed.data.isArchived || parsed.data.state === 'archived'
+                || parsed.data.state === 'deleted' ? 'complete' : 'provisional',
+            records: normalizeExport(parsed.data, source.locator),
+        };
+    }
+}
+function normalizeExport(value, locator) {
+    const nativeSessionId = value.sessionId ?? basename(locator, extname(locator));
+    const lifecycle = value.isArchived || value.state === 'archived'
+        ? 'archived'
+        : value.state === 'deleted' ? 'deleted' : 'active';
+    const output = [];
+    for (const [requestIndex, request] of value.requests.entries()) {
+        const requestId = request.requestId ?? `request-${requestIndex}`;
+        output.push({
+            nativeSessionId,
+            nativeEventId: `${requestId}:request`,
+            sequence: requestIndex * 2,
+            kind: 'message',
+            role: 'user',
+            occurredAt: timestamp(request.timestamp ?? value.creationDate),
+            text: messageText(request),
+            rawReference: { locatorClass: 'copilot-chat-json-export', sequence: requestIndex },
+            extensions: commonExtensions(value, request, lifecycle, {
+                direction: 'request',
+                unknownFields: unknownFields(request, REQUEST_KEYS),
+                metadataLoss: [],
+            }),
+        });
+        const response = responseText(request);
+        if (response.text !== null) {
+            output.push({
+                nativeSessionId,
+                nativeEventId: `${requestId}:response`,
+                sequence: requestIndex * 2 + 1,
+                kind: 'message',
+                role: 'assistant',
+                occurredAt: timestamp(request.timestamp ?? value.lastMessageDate),
+                text: response.text,
+                rawReference: { locatorClass: 'copilot-chat-json-export', sequence: requestIndex },
+                extensions: commonExtensions(value, request, lifecycle, {
+                    direction: 'response',
+                    unknownFields: response.unknownFields,
+                    metadataLoss: response.losses,
+                }),
+            });
+        }
+    }
+    return output;
+}
+function commonExtensions(value, request, lifecycle, event) {
+    return {
+        ...event,
+        lifecycle,
+        sync: {
+            status: value.syncStatus ?? 'unknown',
+            archiveState: value.isArchived ? 'archived' : 'not-reported',
+            deletionState: value.state === 'deleted' ? 'provider-reported' : 'not-reported',
+        },
+        workspace: {
+            id: value.workspace?.id,
+            repository: value.workspace?.repository,
+        },
+        model: request.modelId,
+        participants: {
+            requester: value.requesterUsername,
+            responder: value.responderUsername,
+        },
+        provenance: {
+            acquisition: 'vscode-chat-json-export',
+            schema: declaredSchemaVersion(value),
+            stableWorkspaceStoreDependency: false,
+            proposedApiDependency: false,
+        },
+        exportUnknownFields: unknownFields(value, EXPORT_KEYS),
+    };
+}
+function responseText(request) {
+    if (typeof request.response === 'string') {
+        return { text: request.response, losses: [], unknownFields: {} };
+    }
+    if (!request.response)
+        return { text: null, losses: [], unknownFields: {} };
+    const text = request.response
+        .map((part) => part.value)
+        .filter((part) => typeof part === 'string')
+        .join('\n\n');
+    const losses = request.response.flatMap((part, index) => (part.kind && part.kind !== 'markdownContent'
+        ? [{
+                field: `response[${index}]`,
+                reason: `structured ${part.kind} part flattened or retained as opaque metadata`,
+            }]
+        : []));
+    return {
+        text,
+        losses,
+        unknownFields: {
+            responseParts: request.response.map((part) => unknownFields(part, RESPONSE_KEYS)),
+        },
+    };
+}
+function messageText(request) {
+    return typeof request.message === 'string' ? request.message : request.message.text;
+}
+function declaredSchemaVersion(value) {
+    if (value.schemaVersion)
+        return value.schemaVersion;
+    const major = typeof value.version === 'number'
+        ? value.version
+        : Number(String(value.version).split('.')[0]);
+    if (!Number.isInteger(major) || major < 1) {
+        throw new SessionContractError('SCHEMA_DRIFT', 'invalid Copilot export version');
+    }
+    return `${major}.0.0`;
+}
+function timestamp(value) {
+    if (value === undefined)
+        return undefined;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+}
+function unknownFields(value, known) {
+    return Object.fromEntries(Object.entries(value).filter(([key]) => !known.has(key)).sort(([a], [b]) => a.localeCompare(b)));
+}
+function parseCursor(value) {
+    if (!value)
+        return 0;
+    if (!/^\d+$/.test(value)) {
+        throw new SessionContractError('SCHEMA_DRIFT', 'invalid Copilot record cursor');
+    }
+    return Number(value);
+}
+const EXPORT_KEYS = new Set([
+    'version', 'schemaVersion', 'sessionId', 'creationDate', 'lastMessageDate',
+    'requests', 'requesterUsername', 'responderUsername', 'state', 'isArchived',
+    'syncStatus', 'workspace',
+]);
+const REQUEST_KEYS = new Set([
+    'requestId', 'message', 'response', 'timestamp', 'modelId',
+]);
+const RESPONSE_KEYS = new Set(['value', 'kind']);
+//# sourceMappingURL=copilot.js.map

package/dist/src/sessions/adapters/cursor.js

@@ -0,0 +1,372 @@
+import { basename, extname } from 'node:path';
+import { z } from 'zod';
+import { SessionContractError, assertSupportedSchemaMajor, } from '../contracts.js';
+import { readBoundedJsonLines, readBoundedText, streamBoundedJsonLines, } from '../readers.js';
+export const CURSOR_ADAPTER_VERSION = '1.0.0';
+export const CURSOR_SOURCE_SCHEMA_VERSION = '1.0.0';
+const CliEventSchema = z.object({
+    schemaVersion: z.string().optional(),
+    cliVersion: z.string().optional(),
+    version: z.string().optional(),
+    type: z.string().min(1),
+    subtype: z.string().optional(),
+    session_id: z.string().min(1),
+    request_id: z.string().optional(),
+    call_id: z.string().optional(),
+    cwd: z.string().optional(),
+    model: z.string().optional(),
+    permissionMode: z.string().optional(),
+    message: z.object({
+        role: z.string().optional(),
+        content: z.array(z.object({
+            type: z.string(),
+            text: z.string().optional(),
+        }).passthrough()).optional(),
+    }).passthrough().optional(),
+    tool_call: z.record(z.unknown()).optional(),
+    result: z.string().optional(),
+    is_error: z.boolean().optional(),
+}).passthrough();
+const CloudEventSchema = z.object({
+    schemaVersion: z.string().optional(),
+    id: z.string().optional(),
+    event_id: z.string().optional(),
+    type: z.string().min(1),
+    agent: z.object({
+        id: z.string().min(1),
+        status: z.string().optional(),
+    }).passthrough().optional(),
+    run: z.object({
+        id: z.string().min(1),
+        status: z.string().optional(),
+    }).passthrough().optional(),
+    data: z.unknown().optional(),
+}).passthrough().refine((value) => value.agent?.id || value.run?.id, {
+    message: 'cloud event requires an agent or run identity',
+});
+export class CursorSessionAdapter {
+    limits;
+    provider = 'cursor';
+    adapterVersion = CURSOR_ADAPTER_VERSION;
+    disposition = 'implemented';
+    supportedOperations = ['inspect', 'stream'];
+    acquisitionModes = ['api', 'jsonl', 'manual-export'];
+    constructor(limits) {
+        this.limits = limits;
+    }
+    async *discover(_scope) {
+        // Every supported Cursor surface requires an explicitly selected export.
+        // The undocumented editor SQLite store is intentionally excluded.
+    }
+    async inspect(source) {
+        const parsed = await this.readSource(source);
+        return {
+            sourceSchemaVersion: parsed.schemaVersion,
+            consistency: parsed.consistency,
+            operationalState: 'available',
+        };
+    }
+    async *stream(source, cursor) {
+        if (source.locatorClass === 'cursor-cli-stream-json'
+            || source.locatorClass === 'cursor-cloud-events-jsonl') {
+            const input = await streamBoundedJsonLines({
+                selectedPath: source.locator,
+                allowedRoots: source.authorizedScope.allowedRoots,
+            }, { consistency: 'provisional', limits: this.limits });
+            const start = parseCursor(cursor?.value);
+            let outputIndex = 0;
+            let schemaVersion = null;
+            let cliSessionId;
+            let agentId;
+            let runId;
+            let sawRecord = false;
+            for await (const line of input) {
+                sawRecord = true;
+                const raw = asObject(line.value);
+                const currentSchema = typeof raw.schemaVersion === 'string'
+                    ? raw.schemaVersion : CURSOR_SOURCE_SCHEMA_VERSION;
+                if (schemaVersion && schemaVersion !== currentSchema) {
+                    throw new SessionContractError('SCHEMA_DRIFT', 'Cursor source declares mixed schema versions');
+                }
+                schemaVersion = currentSchema;
+                assertSupportedSchemaMajor(schemaVersion);
+                let record;
+                if (source.locatorClass === 'cursor-cli-stream-json') {
+                    const parsed = CliEventSchema.safeParse(line.value);
+                    if (!parsed.success) {
+                        throw new SessionContractError('MALFORMED_SOURCE', 'Cursor CLI event is malformed');
+                    }
+                    const event = parsed.data;
+                    if (cliSessionId && cliSessionId !== event.session_id) {
+                        throw new SessionContractError('DUPLICATE_NATIVE_ID', 'Cursor CLI stream changes session identity');
+                    }
+                    cliSessionId = event.session_id;
+                    record = normalizeCli([line]).records[0];
+                }
+                else {
+                    const parsed = CloudEventSchema.safeParse(line.value);
+                    if (!parsed.success) {
+                        throw new SessionContractError('MALFORMED_SOURCE', 'Cursor Cloud Agent event is malformed');
+                    }
+                    const event = parsed.data;
+                    const nextAgentId = event.agent?.id ?? agentId;
+                    const nextRunId = event.run?.id ?? runId;
+                    if (agentId && nextAgentId && agentId !== nextAgentId) {
+                        throw new SessionContractError('DUPLICATE_NATIVE_ID', 'Cursor cloud stream changes agent identity');
+                    }
+                    if (runId && nextRunId && runId !== nextRunId) {
+                        throw new SessionContractError('DUPLICATE_NATIVE_ID', 'Cursor cloud stream changes run identity');
+                    }
+                    agentId = nextAgentId;
+                    runId = nextRunId;
+                    record = normalizeCloud([{
+                            ...line,
+                            value: {
+                                ...event,
+                                agent: event.agent ?? (agentId ? { id: agentId } : undefined),
+                                run: event.run ?? (runId ? { id: runId } : undefined),
+                            },
+                        }]).records[0];
+                }
+                if (outputIndex++ >= start)
+                    yield record;
+            }
+            if (!sawRecord && !input.incompleteTail) {
+                throw new SessionContractError('MALFORMED_SOURCE', 'Cursor structured source is empty');
+            }
+            return;
+        }
+        const parsed = await this.readSource(source);
+        const start = parseCursor(cursor?.value);
+        for (const record of parsed.records.slice(start))
+            yield record;
+    }
+    async readSource(source) {
+        const authorization = {
+            selectedPath: source.locator,
+            allowedRoots: source.authorizedScope.allowedRoots,
+        };
+        if (source.locatorClass === 'cursor-editor-sqlite') {
+            throw new SessionContractError('UNSUPPORTED_OPERATION', 'Cursor editor SQLite is undocumented and unsupported; export the chat as Markdown');
+        }
+        if (source.locatorClass === 'cursor-editor-markdown') {
+            const input = await readBoundedText(authorization, this.limits);
+            return {
+                schemaVersion: CURSOR_SOURCE_SCHEMA_VERSION,
+                consistency: 'complete',
+                records: normalizeMarkdown(input.value, source.locator),
+            };
+        }
+        const input = await readBoundedJsonLines(authorization, { consistency: 'provisional', limits: this.limits });
+        if (input.records.length === 0 && !input.incompleteTail) {
+            throw new SessionContractError('MALFORMED_SOURCE', 'Cursor structured source is empty');
+        }
+        const schemaVersion = declaredVersion(input.records);
+        assertSupportedSchemaMajor(schemaVersion);
+        if (source.locatorClass === 'cursor-cli-stream-json') {
+            const normalized = normalizeCli(input.records);
+            return {
+                schemaVersion,
+                consistency: normalized.complete && !input.incompleteTail ? 'complete' : 'provisional',
+                records: normalized.records,
+            };
+        }
+        if (source.locatorClass === 'cursor-cloud-events-jsonl') {
+            const normalized = normalizeCloud(input.records);
+            return {
+                schemaVersion,
+                consistency: normalized.complete && !input.incompleteTail ? 'complete' : 'provisional',
+                records: normalized.records,
+            };
+        }
+        throw new SessionContractError('UNSUPPORTED_OPERATION', 'unsupported Cursor source class');
+    }
+}
+function normalizeCli(input) {
+    const records = [];
+    let sessionId;
+    let complete = false;
+    for (const line of input) {
+        const parsed = CliEventSchema.safeParse(line.value);
+        if (!parsed.success) {
+            throw new SessionContractError('MALFORMED_SOURCE', 'Cursor CLI event is malformed');
+        }
+        const event = parsed.data;
+        if (sessionId && sessionId !== event.session_id) {
+            throw new SessionContractError('DUPLICATE_NATIVE_ID', 'Cursor CLI stream changes session identity');
+        }
+        sessionId = event.session_id;
+        complete ||= event.type === 'result' && event.subtype === 'success' && event.is_error !== true;
+        const text = event.type === 'result'
+            ? (event.result ?? '')
+            : (event.message?.content ?? []).flatMap((part) => part.text ?? []).join('');
+        records.push({
+            nativeSessionId: event.session_id,
+            nativeEventId: event.call_id ?? event.request_id ?? `${event.type}:${line.sequence}`,
+            sequence: line.sequence,
+            kind: event.type === 'tool_call' ? `tool.${event.subtype ?? 'event'}` : event.type,
+            role: event.message?.role ?? (event.type === 'system' ? 'system' : undefined),
+            participant: event.message?.role ?? (event.type === 'system' ? 'system' : undefined),
+            model: event.model,
+            toolName: typeof asObject(event.tool_call).name === 'string'
+                ? String(asObject(event.tool_call).name) : undefined,
+            toolCallId: event.call_id,
+            text,
+            rawReference: { locatorClass: 'cursor-cli-stream-json', offset: line.byteOffset },
+            extensions: {
+                subtype: event.subtype,
+                cwd: event.cwd,
+                model: event.model,
+                permissionMode: event.permissionMode,
+                productVersion: event.cliVersion ?? event.version ?? 'not-reported',
+                toolCall: event.tool_call,
+                lifecycle: complete ? 'complete' : 'active',
+                provenance: { acquisition: 'cursor-cli-stream-json', schema: declaredEventVersion(event) },
+                unknownFields: unknownFields(event, CLI_KEYS),
+            },
+        });
+    }
+    return { records, complete };
+}
+function normalizeCloud(input) {
+    const records = [];
+    let agentId;
+    let runId;
+    let complete = false;
+    for (const line of input) {
+        const parsed = CloudEventSchema.safeParse(line.value);
+        if (!parsed.success) {
+            throw new SessionContractError('MALFORMED_SOURCE', 'Cursor Cloud Agent event is malformed');
+        }
+        const event = parsed.data;
+        const nextAgentId = event.agent?.id ?? agentId;
+        const nextRunId = event.run?.id ?? runId;
+        if (agentId && nextAgentId && agentId !== nextAgentId) {
+            throw new SessionContractError('DUPLICATE_NATIVE_ID', 'Cursor cloud stream changes agent identity');
+        }
+        if (runId && nextRunId && runId !== nextRunId) {
+            throw new SessionContractError('DUPLICATE_NATIVE_ID', 'Cursor cloud stream changes run identity');
+        }
+        agentId = nextAgentId;
+        runId = nextRunId;
+        const status = event.run?.status ?? event.agent?.status;
+        complete ||= isTerminal(status) || event.type === 'agent.deleted' || event.type === 'agent.archived';
+        const sessionId = runId ? `${agentId ?? 'agent'}:${runId}` : agentId;
+        records.push({
+            nativeSessionId: sessionId,
+            nativeEventId: event.event_id ?? event.id ?? `${event.type}:${line.sequence}`,
+            sequence: line.sequence,
+            kind: `cursor.cloud.${event.type}`,
+            role: 'system',
+            text: extractCloudText(event.data),
+            rawReference: { locatorClass: 'cursor-cloud-events-jsonl', offset: line.byteOffset },
+            extensions: {
+                agent: event.agent,
+                run: event.run,
+                status,
+                lifecycle: cloudLifecycle(event.type, status),
+                reconnect: {
+                    eventId: event.event_id ?? event.id,
+                    supported: true,
+                    header: 'Last-Event-ID',
+                },
+                provenance: { acquisition: 'cursor-cloud-agents-api-v1', schema: declaredEventVersion(event) },
+                unknownFields: unknownFields(event, CLOUD_KEYS),
+            },
+        });
+    }
+    return { records, complete };
+}
+function normalizeMarkdown(value, locator) {
+    const heading = /^#{1,3}\s+(User|Assistant|Cursor)\s*$/gim;
+    const matches = [...value.matchAll(heading)];
+    if (matches.length === 0) {
+        throw new SessionContractError('MALFORMED_SOURCE', 'Cursor Markdown export has no role headings');
+    }
+    const nativeSessionId = basename(locator, extname(locator));
+    return matches.map((match, index) => {
+        const start = match.index + match[0].length;
+        const end = matches[index + 1]?.index ?? value.length;
+        const role = match[1].toLowerCase() === 'user' ? 'user' : 'assistant';
+        return {
+            nativeSessionId,
+            nativeEventId: `markdown:${index}`,
+            sequence: index,
+            kind: 'message',
+            role,
+            text: value.slice(start, end).trim(),
+            rawReference: { locatorClass: 'cursor-editor-markdown', sequence: index },
+            extensions: {
+                metadataLoss: [
+                    'timestamps unavailable',
+                    'model unavailable',
+                    'tool calls and results unavailable',
+                    'provider lifecycle unavailable',
+                ],
+                provenance: {
+                    acquisition: 'cursor-editor-markdown-export',
+                    nativeSessionIdDerivedFromFilename: true,
+                    undocumentedSqliteDependency: false,
+                },
+            },
+        };
+    });
+}
+function declaredVersion(records) {
+    const versions = new Set(records.map((line) => {
+        const value = asObject(line.value);
+        return typeof value.schemaVersion === 'string' ? value.schemaVersion : CURSOR_SOURCE_SCHEMA_VERSION;
+    }));
+    if (versions.size !== 1) {
+        throw new SessionContractError('SCHEMA_DRIFT', 'Cursor source declares mixed schema versions');
+    }
+    return [...versions][0];
+}
+function declaredEventVersion(event) {
+    return event.schemaVersion ?? CURSOR_SOURCE_SCHEMA_VERSION;
+}
+function extractCloudText(value) {
+    const object = asObject(value);
+    if (typeof object.text === 'string')
+        return object.text;
+    if (typeof object.message === 'string')
+        return object.message;
+    return '';
+}
+function cloudLifecycle(type, status) {
+    if (type === 'agent.deleted')
+        return 'deleted';
+    if (type === 'agent.archived')
+        return 'archived';
+    if (type === 'agent.unarchived')
+        return 'active';
+    if (status === 'cancelled' || status === 'canceled')
+        return 'cancelled';
+    return isTerminal(status) ? 'complete' : 'active';
+}
+function isTerminal(status) {
+    return ['completed', 'failed', 'cancelled', 'canceled'].includes(status ?? '');
+}
+function unknownFields(value, known) {
+    return Object.fromEntries(Object.entries(value).filter(([key]) => !known.has(key)).sort(([a], [b]) => a.localeCompare(b)));
+}
+function asObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function parseCursor(value) {
+    if (!value)
+        return 0;
+    if (!/^\d+$/.test(value)) {
+        throw new SessionContractError('SCHEMA_DRIFT', 'invalid Cursor record cursor');
+    }
+    return Number(value);
+}
+const CLI_KEYS = new Set([
+    'schemaVersion', 'type', 'subtype', 'session_id', 'request_id', 'call_id', 'cwd',
+    'model', 'permissionMode', 'cliVersion', 'version', 'message', 'tool_call', 'result', 'is_error',
+    'duration_ms', 'duration_api_ms',
+]);
+const CLOUD_KEYS = new Set(['schemaVersion', 'id', 'event_id', 'type', 'agent', 'run', 'data']);
+//# sourceMappingURL=cursor.js.map