agl 1.0.17 → 21.0.2

package/dist_ts/classes.processinspection.js

@@ -0,0 +1,484 @@
+import * as plugins from './plugins.js';
+import { controllerPackageName } from '../dist_ts_interfaces/index.js';
+import { defaultControllerPort } from './classes.config.js';
+const maximumProcessIdentities = 16_384;
+const processIdentityBatchSize = 128;
+const maximumProcessArguments = 512;
+const maximumProcessArgumentBytes = 256 * 1024;
+const maximumProcessCommandBytes = maximumProcessArgumentBytes + maximumProcessArguments;
+const maximumReconstructedPathArguments = 32;
+const maximumDataWriterCliPaths = 8;
+const maximumDataWriterCandidates = 1_024;
+const currentRuntimeName = String(controllerPackageName) === 'agl' ? 'AGL' : 'hcon';
+const installedControllerPackagePaths = [
+    plugins.path.join('node_modules', '@modelprofile.com', 'harness-controller'),
+    plugins.path.join('node_modules', 'agl'),
+];
+const boundedProcessArgumentsPrefix = (argumentsArg) => {
+    const bounded = [];
+    let totalBytes = 0;
+    for (const argument of argumentsArg) {
+        const argumentBytes = Buffer.byteLength(argument, 'utf8');
+        if (bounded.length >= maximumProcessArguments
+            || totalBytes + argumentBytes > maximumProcessArgumentBytes)
+            break;
+        bounded.push(argument);
+        totalBytes += argumentBytes;
+    }
+    return bounded;
+};
+const assertPid = (pidArg) => {
+    if (!Number.isSafeInteger(pidArg) || pidArg < 2) {
+        throw new Error('Controller PID is invalid.');
+    }
+    return pidArg;
+};
+const execFile = async (fileArg, argsArg, optionsArg = {}) => {
+    return await new Promise((resolve, reject) => {
+        plugins.childProcess.execFile(fileArg, argsArg, {
+            encoding: 'utf8',
+            maxBuffer: optionsArg.maxBufferBytes ?? 128 * 1024,
+            timeout: optionsArg.timeoutMs ?? 2_000,
+            killSignal: 'SIGKILL',
+            ...(optionsArg.detached === undefined ? {} : { detached: optionsArg.detached }),
+        }, (errorArg, stdoutArg) => {
+            if (errorArg) {
+                reject(errorArg);
+                return;
+            }
+            resolve(stdoutArg);
+        });
+    });
+};
+const readBoundedLinuxCommandArguments = async (pidArg) => {
+    // Read only the accepted argv budget plus one byte so oversized processes
+    // cannot make a system-wide inventory retain unbounded command data.
+    const handle = await plugins.fs.promises.open(`/proc/${pidArg}/cmdline`, plugins.fs.constants.O_RDONLY);
+    try {
+        const buffer = Buffer.allocUnsafe(maximumProcessCommandBytes + 1);
+        let bytesRead = 0;
+        while (bytesRead < buffer.length) {
+            const read = await handle.read(buffer, bytesRead, buffer.length - bytesRead, null);
+            if (read.bytesRead === 0)
+                break;
+            bytesRead += read.bytesRead;
+        }
+        const commandLength = Math.min(bytesRead, maximumProcessCommandBytes);
+        const argumentsResult = [];
+        let argumentStart = 0;
+        let argumentCountExceeded = false;
+        for (let index = 0; index < commandLength; index++) {
+            if (buffer[index] !== 0)
+                continue;
+            if (argumentsResult.length >= maximumProcessArguments) {
+                argumentCountExceeded = true;
+                break;
+            }
+            if (index > argumentStart) {
+                argumentsResult.push(buffer.subarray(argumentStart, index).toString('utf8'));
+            }
+            argumentStart = index + 1;
+        }
+        if (bytesRead <= maximumProcessCommandBytes
+            && !argumentCountExceeded
+            && argumentStart < commandLength
+            && argumentsResult.length < maximumProcessArguments) {
+            argumentsResult.push(buffer.subarray(argumentStart, commandLength).toString('utf8'));
+        }
+        return {
+            arguments: argumentsResult,
+            truncated: bytesRead > maximumProcessCommandBytes || argumentCountExceeded,
+        };
+    }
+    finally {
+        await handle.close();
+    }
+};
+const readLinuxIdentity = async (pidArg) => {
+    const [statBuffer, command] = await Promise.all([
+        plugins.fs.promises.readFile(`/proc/${pidArg}/stat`),
+        readBoundedLinuxCommandArguments(pidArg),
+    ]);
+    const stat = statBuffer.toString('utf8');
+    const statSuffixIndex = stat.lastIndexOf(') ');
+    if (statSuffixIndex < 0)
+        throw new Error('Unable to parse controller process metadata.');
+    const statFields = stat.slice(statSuffixIndex + 2).trim().split(/\s+/);
+    const processGroupId = Number(statFields[2]);
+    const startTime = statFields[19];
+    if (!Number.isSafeInteger(processGroupId) || !startTime) {
+        throw new Error('Unable to parse controller process identity.');
+    }
+    return {
+        pid: pidArg,
+        processGroupId,
+        processGroupLeader: processGroupId === pidArg,
+        arguments: command.arguments,
+        ...(command.truncated ? { argumentsTruncated: true } : {}),
+        fingerprint: `linux:${pidArg}:${startTime}`,
+    };
+};
+const readLinuxProcessGroupId = async (pidArg) => {
+    try {
+        const stat = await plugins.fs.promises.readFile(`/proc/${pidArg}/stat`, 'utf8');
+        const statSuffixIndex = stat.lastIndexOf(') ');
+        if (statSuffixIndex < 0)
+            return undefined;
+        const statFields = stat.slice(statSuffixIndex + 2).trim().split(/\s+/);
+        const processGroupId = Number(statFields[2]);
+        return Number.isSafeInteger(processGroupId) ? processGroupId : undefined;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT' || code === 'ESRCH' || code === 'EACCES')
+            return undefined;
+        throw error;
+    }
+};
+const readPosixIdentity = async (pidArg) => {
+    const output = await execFile('ps', [
+        '-ww',
+        '-p',
+        String(pidArg),
+        '-o',
+        'pgid=',
+        '-o',
+        'lstart=',
+        '-o',
+        'command=',
+    ], { maxBufferBytes: 8 * 1024 * 1024 });
+    const line = output.trim();
+    const match = /^\s*(\d+)\s+(.{24})\s+(.+)$/.exec(line);
+    if (!match)
+        throw new Error('Unable to parse controller process metadata.');
+    const processGroupId = Number(match[1]);
+    return {
+        pid: pidArg,
+        processGroupId,
+        processGroupLeader: processGroupId === pidArg,
+        arguments: parsePosixCommandArguments(match[3]),
+        fingerprint: `posix:${pidArg}:${match[2].trim()}`,
+    };
+};
+const parsePosixCommandArguments = (commandArg) => {
+    return (commandArg.match(/"[^"]*"|'[^']*'|\S+/g) ?? []).map((argumentArg) => {
+        const quoted = ((argumentArg.startsWith('"') && argumentArg.endsWith('"'))
+            || (argumentArg.startsWith("'") && argumentArg.endsWith("'")));
+        return quoted ? argumentArg.slice(1, -1) : argumentArg;
+    });
+};
+export const readControllerProcessIdentity = async (pidArg) => {
+    const pid = assertPid(pidArg);
+    try {
+        if (process.platform === 'linux')
+            return await readLinuxIdentity(pid);
+        if (process.platform !== 'win32')
+            return await readPosixIdentity(pid);
+        return null;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT' || code === 'ESRCH')
+            return null;
+        throw error;
+    }
+};
+export const readProcessGroupMemberPids = async (processGroupIdArg) => {
+    const processGroupId = assertPid(processGroupIdArg);
+    if (process.platform === 'linux') {
+        const entries = await plugins.fs.promises.readdir('/proc');
+        const processIds = entries
+            .filter((entryArg) => /^[1-9][0-9]*$/.test(entryArg))
+            .map((entryArg) => Number(entryArg))
+            .filter((processIdArg) => processIdArg >= 2);
+        const groupIds = await Promise.all(processIds.map(async (processIdArg) => ({
+            processId: processIdArg,
+            processGroupId: await readLinuxProcessGroupId(processIdArg),
+        })));
+        return groupIds
+            .filter((entryArg) => entryArg.processGroupId === processGroupId)
+            .map((entryArg) => entryArg.processId)
+            .sort((leftArg, rightArg) => leftArg - rightArg);
+    }
+    if (process.platform !== 'win32') {
+        // A detached helper gets its own process group, so macOS `ps -ax` cannot
+        // report the probe itself as a member of the controller group being read.
+        const output = await execFile('ps', ['-ax', '-o', 'pid=', '-o', 'pgid='], { detached: true });
+        return output
+            .split(/\r?\n/)
+            .map((lineArg) => /^\s*(\d+)\s+(\d+)\s*$/.exec(lineArg))
+            .filter((matchArg) => matchArg !== null)
+            .filter((matchArg) => Number(matchArg[2]) === processGroupId)
+            .map((matchArg) => Number(matchArg[1]))
+            .sort((leftArg, rightArg) => leftArg - rightArg);
+    }
+    return [];
+};
+const findCliArgumentIndex = async (pidArg, argumentsArg, cliPathArg, allowMissingAbsolutePathArg = false) => {
+    const boundedArguments = boundedProcessArgumentsPrefix(argumentsArg);
+    const directIndex = boundedArguments.indexOf(cliPathArg);
+    if (directIndex >= 0)
+        return directIndex;
+    // A controller launched with a relative path (`node cli.js foreground`) is
+    // still the same file; resolve candidate tokens against the process's own
+    // working directory before declaring the identity unverifiable.
+    let processCwd;
+    if (process.platform === 'linux') {
+        try {
+            processCwd = await plugins.fs.promises.readlink(`/proc/${pidArg}/cwd`);
+        }
+        catch {
+            processCwd = undefined;
+        }
+    }
+    const cliBasename = plugins.path.basename(cliPathArg);
+    const normalizedCliPath = plugins.path.normalize(cliPathArg);
+    for (let endIndex = 1; endIndex <= boundedArguments.length; endIndex++) {
+        const minimumStartIndex = Math.max(0, endIndex - maximumReconstructedPathArguments);
+        for (let startIndex = endIndex - 1; startIndex >= minimumStartIndex; startIndex--) {
+            const candidate = boundedArguments.slice(startIndex, endIndex).join(' ');
+            if (plugins.path.basename(candidate) !== cliBasename)
+                continue;
+            try {
+                const resolved = await plugins.fs.promises.realpath(plugins.path.isAbsolute(candidate)
+                    ? candidate
+                    : plugins.path.resolve(processCwd ?? '', candidate));
+                if (resolved === cliPathArg)
+                    return endIndex - 1;
+            }
+            catch {
+                // pnpm may remove A's package while its worker still owns the upgrade
+                // lock. Only that trusted caller may use an exact normalized old path.
+                if (allowMissingAbsolutePathArg
+                    && plugins.path.isAbsolute(candidate)
+                    && plugins.path.normalize(candidate) === normalizedCliPath)
+                    return endIndex - 1;
+                continue;
+            }
+        }
+    }
+    return -1;
+};
+export const processIdentityHasFileArgument = async (identityArg, filePathArg, optionsArg = {}) => await findCliArgumentIndex(identityArg.pid, identityArg.arguments, filePathArg, optionsArg.allowMissingAbsolutePath === true) >= 0;
+const findInstalledControllerPackageFileArgumentIndex = (argumentsArg, packageRelativePathArg) => {
+    const boundedArguments = boundedProcessArgumentsPrefix(argumentsArg);
+    const expectedSuffixes = installedControllerPackagePaths.map((packagePathArg) => (`${plugins.path.sep}${plugins.path.join(packagePathArg, packageRelativePathArg)}`));
+    const expectedBasename = plugins.path.basename(packageRelativePathArg);
+    for (let endIndex = 1; endIndex <= boundedArguments.length; endIndex++) {
+        const minimumStartIndex = Math.max(0, endIndex - maximumReconstructedPathArguments);
+        for (let startIndex = endIndex - 1; startIndex >= minimumStartIndex; startIndex--) {
+            const candidate = boundedArguments.slice(startIndex, endIndex).join(' ');
+            if (plugins.path.basename(candidate) === expectedBasename
+                && plugins.path.isAbsolute(candidate)
+                && expectedSuffixes.some((suffixArg) => (plugins.path.normalize(candidate).endsWith(suffixArg))))
+                return endIndex - 1;
+        }
+    }
+    return -1;
+};
+const processIdentityHasInstalledControllerCommand = (identityArg, commandArg) => {
+    const cliIndex = findInstalledControllerPackageFileArgumentIndex(identityArg.arguments, 'cli.js');
+    return cliIndex >= 0 && identityArg.arguments[cliIndex + 1] === commandArg;
+};
+const readEffectiveArgvPort = (argumentsArg) => {
+    let effectivePort = defaultControllerPort;
+    const boundedArguments = boundedProcessArgumentsPrefix(argumentsArg);
+    for (let index = 0; index < boundedArguments.length; index++) {
+        if (boundedArguments[index] === '--port') {
+            effectivePort = Number(boundedArguments[index + 1]);
+        }
+        else if (boundedArguments[index].startsWith('--port=')) {
+            effectivePort = Number(boundedArguments[index].slice('--port='.length));
+        }
+    }
+    return effectivePort;
+};
+export const processIdentityHasCliCommand = async (identityArg, cliPathArg, commandArg, optionsArg = {}) => {
+    const cliIndex = await findCliArgumentIndex(identityArg.pid, identityArg.arguments, cliPathArg, optionsArg.allowMissingAbsolutePath === true);
+    return cliIndex >= 0 && identityArg.arguments[cliIndex + 1] === commandArg;
+};
+const hasExpectedArguments = async (identityArg, cliPathArg, portArg, commandArg) => {
+    return await processIdentityHasCliCommand(identityArg, cliPathArg, commandArg)
+        && readEffectiveArgvPort(identityArg.arguments) === portArg;
+};
+const visitProcessIdentities = async (visitorArg) => {
+    if (process.platform === 'linux') {
+        const entries = await plugins.fs.promises.readdir('/proc');
+        const processIds = entries
+            .filter((entryArg) => /^[1-9][0-9]*$/.test(entryArg))
+            .map((entryArg) => Number(entryArg))
+            .filter((processIdArg) => processIdArg >= 2)
+            .sort((leftArg, rightArg) => leftArg - rightArg);
+        if (processIds.length > maximumProcessIdentities) {
+            throw new Error('Controller data-writer process inventory exceeds its scan bound.');
+        }
+        for (let index = 0; index < processIds.length; index += processIdentityBatchSize) {
+            const batch = await Promise.all(processIds.slice(index, index + processIdentityBatchSize).map(async (processIdArg) => {
+                try {
+                    return await readControllerProcessIdentity(processIdArg);
+                }
+                catch (errorArg) {
+                    const code = errorArg.code;
+                    if (code === 'EACCES' || code === 'EPERM')
+                        return null;
+                    throw errorArg;
+                }
+            }));
+            for (const identity of batch) {
+                if (identity)
+                    await visitorArg(identity);
+            }
+        }
+        return;
+    }
+    if (process.platform === 'win32')
+        return;
+    const output = await execFile('ps', [
+        '-ax',
+        '-ww',
+        '-o',
+        'pid=',
+        '-o',
+        'pgid=',
+        '-o',
+        'lstart=',
+        '-o',
+        'command=',
+    ], { maxBufferBytes: 8 * 1024 * 1024 });
+    let identityCount = 0;
+    for (const lineArg of output.split(/\r?\n/)) {
+        const match = /^\s*(\d+)\s+(\d+)\s+(.{24})\s+(.+)$/.exec(lineArg);
+        if (!match)
+            continue;
+        const pid = Number(match[1]);
+        const processGroupId = Number(match[2]);
+        if (!Number.isSafeInteger(pid) || !Number.isSafeInteger(processGroupId))
+            continue;
+        identityCount += 1;
+        if (identityCount > maximumProcessIdentities) {
+            throw new Error('Controller data-writer process inventory exceeds its scan bound.');
+        }
+        await visitorArg({
+            pid,
+            processGroupId,
+            processGroupLeader: processGroupId === pid,
+            arguments: parsePosixCommandArguments(match[4]),
+            fingerprint: `posix:${pid}:${match[3].trim()}`,
+        });
+    }
+};
+const compactProcessIdentity = (identityArg) => ({
+    ...identityArg,
+    arguments: [],
+});
+export const listControllerProcessesForCli = async (cliPathArg) => {
+    const candidates = [];
+    await visitProcessIdentities(async (identity) => {
+        for (const command of ['__serve', 'foreground']) {
+            if (!await processIdentityHasCliCommand(identity, cliPathArg, command))
+                continue;
+            const port = readEffectiveArgvPort(identity.arguments);
+            if (!Number.isSafeInteger(port) || port < 1 || port > 65_535) {
+                throw new Error(`An ${currentRuntimeName} process has an invalid port argument (PID ${identity.pid}).`);
+            }
+            candidates.push({ identity: compactProcessIdentity(identity), command, port });
+        }
+    });
+    return candidates.sort((leftArg, rightArg) => leftArg.identity.pid - rightArg.identity.pid);
+};
+export const listControllerDataWriterProcessesForCli = async (cliPathArg, optionsArg = {}) => await listControllerDataWriterProcessesForCliPaths([cliPathArg], optionsArg);
+export const listControllerDataWriterProcessesForCliPaths = async (cliPathsArg, optionsArg = {}) => {
+    const cliPaths = [...new Set(cliPathsArg)];
+    if (cliPaths.length === 0
+        || cliPaths.length > maximumDataWriterCliPaths
+        || cliPaths.some((cliPathArg) => !plugins.path.isAbsolute(cliPathArg)))
+        throw new Error('Controller data-writer CLI path inventory is invalid.');
+    const flexChildPaths = cliPaths.map((cliPathArg) => plugins.path.join(plugins.path.dirname(cliPathArg), 'dist_ts', 'flexharness.child.js'));
+    const candidates = [];
+    await visitProcessIdentities(async (identity) => {
+        let matched = false;
+        for (const cliPath of cliPaths) {
+            if (await processIdentityHasCliCommand(identity, cliPath, '__serve')
+                || await processIdentityHasCliCommand(identity, cliPath, 'foreground')) {
+                matched = true;
+                break;
+            }
+        }
+        if (!matched
+            && optionsArg.includeInstalledPackagePaths === true
+            && (processIdentityHasInstalledControllerCommand(identity, '__serve')
+                || processIdentityHasInstalledControllerCommand(identity, 'foreground')))
+            matched = true;
+        if (matched) {
+            if (candidates.length >= maximumDataWriterCandidates) {
+                throw new Error('Controller data-writer candidate inventory exceeds its scan bound.');
+            }
+            candidates.push({ kind: 'controller', identity: compactProcessIdentity(identity) });
+            return;
+        }
+        for (const cliPath of cliPaths) {
+            if (await processIdentityHasCliCommand(identity, cliPath, 'temp-password')) {
+                matched = true;
+                break;
+            }
+        }
+        if (!matched
+            && optionsArg.includeInstalledPackagePaths === true
+            && processIdentityHasInstalledControllerCommand(identity, 'temp-password'))
+            matched = true;
+        if (matched) {
+            if (candidates.length >= maximumDataWriterCandidates) {
+                throw new Error('Controller data-writer candidate inventory exceeds its scan bound.');
+            }
+            candidates.push({ kind: 'temp-password', identity: compactProcessIdentity(identity) });
+            return;
+        }
+        for (const flexChildPath of flexChildPaths) {
+            if (await processIdentityHasFileArgument(identity, flexChildPath)) {
+                matched = true;
+                break;
+            }
+        }
+        if (!matched
+            && optionsArg.includeInstalledPackagePaths === true
+            && findInstalledControllerPackageFileArgumentIndex(identity.arguments, plugins.path.join('dist_ts', 'flexharness.child.js')) >= 0)
+            matched = true;
+        if (matched) {
+            if (candidates.length >= maximumDataWriterCandidates) {
+                throw new Error('Controller data-writer candidate inventory exceeds its scan bound.');
+            }
+            candidates.push({ kind: 'flex-child', identity: compactProcessIdentity(identity) });
+        }
+    });
+    return candidates.sort((leftArg, rightArg) => leftArg.identity.pid - rightArg.identity.pid);
+};
+export const inspectControllerProcess = async (optionsArg) => {
+    const identity = await readControllerProcessIdentity(optionsArg.pid);
+    if (!identity)
+        return null;
+    if (!await hasExpectedArguments(identity, optionsArg.cliPath, optionsArg.port, optionsArg.command)) {
+        return null;
+    }
+    if (optionsArg.expectedProcessGroupId !== undefined
+        && identity.processGroupId !== optionsArg.expectedProcessGroupId)
+        return null;
+    if (optionsArg.expectedFingerprint !== undefined
+        && identity.fingerprint !== optionsArg.expectedFingerprint)
+        return null;
+    return identity;
+};
+export const signalVerifiedControllerProcess = async (optionsArg) => {
+    const identity = await inspectControllerProcess(optionsArg);
+    if (!identity) {
+        throw new Error('Refusing to signal a process whose controller identity cannot be verified.');
+    }
+    if (optionsArg.signalProcessGroup) {
+        if (!identity.processGroupLeader) {
+            throw new Error('Refusing to signal a process group whose controller is not its leader.');
+        }
+        process.kill(-identity.processGroupId, optionsArg.signal);
+        return;
+    }
+    process.kill(identity.pid, optionsArg.signal);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.processinspection.js","sourceRoot":"","sources":["../../ts/classes.processinspection.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.resourcecoordinator.d.ts

@@ -0,0 +1,64 @@
+import { type TControllerResource, type TControllerSessionId } from '../dist_ts_interfaces/index.js';
+import type { SmartDataAuthStore } from './classes.authstore.js';
+import type { IControllerResourceDocument } from './interfaces.projects.js';
+import { type IFlexBrowserResourceDescriptor } from './interfaces.flexipc.js';
+export interface IControllerResourceRuntimeHost {
+    startResource(resourceArg: IControllerResourceDocument, signalArg: AbortSignal): Promise<void>;
+    stopResource(resourceArg: IControllerResourceDocument, signalArg: AbortSignal): Promise<void>;
+    isRunning(resourceArg: IControllerResourceDocument): boolean;
+    isAvailable(): boolean;
+    renameResource?(resourceArg: IControllerResourceDocument): Promise<void>;
+    reconcileAttachment(resourceArg: IControllerResourceDocument, signalArg: AbortSignal): Promise<void>;
+    retireResource(resourceArg: IControllerResourceDocument, signalArg: AbortSignal): Promise<void>;
+}
+export interface IControllerResourceCoordinatorOptions {
+    store: Pick<SmartDataAuthStore, 'listResources' | 'listRecoverableResources' | 'createResource' | 'renameResource' | 'beginResourceAttachmentTransition' | 'commitResourceAttachmentTransition' | 'beginResourceRetirement' | 'completeResourceRetirement'>;
+    terminalHost: IControllerResourceRuntimeHost;
+    browserHost: IControllerResourceRuntimeHost;
+    isFlexHarnessAvailable(): boolean;
+}
+export declare class ControllerResourceUnavailableError extends Error {
+    readonly code = "resource_unavailable";
+    constructor(messageArg: string);
+}
+export declare class ControllerProjectHasResourcesError extends Error {
+    readonly resourceIds: string[];
+    readonly code = "project_has_resources";
+    constructor(resourceIds: string[]);
+}
+export declare class ControllerResourceCoordinator {
+    private readonly options;
+    private readonly projectStates;
+    private readonly deletingSessions;
+    constructor(options: IControllerResourceCoordinatorOptions);
+    listResources(projectIdArg: string): Promise<TControllerResource[]>;
+    requireResourceKind(projectIdArg: string, resourceIdArg: string, kindArg: IControllerResourceDocument['kind']): Promise<boolean>;
+    createResource(inputArg: Parameters<SmartDataAuthStore['createResource']>[0], signalArg: AbortSignal): Promise<TControllerResource>;
+    renameResource(projectIdArg: string, resourceIdArg: string, titleArg: string): Promise<TControllerResource>;
+    changeAttachment(inputArg: {
+        projectId: string;
+        resourceId: string;
+        sessionId: TControllerSessionId | null;
+        expectedAttachmentRevision: number;
+        signal: AbortSignal;
+    }): Promise<TControllerResource>;
+    retireResource(projectIdArg: string, resourceIdArg: string, signalArg: AbortSignal): Promise<void>;
+    startResource(projectIdArg: string, resourceIdArg: string, signalArg: AbortSignal): Promise<TControllerResource>;
+    stopResource(projectIdArg: string, resourceIdArg: string, signalArg: AbortSignal): Promise<TControllerResource>;
+    recover(signalArg: AbortSignal): Promise<void>;
+    withSessionDeletion<T>(projectIdArg: string, sessionIdArg: TControllerSessionId, signalArg: AbortSignal, deleteArg: () => Promise<T>): Promise<T>;
+    withProjectRemovalGuard<T>(projectIdArg: string, removeArg: () => Promise<T>): Promise<T>;
+    resolveFlexBrowserResources(projectIdArg: string, sessionIdArg: string): Promise<IFlexBrowserResourceDescriptor[]>;
+    requireFlexBrowserResource(inputArg: {
+        projectId: string;
+        sessionId: string;
+        resourceId: string;
+        attachmentRevision: number;
+    }): Promise<IControllerResourceDocument>;
+    private reconcilePendingAttachment;
+    private toPublicResource;
+    private hostFor;
+    private projectState;
+    private runProjectMutation;
+    private sessionKey;
+}