@myagentroam/node 0.11.35 → 0.11.37

package/dist/hosting/hosted-conversation-templates.js

@@ -0,0 +1,280 @@
+import { lstat, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { marAgentRuntimeModelConfigurationSchema } from '@myagentroam/protocol';
+import { assertMcpServerNames } from '../mcp/naming.js';
+import { parseTemplateVersionManifest, templateContentHash, templateMcpConfigHash, templateManifestHash } from '../service/conversation-template-manifest.js';
+const HOST_POLICY_VERSION = 1;
+export class HostedConversationTemplates {
+    database;
+    store;
+    nodeId;
+    processExecutorFactory;
+    constructor(database, store, nodeId, processExecutorFactory) {
+        this.database = database;
+        this.store = store;
+        this.nodeId = nodeId;
+        this.processExecutorFactory = processExecutorFactory;
+    }
+    pathMounts(paths, version, generatedImagesDirectory, generatedImagesLogicalPath, temporaryDirectory) {
+        const mounts = [
+            {
+                logicalPath: '/workspace',
+                physicalPath: version.templateDirectory,
+                writable: false
+            },
+            {
+                logicalPath: '/workspace/inbox',
+                physicalPath: paths.uploadsDirectory,
+                writable: true
+            },
+            {
+                logicalPath: '/workspace/output',
+                physicalPath: paths.outputDirectory,
+                writable: true
+            }
+        ];
+        if (temporaryDirectory !== undefined)
+            mounts.push({
+                logicalPath: '/tmp',
+                physicalPath: temporaryDirectory,
+                writable: true
+            });
+        if (generatedImagesDirectory !== undefined && generatedImagesLogicalPath !== undefined)
+            mounts.push({
+                logicalPath: generatedImagesLogicalPath,
+                physicalPath: generatedImagesDirectory,
+                writable: false
+            });
+        if (version.sourceWorkspacePath !== undefined)
+            mounts.push({
+                logicalPath: version.sourceWorkspacePath,
+                physicalPath: version.templateDirectory,
+                writable: false
+            }, {
+                logicalPath: join(version.sourceWorkspacePath, 'inbox'),
+                physicalPath: paths.uploadsDirectory,
+                writable: true
+            }, {
+                logicalPath: join(version.sourceWorkspacePath, 'output'),
+                physicalPath: paths.outputDirectory,
+                writable: true
+            });
+        return mounts;
+    }
+    processExecutor(paths, version, temporaryDirectory = paths.temporaryRootDirectory, generatedImagesDirectory, generatedImagesLogicalPath) {
+        return this.processExecutorFactory({
+            workspaceDirectory: version.templateDirectory,
+            sourceWorkspacePath: version.sourceWorkspacePath,
+            inboxDirectory: paths.uploadsDirectory,
+            outputDirectory: paths.outputDirectory,
+            ...(generatedImagesDirectory === undefined || generatedImagesLogicalPath === undefined
+                ? {}
+                : { generatedImagesDirectory, generatedImagesLogicalPath }),
+            temporaryDirectory,
+            networkMode: version.draft.networkMode
+        });
+    }
+    latestAvailableTemplateVersionId(templateId) {
+        const row = this.database.raw
+            .prepare(`SELECT id FROM conversation_template_versions
+         WHERE template_id=? AND status='AVAILABLE'
+         ORDER BY version_number DESC,published_at DESC,id DESC
+         LIMIT 1`)
+            .get(templateId);
+        if (row === undefined)
+            return undefined;
+        if (typeof row.id !== 'string')
+            throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+        return row.id;
+    }
+    async loadTemplateVersion(versionId, templateId) {
+        const row = this.database.raw
+            .prepare(`SELECT id,template_id,status,storage_key,manifest,content_hash,manifest_hash,mcp_config_hash,
+                file_count,total_bytes,host_policy_version
+         FROM conversation_template_versions WHERE id=? AND template_id=?`)
+            .get(versionId, templateId);
+        if (row === undefined ||
+            (row.status !== 'AVAILABLE' && row.status !== 'RETAINED') ||
+            row.host_policy_version !== HOST_POLICY_VERSION ||
+            typeof row.storage_key !== 'string' ||
+            typeof row.manifest !== 'string' ||
+            typeof row.content_hash !== 'string' ||
+            typeof row.manifest_hash !== 'string' ||
+            typeof row.mcp_config_hash !== 'string')
+            throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+        const versionDirectory = this.store.templateVersionDirectory(row.storage_key);
+        const manifestPath = join(versionDirectory, 'manifest.json');
+        const contentDirectory = join(versionDirectory, 'content');
+        const manifestInfo = await lstat(manifestPath).catch(() => undefined);
+        const contentInfo = await lstat(contentDirectory).catch(() => undefined);
+        if (manifestInfo === undefined ||
+            !manifestInfo.isFile() ||
+            manifestInfo.isSymbolicLink() ||
+            contentInfo === undefined ||
+            !contentInfo.isDirectory() ||
+            contentInfo.isSymbolicLink() ||
+            (contentInfo.mode & 0o777) !== 0o555)
+            throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+        let persisted;
+        try {
+            const manifestText = await readFile(manifestPath, 'utf8');
+            const manifestJson = manifestText.endsWith('\n') ? manifestText.slice(0, -1) : manifestText;
+            if (manifestJson !== row.manifest || templateManifestHash(manifestText) !== row.manifest_hash)
+                throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+            persisted = JSON.parse(manifestJson);
+        }
+        catch {
+            throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+        }
+        if (!record(persisted))
+            throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+        const snapshot = parseTemplateVersionManifest(persisted);
+        const { allowedModels, defaultModelId, ...draft } = snapshot.draft;
+        const mcpServers = snapshot.mcpServers;
+        const contentHash = templateContentHash(snapshot.directories, snapshot.entries);
+        const totalBytes = snapshot.entries.reduce((total, entry) => total + entry.size, 0);
+        if (snapshot.mcpConfigHash !== row.mcp_config_hash ||
+            templateMcpConfigHash(mcpServers) !== row.mcp_config_hash ||
+            snapshot.contentHash !== row.content_hash ||
+            contentHash !== row.content_hash ||
+            row.file_count !== snapshot.entries.length ||
+            row.total_bytes !== totalBytes)
+            throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+        if (persisted.versionId !== versionId ||
+            persisted.templateId !== templateId ||
+            persisted.hostPolicyVersion !== HOST_POLICY_VERSION ||
+            draft.templateId !== templateId ||
+            draft.nodeId !== this.nodeId())
+            throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
+        return {
+            id: versionId,
+            templateId,
+            storageKey: row.storage_key,
+            templateDirectory: contentDirectory,
+            sourceWorkspacePath: snapshot.sourceWorkspacePath,
+            draft,
+            modelPolicy: {
+                allowedIds: allowedModels.map((model) => model.modelId),
+                defaultId: defaultModelId
+            },
+            mcpServers
+        };
+    }
+}
+export function runtimeModels(value) {
+    return marAgentRuntimeModelConfigurationSchema
+        .array()
+        .parse(value);
+}
+export function allowedModels(version, models) {
+    const allowed = new Set(version.modelPolicy.allowedIds);
+    return models.filter((model) => model.enabled && allowed.has(model.modelId));
+}
+export function selectModel(version, models, requestedModelId) {
+    const available = allowedModels(version, models).filter((model) => model.conversationModel !== false);
+    const requested = available.find((candidate) => candidate.id === requestedModelId);
+    if (requested !== undefined)
+        return requested;
+    if (models.some((candidate) => candidate.id === requestedModelId && candidate.conversationModel === false))
+        throw new Error('HOSTED_CONVERSATION_MODEL_NOT_AVAILABLE');
+    const defaultModel = available.find((candidate) => candidate.modelId === version.modelPolicy.defaultId);
+    if (defaultModel !== undefined)
+        return defaultModel;
+    const model = version.modelPolicy.allowedIds
+        .map((allowedId) => available.find((candidate) => candidate.modelId === allowedId))
+        .find((candidate) => candidate !== undefined);
+    if (model === undefined)
+        throw new Error('HOSTED_CONVERSATION_MODEL_NOT_AVAILABLE');
+    return model;
+}
+export function networkModels(models, networkMode) {
+    if (networkMode !== 'NONE')
+        return models;
+    return models.map((model) => model.hostedWebSearch ? { ...model, hostedWebSearch: false } : model);
+}
+export function resolveMcpServers(version, environment) {
+    const resolveReferences = (references) => {
+        const resolved = {};
+        for (const [name, reference] of Object.entries(references ?? {})) {
+            const value = environment[reference.secretName];
+            if (value === undefined)
+                throw new Error('CONVERSATION_TEMPLATE_MCP_INVALID');
+            resolved[name] = value;
+        }
+        return resolved;
+    };
+    assertMcpServerNames(version.mcpServers.map((server) => ({ name: server.serverName })));
+    return version.mcpServers.flatMap((server) => {
+        if (server.runtime.transport === 'HTTP') {
+            if (version.draft.networkMode !== 'UNRESTRICTED')
+                return [];
+            return [
+                {
+                    name: server.serverName,
+                    lifecycle: 'EXECUTION',
+                    transport: 'HTTP',
+                    url: server.runtime.url,
+                    headers: {
+                        ...resolveReferences(server.runtime.headers),
+                        ...resolveReferences(server.configuration.headers)
+                    }
+                }
+            ];
+        }
+        return [
+            {
+                name: server.serverName,
+                lifecycle: 'EXECUTION',
+                transport: 'STDIO',
+                command: server.runtime.command,
+                args: [...server.runtime.args, ...(server.configuration.arguments ?? [])],
+                environment: {
+                    ...resolveReferences(server.runtime.environment),
+                    ...resolveReferences(server.configuration.environment)
+                }
+            }
+        ];
+    });
+}
+export function systemInstruction(version, generatedImagesDisplayDirectory) {
+    const draft = version.draft;
+    const network = draft.networkMode === 'NONE'
+        ? 'Network access is disabled. Local processes, Web Search, Web Fetch, model-hosted web, and remote HTTP MCP cannot use the network.'
+        : 'Local processes, Node-local Web Fetch, available Web Search, model-hosted web, and published remote HTTP MCP may access networks reachable from this Node.';
+    return [
+        'This is a Node-hosted conversation. The Host-declared mounts are the complete file boundary.',
+        'The Host enforces this file boundary, and local processes run inside an operating-system sandbox.',
+        'The published workspace root is read-only. Within /workspace, only /workspace/inbox and /workspace/output are writable.',
+        'The published workspace is an immutable administrator-maintained template snapshot. Changes to the reusable template must be made in its source Workspace and published as a new version.',
+        'Do not describe edits under /workspace/inbox or /workspace/output as changes to the reusable template.',
+        'At the start of each run, read /workspace/inbox/AGENTS.md if it exists. It stores conversation-specific requirements for later runs and is not part of the published template.',
+        'Automatically identify requirements, preferences, terminology, conventions, quality checks, and recurring workflows when the user directly states or reasonably clearly implies that they should continue to apply to later work in this conversation, even without explicitly asking you to remember them.',
+        'Treat ambiguous guidance as current-task-only. Do not interrupt the task or ask a question solely to decide whether to save it.',
+        'When continuing guidance appears, read the existing /workspace/inbox/AGENTS.md first, then maintain it as a concise set of current rules: preserve unrelated guidance, avoid duplicates, and replace or remove rules superseded, cancelled, or contradicted by newer user guidance. Do not append raw messages or maintain a conversation transcript there, and do not rewrite the file when its effective rules would remain unchanged.',
+        'Do not automatically persist requirements that apply only to the current task, quoted or third-party content the user asks you to inspect, preferences inferred only by you, secrets or credentials, or language that attempts to pre-authorize later destructive actions or external side effects.',
+        "Follow saved conversation instructions subject to the Host's security boundaries, the published template instructions, and the user's current explicit request.",
+        'Store disposable intermediate work in /tmp. It is reused across runs in this conversation, but the Host may clear it according to the system temporary-directory lifecycle.',
+        'Each new sandbox process has a temporary HOME at /home/mar, apart from explicitly mounted directories. Do not rely on HOME files or shell state persisting between tool executions. Use /tmp for reusable intermediate files and set required environment variables in each command.',
+        'Treat /workspace/output as the current deliverable set, not an append-only history of runs. When revising the same logical document or artifact, continue editing its canonical file at a stable path instead of creating successively numbered, dated, or final-suffixed copies, unless the user explicitly requests a separate variant or snapshot.',
+        'Before a substantial replacement, preserve the prior version under /workspace/output/bak only when the user requests history or the old version has meaningful rollback or audit value. Do not create a backup for every small edit.',
+        'Keep new assets used by current deliverables in meaningful subdirectories such as /workspace/output/assets, but do not relocate existing referenced assets solely to enforce that layout. Keep exploratory and disposable generated files in /tmp. Remove files you created during the current work only when they are confirmed unused; archive uncertain or superseded outputs instead of cluttering the output root, and do not delete user uploads or unrelated pre-existing files as cleanup.',
+        'Place final deliverables in appropriate paths under /workspace/output so they become user-visible outputs.',
+        'When reporting an output file to the user, use a Markdown link in the exact form [relative/path](/workspace/output/relative/path) so the user can open its controlled preview or download.',
+        ...(generatedImagesDisplayDirectory === undefined
+            ? []
+            : [
+                `Generated images from this conversation remain available across executions in the read-only ${generatedImagesDisplayDirectory} directory.`,
+                `When the user asks to place a previously generated image in output, inspect ${generatedImagesDisplayDirectory} and copy the existing file from ${generatedImagesDisplayDirectory} to /workspace/output when available. If it is missing, report that fact; regenerate only when requested or authorized by the user.`
+            ]),
+        ...(version.sourceWorkspacePath === undefined
+            ? []
+            : [
+                `The published workspace is also mounted read-only at ${version.sourceWorkspacePath} as a compatibility alias; it is the same immutable snapshot, not the live source Workspace. ${join(version.sourceWorkspacePath, 'inbox')} and ${join(version.sourceWorkspacePath, 'output')} are aliases of the same writable overlays.`
+            ]),
+        'Read user uploads from /workspace/inbox.',
+        network
+    ].join('\n');
+}
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/hosting/hosted-conversation-uploads.js

@@ -0,0 +1,344 @@
+import { assertRegularFile } from './hosted-conversation-file-identity.js';
+import { lstat, open, rename, rm, utimes } from 'node:fs/promises';
+import { join } from 'node:path';
+import { hostedConversationUploadChunkInputSchema, hostedConversationUploadControlInputSchema, hostedConversationUploadCreateInputSchema, hostedConversationUploadPreflightInputSchema, hostedConversationUploadPreflightResultSchema, hostedConversationUploadSchema } from '@myagentroam/protocol';
+/** Owns Hosted upload admission, name reservations and temporary files. */
+export class HostedConversationUploads {
+    options;
+    now;
+    id;
+    uploads = new Map();
+    uploadsByRequest = new Map();
+    pendingUploadCreates = new Map();
+    uploadNameReservations = new Map();
+    constructor(options, now, id) {
+        this.options = options;
+        this.now = now;
+        this.id = id;
+    }
+    busy(conversationId) {
+        return [...this.uploads.values()].some((upload) => upload.conversationId === conversationId && upload.status === 'UPLOADING');
+    }
+    async close() {
+        await Promise.allSettled([...this.uploads.values()].map(async (upload) => {
+            if (upload.status === 'UPLOADING') {
+                upload.status = 'CANCELLED';
+                await rm(upload.temporaryPath, { force: true });
+            }
+        }));
+        this.uploads.clear();
+        this.uploadsByRequest.clear();
+        this.uploadNameReservations.clear();
+    }
+    async preflightUpload(raw) {
+        const payload = this.options.request(raw);
+        const input = hostedConversationUploadPreflightInputSchema.parse(payload.data);
+        const conversation = this.options.requireWritableConversation(payload.userId, input.conversationId);
+        const version = await this.options.loadTemplateVersion(conversation.activeVersionId, conversation.templateId);
+        const files = await Promise.all(input.files.map(async (file) => ({
+            name: file.name,
+            status: await this.uploadPreflightStatus(conversation, version.draft, file.name, file.size)
+        })));
+        return hostedConversationUploadPreflightResultSchema.parse({ files });
+    }
+    async createUpload(raw) {
+        const payload = this.options.request(raw);
+        const input = hostedConversationUploadCreateInputSchema.parse(payload.data);
+        const conversation = this.options.requireWritableConversation(payload.userId, input.conversationId);
+        const requestKey = `${payload.userId}\0${conversation.id}\0${input.clientRequestId}`;
+        const existingId = this.uploadsByRequest.get(requestKey);
+        if (existingId !== undefined) {
+            const existing = this.uploads.get(existingId);
+            if (existing !== undefined)
+                return { upload: hostedConversationUploadSchema.parse(uploadProjection(existing)) };
+        }
+        const pending = this.pendingUploadCreates.get(requestKey);
+        if (pending !== undefined)
+            return pending;
+        const operation = this.createUploadForRequest(payload, input, conversation, requestKey);
+        this.pendingUploadCreates.set(requestKey, operation);
+        void operation
+            .finally(() => {
+            if (this.pendingUploadCreates.get(requestKey) === operation)
+                this.pendingUploadCreates.delete(requestKey);
+        })
+            .catch(() => undefined);
+        return operation;
+    }
+    async createUploadForRequest(payload, input, conversation, requestKey) {
+        const version = await this.options.loadTemplateVersion(conversation.activeVersionId, conversation.templateId);
+        const paths = this.options.store.pathsForConversation(payload.userId, conversation.id);
+        const status = await this.uploadPreflightStatus(conversation, version.draft, input.name, input.size);
+        if (status === 'QUOTA_EXCEEDED' || status === 'TOO_LARGE')
+            throw new Error('HOSTED_CONVERSATION_QUOTA_EXCEEDED');
+        if (status !== 'READY')
+            throw new Error('HOSTED_CONVERSATION_FILE_INVALID');
+        const uploadId = this.id();
+        const temporaryPath = join(paths.uploadsDirectory, `.${uploadId}.upload`);
+        const name = await this.allocateUploadName(paths, payload.userId, conversation.id, input.name);
+        const targetPath = join(paths.uploadsDirectory, name);
+        try {
+            const handle = await open(temporaryPath, 'wx', 0o600);
+            await handle.close();
+        }
+        catch (error) {
+            this.releaseUploadName(conversation.id, name);
+            throw error;
+        }
+        const upload = {
+            uploadId,
+            conversationId: conversation.id,
+            userId: payload.userId,
+            clientRequestId: input.clientRequestId,
+            name,
+            mimeType: input.mimeType,
+            size: input.size,
+            temporaryPath,
+            targetPath,
+            receivedBytes: 0,
+            status: 'UPLOADING'
+        };
+        this.uploads.set(uploadId, upload);
+        this.uploadsByRequest.set(requestKey, uploadId);
+        return { upload: hostedConversationUploadSchema.parse(uploadProjection(upload)) };
+    }
+    async writeUploadChunk(raw) {
+        const payload = this.options.request(raw);
+        const input = hostedConversationUploadChunkInputSchema.parse(payload.data);
+        const upload = this.requireUpload(payload.userId, input.conversationId, input.uploadId);
+        if (upload.status !== 'UPLOADING')
+            throw new Error('HOSTED_CONVERSATION_UPLOAD_STATE_INVALID');
+        if (input.offset !== upload.receivedBytes)
+            throw new Error('HOSTED_CONVERSATION_UPLOAD_OFFSET_INVALID');
+        const chunk = Buffer.from(input.dataBase64, 'base64');
+        if (upload.receivedBytes + chunk.byteLength > upload.size)
+            throw new Error('HOSTED_CONVERSATION_UPLOAD_SIZE_INVALID');
+        await assertUploadTemporaryFile(upload.temporaryPath, upload.receivedBytes);
+        const handle = await open(upload.temporaryPath, 'r+');
+        try {
+            await handle.write(chunk, 0, chunk.byteLength, upload.receivedBytes);
+        }
+        finally {
+            await handle.close();
+        }
+        upload.receivedBytes += chunk.byteLength;
+        return { upload: hostedConversationUploadSchema.parse(uploadProjection(upload)) };
+    }
+    uploadStatus(raw) {
+        const payload = this.options.request(raw);
+        const input = hostedConversationUploadControlInputSchema.parse(payload.data);
+        const upload = this.requireUpload(payload.userId, input.conversationId, input.uploadId);
+        return { upload: hostedConversationUploadSchema.parse(uploadProjection(upload)) };
+    }
+    async completeUpload(raw) {
+        const payload = this.options.request(raw);
+        const input = hostedConversationUploadControlInputSchema.parse(payload.data);
+        const upload = this.requireUpload(payload.userId, input.conversationId, input.uploadId);
+        if (upload.status === 'COMPLETED')
+            return { upload: hostedConversationUploadSchema.parse(uploadProjection(upload)) };
+        if (upload.status !== 'UPLOADING' || upload.receivedBytes !== upload.size)
+            throw new Error('HOSTED_CONVERSATION_UPLOAD_INCOMPLETE');
+        const conversation = this.options.requireWritableConversation(payload.userId, upload.conversationId);
+        const version = await this.options.loadTemplateVersion(conversation.activeVersionId, conversation.templateId);
+        if (upload.size > version.draft.quotas.maxUploadBytes ||
+            conversation.quota.usedBytes + upload.size > conversation.quota.maxBytes)
+            throw new Error('HOSTED_CONVERSATION_QUOTA_EXCEEDED');
+        await assertUploadTemporaryFile(upload.temporaryPath, upload.size);
+        const target = await lstat(upload.targetPath).catch((error) => {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        });
+        if (target !== undefined)
+            throw new Error('HOSTED_CONVERSATION_FILE_INVALID');
+        const handle = await open(upload.temporaryPath, 'r+');
+        try {
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await rename(upload.temporaryPath, upload.targetPath);
+        const createdAt = this.now();
+        try {
+            await utimes(upload.targetPath, new Date(createdAt), new Date(createdAt));
+            const file = {
+                id: this.options.store.fileProjectionId(upload.conversationId, 'UPLOAD', upload.name),
+                conversationId: upload.conversationId,
+                category: 'UPLOAD',
+                relativePath: upload.name,
+                displayName: upload.name,
+                mimeType: upload.mimeType,
+                size: upload.size,
+                source: 'USER',
+                createdAt,
+                updatedAt: createdAt
+            };
+            upload.file = await this.options.store.registerFile(payload.userId, file);
+            upload.status = 'COMPLETED';
+            this.releaseUploadName(upload.conversationId, upload.name);
+            this.options.publish(upload.conversationId, {
+                conversationId: upload.conversationId,
+                kind: 'files',
+                files: this.options.store.listFiles(payload.userId, upload.conversationId),
+                error: null
+            });
+            return { upload: hostedConversationUploadSchema.parse(uploadProjection(upload)) };
+        }
+        catch (error) {
+            await rename(upload.targetPath, upload.temporaryPath).catch(() => undefined);
+            this.releaseUploadName(upload.conversationId, upload.name);
+            throw error;
+        }
+    }
+    async cancelUpload(raw) {
+        const payload = this.options.request(raw);
+        const input = hostedConversationUploadControlInputSchema.parse(payload.data);
+        const upload = this.requireUpload(payload.userId, input.conversationId, input.uploadId);
+        if (upload.status === 'COMPLETED')
+            throw new Error('HOSTED_CONVERSATION_UPLOAD_STATE_INVALID');
+        upload.status = 'CANCELLED';
+        await rm(upload.temporaryPath, { force: true });
+        this.releaseUploadName(upload.conversationId, upload.name);
+        return { upload: hostedConversationUploadSchema.parse(uploadProjection(upload)) };
+    }
+    requireUpload(userId, conversationId, uploadId) {
+        this.options.store.requireConversation(userId, conversationId);
+        const upload = this.uploads.get(uploadId);
+        if (upload === undefined ||
+            upload.userId !== userId ||
+            upload.conversationId !== conversationId)
+            throw new Error('HOSTED_CONVERSATION_UPLOAD_NOT_FOUND');
+        return upload;
+    }
+    async requireAttachment(userId, conversationId, fileId) {
+        const file = this.options.store.requireFile(userId, conversationId, fileId);
+        if (file.category !== 'UPLOAD')
+            throw new Error('HOSTED_CONVERSATION_ATTACHMENT_INVALID');
+        await assertRegularFile(this.options.store.filePath(userId, file), file.size);
+        return file;
+    }
+    async cancelConversationUploads(userId, conversationId) {
+        for (const upload of this.uploads.values()) {
+            if (upload.userId !== userId || upload.conversationId !== conversationId)
+                continue;
+            if (upload.status === 'UPLOADING') {
+                upload.status = 'CANCELLED';
+                await rm(upload.temporaryPath, { force: true }).catch(() => undefined);
+                this.releaseUploadName(upload.conversationId, upload.name);
+            }
+        }
+    }
+    async uploadPreflightStatus(conversation, draft, name, size) {
+        if (Buffer.byteLength(name, 'utf8') > 255)
+            return 'INVALID_NAME';
+        if (size > draft.quotas.maxUploadBytes)
+            return 'TOO_LARGE';
+        if (conversation.quota.usedBytes + size > conversation.quota.maxBytes)
+            return 'QUOTA_EXCEEDED';
+        return 'READY';
+    }
+    async allocateUploadName(paths, userId, conversationId, requestedName) {
+        const existingNames = new Set(this.options.store
+            .listFiles(userId, conversationId)
+            .filter((file) => file.category === 'UPLOAD')
+            .map((file) => canonicalUploadName(file.relativePath)));
+        const parts = uploadNameParts(requestedName);
+        let index = parts.index;
+        for (;;) {
+            const candidate = uploadNameCandidate(parts, index);
+            const canonical = canonicalUploadName(candidate);
+            if (existingNames.has(canonical) || this.isUploadNameReserved(conversationId, canonical)) {
+                index = Math.max(1, index + 1);
+                continue;
+            }
+            this.reserveUploadName(conversationId, canonical);
+            let target;
+            try {
+                target = await lstat(join(paths.uploadsDirectory, candidate));
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    return candidate;
+                this.releaseUploadName(conversationId, candidate);
+                throw error;
+            }
+            if (target === undefined)
+                return candidate;
+            this.releaseUploadName(conversationId, candidate);
+            if (!target.isFile())
+                throw new Error('HOSTED_CONVERSATION_FILE_INVALID');
+            existingNames.add(canonical);
+            index = Math.max(1, index + 1);
+        }
+    }
+    isUploadNameReserved(conversationId, canonicalName) {
+        return this.uploadNameReservations.get(conversationId)?.has(canonicalName) ?? false;
+    }
+    reserveUploadName(conversationId, canonicalName) {
+        const reserved = this.uploadNameReservations.get(conversationId) ?? new Set();
+        reserved.add(canonicalName);
+        this.uploadNameReservations.set(conversationId, reserved);
+    }
+    releaseUploadName(conversationId, name) {
+        const reserved = this.uploadNameReservations.get(conversationId);
+        if (reserved === undefined)
+            return;
+        reserved.delete(canonicalUploadName(name));
+        if (reserved.size === 0)
+            this.uploadNameReservations.delete(conversationId);
+    }
+}
+function canonicalUploadName(name) {
+    return name.normalize('NFKC').toLocaleLowerCase();
+}
+function uploadNameParts(name) {
+    const dot = name.lastIndexOf('.');
+    const extension = dot > 0 ? name.slice(dot) : '';
+    const stem = dot > 0 ? name.slice(0, dot) : name;
+    const suffix = /^(.*) \((\d+)\)$/u.exec(stem);
+    if (suffix === null || suffix[1] === undefined || suffix[2] === undefined)
+        return { stem, extension, index: 0 };
+    const index = Number.parseInt(suffix[2], 10);
+    return {
+        stem: suffix[1],
+        extension,
+        index: Number.isSafeInteger(index) && index > 0 ? index : 0
+    };
+}
+function uploadNameCandidate(parts, index) {
+    if (index === 0)
+        return `${parts.stem}${parts.extension}`;
+    const suffix = ` (${index})`;
+    const maximumStemLength = 512 - parts.extension.length - suffix.length;
+    return `${truncateUploadStem(parts.stem, maximumStemLength)}${suffix}${parts.extension}`;
+}
+function truncateUploadStem(stem, maximumLength) {
+    if (stem.length <= maximumLength)
+        return stem;
+    const truncated = stem.slice(0, Math.max(0, maximumLength));
+    const last = truncated.charCodeAt(truncated.length - 1);
+    return last >= 0xd800 && last <= 0xdbff ? truncated.slice(0, -1) : truncated;
+}
+function uploadProjection(upload) {
+    return {
+        uploadId: upload.uploadId,
+        conversationId: upload.conversationId,
+        name: upload.name,
+        mimeType: upload.mimeType,
+        receivedBytes: upload.receivedBytes,
+        size: upload.size,
+        status: upload.status,
+        ...(upload.file === undefined ? {} : { file: upload.file })
+    };
+}
+async function assertUploadTemporaryFile(path, expectedSize) {
+    const metadata = await lstat(path).catch(() => {
+        throw new Error('HOSTED_CONVERSATION_UPLOAD_STATE_INVALID');
+    });
+    if (!metadata.isFile() ||
+        metadata.isSymbolicLink() ||
+        metadata.nlink !== 1 ||
+        metadata.size !== expectedSize)
+        throw new Error('HOSTED_CONVERSATION_UPLOAD_STATE_INVALID');
+}