agl 1.0.17 → 21.0.2

package/dist_ts/classes.uploadmanager.d.ts

@@ -0,0 +1,24 @@
+import { type IControllerDraftAttachment } from '../dist_ts_interfaces/interfaces.js';
+export interface IControllerUploadHandle {
+    id: string;
+    directory: string;
+    paths: string[];
+    promptSuffix: string;
+    bytes: number;
+    cleanup(): Promise<void>;
+}
+export declare class ControllerUploadManager {
+    private rootPromise?;
+    private readonly activeUploads;
+    private readonly pendingCreates;
+    private activeUploadCount;
+    private activeBytes;
+    private closed;
+    private closePromise?;
+    create(attachmentsArg: readonly IControllerDraftAttachment[]): Promise<IControllerUploadHandle | undefined>;
+    close(): Promise<void>;
+    private createReserved;
+    private closeInternal;
+    private ensureRoot;
+    private cleanup;
+}

package/dist_ts/classes.uploadmanager.js

@@ -0,0 +1,210 @@
+import * as plugins from './plugins.js';
+import { controllerMaxAttachmentPromptSuffixBytes, controllerMaxDraftAttachmentBytes, controllerMaxDraftAttachmentTotalBytes, controllerMaxDraftAttachments, } from '../dist_ts_interfaces/interfaces.js';
+const maximumActiveUploads = 64;
+const maximumActiveUploadBytes = 64 * 1024 * 1024;
+export class ControllerUploadManager {
+    rootPromise;
+    activeUploads = new Map();
+    pendingCreates = new Set();
+    activeUploadCount = 0;
+    activeBytes = 0;
+    closed = false;
+    closePromise;
+    create(attachmentsArg) {
+        if (attachmentsArg.length === 0)
+            return Promise.resolve(undefined);
+        if (this.closed)
+            throw new Error('The controller upload manager is closed.');
+        if (attachmentsArg.length > controllerMaxDraftAttachments) {
+            throw new Error('The attachment count exceeds the controller limit.');
+        }
+        if (this.activeUploadCount >= maximumActiveUploads) {
+            throw new Error('The controller has too many active uploads.');
+        }
+        const decoded = attachmentsArg.map((attachment, index) => {
+            if (attachment.name.length === 0
+                || attachment.name !== plugins.path.basename(attachment.name)
+                || Buffer.byteLength(attachment.name, 'utf8') > 255
+                // eslint-disable-next-line no-control-regex
+                || /[\x00-\x1f\x7f/\\]/.test(attachment.name)) {
+                throw new Error(`Attachment ${index + 1} has an unsafe file name.`);
+            }
+            if (attachment.mediaType.length === 0
+                || Buffer.byteLength(attachment.mediaType, 'utf8') > 129
+                // eslint-disable-next-line no-control-regex
+                || /[\x00-\x20\x7f]/.test(attachment.mediaType))
+                throw new Error(`Attachment ${index + 1} has an unsafe media type.`);
+            const data = Buffer.from(attachment.dataBase64, 'base64');
+            if (data.toString('base64') !== attachment.dataBase64) {
+                throw new Error(`Attachment ${index + 1} is not canonical base64.`);
+            }
+            if (data.byteLength !== attachment.size) {
+                throw new Error(`Attachment ${index + 1} size does not match its content.`);
+            }
+            if (data.byteLength > controllerMaxDraftAttachmentBytes) {
+                throw new Error(`Attachment ${index + 1} exceeds the controller byte limit.`);
+            }
+            return { attachment, data };
+        });
+        const bytes = decoded.reduce((sum, entry) => sum + entry.data.byteLength, 0);
+        if (bytes > controllerMaxDraftAttachmentTotalBytes) {
+            throw new Error('The attachments exceed the controller total byte limit.');
+        }
+        if (this.activeBytes + bytes > maximumActiveUploadBytes) {
+            throw new Error('The controller active upload byte limit is exhausted.');
+        }
+        this.activeUploadCount += 1;
+        this.activeBytes += bytes;
+        const createPromise = this.createReserved(decoded, bytes);
+        this.pendingCreates.add(createPromise);
+        void createPromise.finally(() => this.pendingCreates.delete(createPromise)).catch(() => undefined);
+        return createPromise;
+    }
+    async close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closed = true;
+        const closePromise = this.closeInternal();
+        this.closePromise = closePromise;
+        try {
+            await closePromise;
+        }
+        catch (errorArg) {
+            if (this.closePromise === closePromise)
+                this.closePromise = undefined;
+            throw errorArg;
+        }
+    }
+    async createReserved(decodedArg, bytesArg) {
+        const id = plugins.crypto.randomBytes(16).toString('base64url');
+        let directory;
+        let admitted = false;
+        try {
+            const root = await this.ensureRoot();
+            directory = await plugins.fs.promises.mkdtemp(plugins.path.join(root, 'message-'));
+            await plugins.fs.promises.chmod(directory, 0o700);
+            const paths = [];
+            for (const [index, entry] of decodedArg.entries()) {
+                const filePath = plugins.path.join(directory, `${index + 1}-${entry.attachment.name}`);
+                const relative = plugins.path.relative(directory, filePath);
+                if (relative === '..'
+                    || relative.startsWith(`..${plugins.path.sep}`)
+                    || plugins.path.isAbsolute(relative))
+                    throw new Error('An attachment path escaped its upload directory.');
+                const flags = plugins.fs.constants.O_WRONLY
+                    | plugins.fs.constants.O_CREAT
+                    | plugins.fs.constants.O_EXCL
+                    | (plugins.fs.constants.O_NOFOLLOW ?? 0);
+                const file = await plugins.fs.promises.open(filePath, flags, 0o600);
+                try {
+                    await file.writeFile(entry.data);
+                }
+                finally {
+                    await file.close();
+                }
+                paths.push(filePath);
+            }
+            const promptSuffix = `\n\n[Attached files - stored on disk; read them with filesystem tools]\n${decodedArg
+                .map((entry, index) => `- ${paths[index]} (${entry.attachment.mediaType}, ${entry.data.byteLength} bytes)`)
+                .join('\n')}`;
+            if (Buffer.byteLength(promptSuffix, 'utf8') > controllerMaxAttachmentPromptSuffixBytes) {
+                throw new Error('The generated attachment prompt suffix exceeds its byte limit.');
+            }
+            const handle = {
+                id,
+                directory,
+                paths,
+                promptSuffix,
+                bytes: bytesArg,
+                cleanup: () => this.cleanup(id),
+            };
+            this.activeUploads.set(id, { handle });
+            admitted = true;
+            return handle;
+        }
+        finally {
+            if (!admitted) {
+                if (directory) {
+                    await plugins.fs.promises.rm(directory, { recursive: true, force: true }).catch(() => undefined);
+                }
+                this.activeUploadCount -= 1;
+                this.activeBytes -= bytesArg;
+            }
+        }
+    }
+    async closeInternal() {
+        await Promise.allSettled([...this.pendingCreates]);
+        const results = await Promise.allSettled([...this.activeUploads.values()].map((entry) => entry.handle.cleanup()));
+        const errors = results
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (this.rootPromise) {
+            try {
+                const root = await this.rootPromise;
+                await plugins.fs.promises.rm(root, { recursive: true, force: true });
+                this.activeUploads.clear();
+                this.activeUploadCount = 0;
+                this.activeBytes = 0;
+                errors.length = 0;
+            }
+            catch (errorArg) {
+                errors.push(errorArg);
+            }
+        }
+        if (errors.length > 0)
+            throw new AggregateError(errors, 'Controller upload cleanup failed.');
+    }
+    async ensureRoot() {
+        if (!this.rootPromise) {
+            this.rootPromise = (async () => {
+                let root;
+                try {
+                    root = await plugins.fs.promises.mkdtemp(plugins.path.join(plugins.os.tmpdir(), 'harness-controller-uploads-'));
+                    await plugins.fs.promises.chmod(root, 0o700);
+                    return await plugins.fs.promises.realpath(root);
+                }
+                catch (errorArg) {
+                    if (root) {
+                        await plugins.fs.promises.rm(root, { recursive: true, force: true })
+                            .catch(() => undefined);
+                    }
+                    throw errorArg;
+                }
+            })();
+        }
+        const rootPromise = this.rootPromise;
+        try {
+            return await rootPromise;
+        }
+        catch (errorArg) {
+            if (this.rootPromise === rootPromise)
+                this.rootPromise = undefined;
+            throw errorArg;
+        }
+    }
+    async cleanup(idArg) {
+        const active = this.activeUploads.get(idArg);
+        if (!active)
+            return;
+        if (active.cleanupPromise)
+            return active.cleanupPromise;
+        const cleanupPromise = (async () => {
+            await plugins.fs.promises.rm(active.handle.directory, { recursive: true, force: true });
+            if (this.activeUploads.get(idArg) === active) {
+                this.activeUploads.delete(idArg);
+                this.activeUploadCount -= 1;
+                this.activeBytes -= active.handle.bytes;
+            }
+        })();
+        active.cleanupPromise = cleanupPromise;
+        try {
+            await cleanupPromise;
+        }
+        finally {
+            if (this.activeUploads.get(idArg) === active && active.cleanupPromise === cleanupPromise) {
+                active.cleanupPromise = undefined;
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.uploadmanager.js","sourceRoot":"","sources":["../../ts/classes.uploadmanager.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.validation.d.ts

@@ -0,0 +1,91 @@
+import type * as interfaces from '../dist_ts_interfaces/index.js';
+export declare const assertEmptyRequest: (valueArg: unknown) => Record<string, never>;
+export declare const assertIdentifier: (valueArg: unknown, nameArg: string) => string;
+export declare function assertControllerRuntimeId<THarnessId extends interfaces.TControllerHarnessId>(valueArg: unknown, nameArg: string, allowedHarnessIdsArg: readonly THarnessId[]): interfaces.IControllerRuntimeId & {
+    harnessId: THarnessId;
+};
+export declare function assertControllerRuntimeId(valueArg: unknown, nameArg: string, allowedHarnessIdsArg?: readonly interfaces.TControllerHarnessId[]): interfaces.IControllerRuntimeId;
+export declare const assertSetupBeginRequest: (valueArg: unknown) => interfaces.IReq_ControllerSetupBegin["request"];
+export declare const assertSetupFinishRequest: (valueArg: unknown) => interfaces.IReq_ControllerSetupFinish["request"];
+export declare const assertAuthenticationFinishRequest: (valueArg: unknown) => interfaces.IReq_ControllerAuthenticationFinish["request"];
+export declare const assertProjectListRequest: (valueArg: unknown) => Record<string, never>;
+export declare const assertProjectRelativePath: (valueArg: unknown, nameArg: string) => string;
+export declare const assertProjectCreateRequest: (valueArg: unknown) => interfaces.IReq_ControllerProjectCreate["request"];
+export declare const assertAbsoluteProjectPath: (valueArg: unknown, nameArg: string) => string;
+/**
+ * Accepts what a human types and returns the absolute directory to register:
+ * an absolute path is taken as-is (any location on disk), a relative path is
+ * resolved against the projects root.
+ */
+export declare const resolveProjectPathInput: (pathArg: string, projectsRootArg: string) => string;
+export interface IProjectSuggestParse {
+    /**
+     * Directory whose entries are being completed: absolute when the query was
+     * absolute, else relative to the projects root ('' meaning the root).
+     */
+    directoryPath: string;
+    prefix: string;
+    unmatchable: boolean;
+    /** The query was an absolute path; suggestions should be returned absolute. */
+    absolute: boolean;
+}
+export declare const assertProjectSuggestRequest: (valueArg: unknown) => IProjectSuggestParse;
+export declare const assertProjectRemoveRequest: (valueArg: unknown) => interfaces.IReq_ControllerProjectRemove["request"];
+export declare const assertProviderListRequest: (valueArg: unknown) => Record<string, never>;
+export declare const assertProviderConnectionListRequest: (valueArg: unknown) => Record<string, never>;
+export declare const assertProviderLoginBeginRequest: (valueArg: unknown) => interfaces.IReq_ControllerProviderLoginBegin["request"];
+export declare const assertProviderLoginGetRequest: (valueArg: unknown) => interfaces.IReq_ControllerProviderLoginGet["request"];
+export declare const assertProviderLoginCancelRequest: (valueArg: unknown) => interfaces.IReq_ControllerProviderLoginCancel["request"];
+export declare const assertProviderConnectionLogoutRequest: (valueArg: unknown) => interfaces.IReq_ControllerProviderConnectionLogout["request"];
+export declare const assertProviderConnectionRateLimitsGetRequest: (valueArg: unknown) => interfaces.IReq_ControllerProviderConnectionRateLimitsGet["request"];
+export declare const assertProviderConnectionActivateOpenCodeRequest: (valueArg: unknown) => interfaces.IReq_ControllerProviderConnectionActivateOpenCode["request"];
+export declare const assertProviderModelRefreshBeginRequest: (valueArg: unknown) => interfaces.IReq_ControllerProviderModelRefreshBegin["request"];
+export declare const assertProviderModelRefreshGetRequest: (valueArg: unknown) => interfaces.IReq_ControllerProviderModelRefreshGet["request"];
+export declare const assertSettingsUpdateRequest: (valueArg: unknown) => interfaces.IReq_ControllerSettingsUpdate["request"];
+export declare const assertSessionListRequest: (valueArg: unknown) => interfaces.IReq_ControllerSessionList["request"];
+export declare const assertSlashListRequest: (valueArg: unknown) => interfaces.IReq_ControllerSlashList["request"];
+export declare const assertSessionGetRequest: (valueArg: unknown) => interfaces.IReq_ControllerSessionGet["request"];
+export declare const assertSessionAuxiliaryGetRequest: (valueArg: unknown) => interfaces.IReq_ControllerSessionAuxiliaryGet["request"];
+export declare const assertSessionModelUpdateRequest: (valueArg: unknown) => interfaces.IReq_ControllerSessionModelUpdate["request"];
+export declare const assertSessionScratchpadSaveRequest: (valueArg: unknown) => interfaces.IReq_ControllerSessionScratchpadSave["request"];
+export declare const assertSessionIntelligenceAskRequest: (valueArg: unknown) => interfaces.IReq_ControllerSessionIntelligenceAsk["request"];
+export declare const assertSessionMessagesPageRequest: (valueArg: unknown) => interfaces.IReq_ControllerSessionMessagesPage["request"];
+export declare const assertSessionMessageGetRequest: (valueArg: unknown) => interfaces.IReq_ControllerSessionMessageGet["request"];
+export declare const assertSessionCreateRequest: (valueArg: unknown) => interfaces.IReq_ControllerSessionCreate["request"];
+export declare const assertTempPasswordLoginRequest: (valueArg: unknown) => interfaces.IReq_ControllerTempPasswordLogin["request"];
+export declare const assertAuthResumeRequest: (valueArg: unknown) => interfaces.IReq_ControllerAuthResume["request"];
+export declare const assertVariantName: (valueArg: unknown) => string;
+export declare function assertModelChoice(valueArg: unknown, nameArg?: string): interfaces.TControllerModelChoice;
+export declare const assertSessionDraftUpdateRequest: (valueArg: unknown) => interfaces.IReq_ControllerSessionDraftUpdate["request"];
+export declare const assertSessionSendRequest: (valueArg: unknown) => interfaces.IReq_ControllerSessionSend["request"];
+export declare const assertSlashExecuteRequest: (valueArg: unknown) => interfaces.IReq_ControllerSlashExecute["request"];
+export declare const assertPermissionReplyRequest: (valueArg: unknown) => interfaces.IReq_ControllerPermissionReply["request"];
+export declare const assertSessionGroupsGetRequest: (valueArg: unknown) => interfaces.IReq_ControllerSessionGroupsGet["request"];
+export declare const assertSessionGroupsUpdateRequest: (valueArg: unknown) => interfaces.IReq_ControllerSessionGroupsUpdate["request"];
+export declare const assertSessionYoloRequest: (valueArg: unknown) => interfaces.IReq_ControllerSessionYolo["request"];
+export declare const assertControllerSessionTitle: (valueArg: unknown) => string;
+export declare const assertSessionRenameRequest: (valueArg: unknown) => interfaces.IReq_ControllerSessionRename["request"];
+export declare const assertSessionArchiveRequest: (valueArg: unknown) => interfaces.IReq_ControllerSessionArchive["request"];
+export declare const assertTerminalListRequest: (valueArg: unknown) => interfaces.IReq_ControllerTerminalList["request"];
+export declare const assertResourceListRequest: (valueArg: unknown) => interfaces.IReq_ControllerResourceList["request"];
+export declare const assertResourceCreateRequest: (valueArg: unknown) => interfaces.IReq_ControllerResourceCreate["request"];
+export declare const assertResourceRenameRequest: (valueArg: unknown) => interfaces.IReq_ControllerResourceRename["request"];
+export declare const assertResourceAttachRequest: (valueArg: unknown) => interfaces.IReq_ControllerResourceAttach["request"];
+export declare const assertResourceDetachRequest: (valueArg: unknown) => interfaces.IReq_ControllerResourceDetach["request"];
+export declare const assertResourceTargetRequest: (valueArg: unknown, nameArg: string) => {
+    projectId: string;
+    resourceId: string;
+};
+export declare const assertBrowserViewOpenRequest: (valueArg: unknown) => interfaces.IReq_ControllerBrowserViewOpen["request"];
+export declare const assertBrowserViewCloseRequest: (valueArg: unknown) => interfaces.IReq_ControllerBrowserViewClose["request"];
+export declare const assertBrowserViewActivateRequest: (valueArg: unknown) => interfaces.IReq_ControllerBrowserViewActivate["request"];
+export declare const assertBrowserViewOperateRequest: (valueArg: unknown) => interfaces.IReq_ControllerBrowserViewOperate["request"];
+export declare const assertTerminalCreateRequest: (valueArg: unknown) => interfaces.IReq_ControllerTerminalCreate["request"];
+export declare const assertTerminalRenameRequest: (valueArg: unknown) => interfaces.IReq_ControllerTerminalRename["request"];
+export declare const assertTerminalTargetRequest: (valueArg: unknown, nameArg: string) => {
+    projectId: string;
+    terminalId: interfaces.TControllerTerminalId;
+};
+export declare const assertTerminalInputRequest: (valueArg: unknown) => interfaces.IReq_ControllerTerminalInput["request"];
+export declare const assertTerminalResizeRequest: (valueArg: unknown) => interfaces.IReq_ControllerTerminalResize["request"];
+export declare const assertQuestionReplyRequest: (valueArg: unknown) => interfaces.IReq_ControllerQuestionReply["request"];