@taskforcehq/taskforce 0.3.328 → 0.3.330

package/dist/services/modelProviderConnectionService.d.ts

@@ -0,0 +1,71 @@
+import type { ModelProviderConnectionDisplayMetadata, ModelProviderConnectionRecord, ModelProviderConnectionLease, ModelProviderConnectionStore } from '../storage/modelProviderConnectionStore.js';
+import type { ModelProviderCredentialHomeManager } from './modelProviderCredentialHome.js';
+export interface PublicModelProviderConnection {
+    id: string;
+    providerKey: string;
+    authenticationType: string;
+    lifecycleStatus: ModelProviderConnectionRecord['lifecycleStatus'];
+    displayMetadata: ModelProviderConnectionDisplayMetadata;
+    lastVerifiedAt: string | null;
+    lastRefreshedAt: string | null;
+    failureCode: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ModelProviderConnectionOperationContext {
+    connection: ModelProviderConnectionRecord;
+    environment: NodeJS.ProcessEnv;
+    lease: ModelProviderConnectionLease;
+    signal: AbortSignal;
+}
+export type ModelProviderConnectionOperation = (context: ModelProviderConnectionOperationContext) => Promise<{
+    displayMetadata?: unknown;
+} | void>;
+export interface ModelProviderConnectionLifecycleHandlers {
+    verify?: ModelProviderConnectionOperation;
+    refresh?: ModelProviderConnectionOperation;
+    disconnect?: ModelProviderConnectionOperation;
+}
+export declare class ModelProviderConnectionService {
+    private readonly store;
+    private readonly credentialHomes;
+    private readonly hasGrant;
+    private readonly supportedConnectionTypes;
+    private readonly handlers;
+    constructor(store: ModelProviderConnectionStore, credentialHomes: ModelProviderCredentialHomeManager, hasGrant: (userId: string) => boolean, handlers?: Array<{
+        providerKey: string;
+        authenticationType: string;
+        lifecycle: ModelProviderConnectionLifecycleHandlers;
+    }>, supportedConnectionTypes?: Array<{
+        providerKey: string;
+        authenticationType: string;
+    }>);
+    create(input: {
+        ownerUserId: string;
+        providerKey: string;
+        authenticationType: string;
+    }): PublicModelProviderConnection;
+    list(ownerUserId: string): PublicModelProviderConnection[];
+    get(ownerUserId: string, connectionId: string): PublicModelProviderConnection;
+    rename(ownerUserId: string, connectionId: string, displayName: unknown): PublicModelProviderConnection;
+    verify(ownerUserId: string, connectionId: string): Promise<PublicModelProviderConnection>;
+    refresh(ownerUserId: string, connectionId: string): Promise<PublicModelProviderConnection>;
+    disconnect(ownerUserId: string, connectionId: string): Promise<PublicModelProviderConnection>;
+    cleanup(ownerUserId: string, connectionId: string): Promise<{
+        id: string;
+        deleted: true;
+    }>;
+    withConnectionLease<T>(input: {
+        ownerUserId: string;
+        connectionId: string;
+        operation: 'login' | 'verify' | 'refresh' | 'invoke' | 'disconnect';
+        requireGrant?: boolean;
+        leaseDurationMs?: number;
+    }, callback: (context: ModelProviderConnectionOperationContext) => Promise<T>): Promise<T>;
+    assertReady(ownerUserId: string, connectionId: string): ModelProviderConnectionRecord;
+    private runWithConnectionLease;
+    private runOperation;
+    private assertGranted;
+    private assertOperationAvailable;
+    private assertOwner;
+}

package/dist/services/modelProviderConnectionService.js

@@ -0,0 +1,279 @@
+import { ModelProviderConnectionError } from '../storage/modelProviderConnectionStore.js';
+function publicConnection(record) {
+    return {
+        id: record.id,
+        providerKey: record.providerKey,
+        authenticationType: record.authenticationType,
+        lifecycleStatus: record.lifecycleStatus,
+        displayMetadata: record.displayMetadata,
+        lastVerifiedAt: record.lastVerifiedAt,
+        lastRefreshedAt: record.lastRefreshedAt,
+        failureCode: record.failureCode,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+    };
+}
+function handlerKey(providerKey, authenticationType) {
+    return `${providerKey}\0${authenticationType}`;
+}
+const RECONNECT_REQUIRED_ERROR_CODES = new Set([
+    'MODEL_CONNECTION_ACCOUNT_UNAVAILABLE',
+    'MODEL_CONNECTION_PROVIDER_FAILURE',
+]);
+export class ModelProviderConnectionService {
+    store;
+    credentialHomes;
+    hasGrant;
+    supportedConnectionTypes;
+    handlers = new Map();
+    constructor(store, credentialHomes, hasGrant, handlers = [], supportedConnectionTypes = [{ providerKey: 'openai', authenticationType: 'chatgpt_device_code' }]) {
+        this.store = store;
+        this.credentialHomes = credentialHomes;
+        this.hasGrant = hasGrant;
+        this.supportedConnectionTypes = supportedConnectionTypes;
+        for (const entry of handlers) {
+            this.handlers.set(handlerKey(entry.providerKey, entry.authenticationType), entry.lifecycle);
+        }
+    }
+    create(input) {
+        this.assertGranted(input.ownerUserId);
+        const key = handlerKey(input.providerKey, input.authenticationType);
+        const supported = this.supportedConnectionTypes.some((entry) => handlerKey(entry.providerKey, entry.authenticationType) === key) || this.handlers.has(key);
+        if (!supported) {
+            throw new ModelProviderConnectionError('This model connection type is not available.', 400, 'MODEL_CONNECTION_TYPE_UNAVAILABLE');
+        }
+        if (!this.credentialHomes.isConfigured()) {
+            throw new ModelProviderConnectionError('Model connection credential storage is unavailable.', 503, 'MODEL_CONNECTION_STORAGE_UNAVAILABLE');
+        }
+        this.credentialHomes.prepareStorage();
+        const connection = this.store.create(input);
+        try {
+            this.credentialHomes.provision(connection);
+        }
+        catch (error) {
+            this.store.deletePendingOwned(input.ownerUserId, connection.id);
+            this.credentialHomes.removeProvisioningFailure(connection.credentialHomeRef);
+            throw error;
+        }
+        return publicConnection(connection);
+    }
+    list(ownerUserId) {
+        this.assertOwner(ownerUserId);
+        return this.store.listOwned(ownerUserId).map(publicConnection);
+    }
+    get(ownerUserId, connectionId) {
+        this.assertOwner(ownerUserId);
+        return publicConnection(this.store.requireOwned(ownerUserId, connectionId));
+    }
+    rename(ownerUserId, connectionId, displayName) {
+        this.assertOwner(ownerUserId);
+        return publicConnection(this.store.renameOwned(ownerUserId, connectionId, displayName));
+    }
+    async verify(ownerUserId, connectionId) {
+        return this.runOperation(ownerUserId, connectionId, 'verify', (context, result) => (this.store.markVerified({
+            ownerUserId,
+            connectionId,
+            leaseToken: context.lease.token,
+            displayMetadata: result?.displayMetadata,
+        })));
+    }
+    async refresh(ownerUserId, connectionId) {
+        return this.runOperation(ownerUserId, connectionId, 'refresh', (context, result) => (this.store.markRefreshed({
+            ownerUserId,
+            connectionId,
+            leaseToken: context.lease.token,
+            displayMetadata: result?.displayMetadata,
+        })));
+    }
+    async disconnect(ownerUserId, connectionId) {
+        this.assertOwner(ownerUserId);
+        const current = this.store.requireOwned(ownerUserId, connectionId);
+        if (current.lifecycleStatus === 'disconnected')
+            return publicConnection(current);
+        return this.runOperation(ownerUserId, connectionId, 'disconnect', (context) => (this.store.markDisconnected({
+            ownerUserId,
+            connectionId,
+            leaseToken: context.lease.token,
+        })), false);
+    }
+    async cleanup(ownerUserId, connectionId) {
+        this.assertOwner(ownerUserId);
+        const connection = this.store.requireOwned(ownerUserId, connectionId);
+        if (connection.lifecycleStatus !== 'pending'
+            && connection.lifecycleStatus !== 'reconnect_required'
+            && connection.lifecycleStatus !== 'disconnected'
+            && connection.lifecycleStatus !== 'revoked') {
+            throw new ModelProviderConnectionError('Disconnect the model connection before removing its credential storage.', 409, 'MODEL_CONNECTION_DISCONNECT_REQUIRED');
+        }
+        return this.runWithConnectionLease({
+            ownerUserId,
+            connectionId,
+            operation: 'cleanup',
+            requireGrant: false,
+        }, async ({ connection: leasedConnection, lease }) => {
+            this.credentialHomes.removeCredentialHome(leasedConnection.credentialHomeRef);
+            if (!this.store.deleteCleanableUnderLease({
+                ownerUserId,
+                connectionId,
+                leaseToken: lease.token,
+            })) {
+                throw new ModelProviderConnectionError('Model connection cleanup could not be completed.', 409, 'MODEL_CONNECTION_CLEANUP_INCOMPLETE');
+            }
+            return { id: connectionId, deleted: true };
+        }, true);
+    }
+    async withConnectionLease(input, callback) {
+        return this.runWithConnectionLease(input, callback, false);
+    }
+    assertReady(ownerUserId, connectionId) {
+        this.assertGranted(ownerUserId);
+        const connection = this.store.requireOwned(ownerUserId, connectionId);
+        this.assertOperationAvailable(connection, 'invoke');
+        this.credentialHomes.assertStorageReady();
+        this.credentialHomes.assertReady(connection.credentialHomeRef, connection);
+        return connection;
+    }
+    async runWithConnectionLease(input, callback, callbackConsumesLease) {
+        if (input.requireGrant === false)
+            this.assertOwner(input.ownerUserId);
+        else
+            this.assertGranted(input.ownerUserId);
+        this.store.requireOwned(input.ownerUserId, input.connectionId);
+        this.credentialHomes.assertStorageReady();
+        const leaseDurationMs = Math.min(10 * 60_000, Math.max(3_000, input.leaseDurationMs ?? 120_000));
+        const lease = this.store.acquireLease({
+            ownerUserId: input.ownerUserId,
+            connectionId: input.connectionId,
+            operation: input.operation,
+            durationMs: leaseDurationMs,
+        });
+        let leaseCompleted = false;
+        const abortController = new AbortController();
+        const heartbeat = setInterval(() => {
+            try {
+                if (!this.store.renewLease(lease, leaseDurationMs))
+                    abortController.abort();
+            }
+            catch {
+                abortController.abort();
+            }
+        }, Math.max(1_000, Math.floor(leaseDurationMs / 3)));
+        heartbeat.unref?.();
+        try {
+            const connection = this.store.requireOwnedUnderLease(input.ownerUserId, input.connectionId, lease.token);
+            this.assertOperationAvailable(connection, input.operation);
+            const homeExists = this.credentialHomes.hasCredentialHome(connection.credentialHomeRef);
+            if (input.operation !== 'cleanup') {
+                this.credentialHomes.assertReady(connection.credentialHomeRef, connection);
+            }
+            const result = await callback({
+                connection,
+                lease,
+                signal: abortController.signal,
+                environment: homeExists && input.operation !== 'cleanup'
+                    ? this.credentialHomes.buildCodexEnvironment(connection.credentialHomeRef, process.env, connection)
+                    : {},
+            });
+            if (input.operation !== 'cleanup') {
+                this.credentialHomes.assertReady(connection.credentialHomeRef, connection);
+            }
+            if (abortController.signal.aborted) {
+                throw new ModelProviderConnectionError('Model connection operation lease was lost.', 409, 'MODEL_CONNECTION_LEASE_LOST');
+            }
+            if (!callbackConsumesLease && !this.store.completeLease(lease)) {
+                throw new ModelProviderConnectionError('Model connection operation lease was lost.', 409, 'MODEL_CONNECTION_LEASE_LOST');
+            }
+            leaseCompleted = true;
+            return result;
+        }
+        finally {
+            clearInterval(heartbeat);
+            if (!leaseCompleted)
+                this.store.releaseLease(lease);
+        }
+    }
+    async runOperation(ownerUserId, connectionId, operation, finalize, requireGrant = true) {
+        if (requireGrant)
+            this.assertGranted(ownerUserId);
+        else
+            this.assertOwner(ownerUserId);
+        const connection = this.store.requireOwned(ownerUserId, connectionId);
+        if (connection.lifecycleStatus === 'revoked' || connection.lifecycleStatus === 'disconnected') {
+            throw new ModelProviderConnectionError('Model connection is unavailable.', 409, 'MODEL_CONNECTION_UNAVAILABLE');
+        }
+        const handler = this.handlers.get(handlerKey(connection.providerKey, connection.authenticationType))?.[operation];
+        if (!handler) {
+            throw new ModelProviderConnectionError('This model connection operation is not available.', 409, 'MODEL_CONNECTION_OPERATION_UNAVAILABLE');
+        }
+        try {
+            return await this.withConnectionLease({
+                ownerUserId,
+                connectionId,
+                operation,
+                requireGrant,
+            }, async (context) => {
+                try {
+                    const result = await handler(context);
+                    return publicConnection(finalize(context, result));
+                }
+                catch (error) {
+                    if (!(error instanceof ModelProviderConnectionError)
+                        || RECONNECT_REQUIRED_ERROR_CODES.has(error.code)) {
+                        try {
+                            this.store.markReconnectRequired({
+                                ownerUserId,
+                                connectionId,
+                                leaseToken: context.lease.token,
+                                failureCode: error instanceof ModelProviderConnectionError
+                                    ? error.code.toLowerCase()
+                                    : 'provider_operation_failed',
+                            });
+                        }
+                        catch {
+                            // The lease-loss path remains authoritative.
+                        }
+                    }
+                    throw error;
+                }
+            });
+        }
+        catch (error) {
+            if (error instanceof ModelProviderConnectionError)
+                throw error;
+            throw new ModelProviderConnectionError('The model provider connection operation failed.', 502, 'MODEL_CONNECTION_PROVIDER_FAILURE');
+        }
+    }
+    assertGranted(userIdRaw) {
+        const userId = this.assertOwner(userIdRaw);
+        if (!this.hasGrant(userId)) {
+            throw new ModelProviderConnectionError('Subscription-backed model access is not enabled for this account.', 403, 'SUBSCRIPTION_MODEL_ACCESS_REQUIRED');
+        }
+    }
+    assertOperationAvailable(connection, operation) {
+        const status = connection.lifecycleStatus;
+        const available = operation === 'login'
+            ? status === 'pending' || status === 'reconnect_required' || status === 'disconnected'
+            : operation === 'invoke'
+                ? status === 'active'
+                : operation === 'cleanup'
+                    ? status === 'pending'
+                        || status === 'reconnect_required'
+                        || status === 'disconnected'
+                        || status === 'revoked'
+                    : operation === 'verify' || operation === 'refresh'
+                        ? status === 'pending' || status === 'reconnect_required' || status === 'active'
+                        : operation === 'disconnect'
+                            ? status === 'pending' || status === 'reconnect_required' || status === 'active'
+                            : false;
+        if (!available) {
+            throw new ModelProviderConnectionError('Model connection is unavailable.', 409, 'MODEL_CONNECTION_UNAVAILABLE');
+        }
+    }
+    assertOwner(userIdRaw) {
+        const userId = String(userIdRaw || '').trim();
+        if (!userId) {
+            throw new ModelProviderConnectionError('Authentication is required.', 401, 'AUTH_REQUIRED');
+        }
+        return userId;
+    }
+}

package/dist/services/modelProviderCredentialHome.d.ts

@@ -0,0 +1,32 @@
+interface CredentialHomeConnectionType {
+    providerKey: string;
+    authenticationType: string;
+}
+export declare class ModelProviderCredentialHomeManager {
+    private readonly root;
+    private readonly homesRoot;
+    constructor(rootPath?: string | null | undefined);
+    isConfigured(): boolean;
+    prepareStorage(): void;
+    provision(input: {
+        credentialHomeRef: string;
+        providerKey: string;
+        authenticationType: string;
+    }): void;
+    assertReady(credentialHomeRef: string, connectionType?: CredentialHomeConnectionType): void;
+    assertStorageReady(): void;
+    buildCodexEnvironment(credentialHomeRef: string, source?: NodeJS.ProcessEnv, connectionType?: CredentialHomeConnectionType): NodeJS.ProcessEnv;
+    /** Internal-only path list for diagnostics redaction. Never serialize this value. */
+    credentialPathsForRedaction(credentialHomeRef: string): string[];
+    hasCredentialHome(credentialHomeRef: string): boolean;
+    removeCredentialHome(credentialHomeRef: string): void;
+    removeProvisioningFailure(credentialHomeRef: string): void;
+    private resolveHomePath;
+    private ensurePrivateDirectory;
+    private assertPrivateDirectory;
+    private assertPrivateHomeLayout;
+    private assertPrivateHomeRoot;
+    private assertPrivateFile;
+    private writePrivateFile;
+}
+export {};

package/dist/services/modelProviderCredentialHome.js

@@ -0,0 +1,271 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { parse as parseToml } from '@iarna/toml';
+import { ModelProviderConnectionError } from '../storage/modelProviderConnectionStore.js';
+import { ensureWindowsUserOnlyDirectoryAcl } from '../server/localServiceWindowsAcl.js';
+const CREDENTIAL_HOME_REF_PATTERN = /^home_[A-Za-z0-9_-]{24,64}$/;
+const CODEX_FILE_AUTH_CONFIG = [
+    'cli_auth_credentials_store = "file"',
+    'forced_login_method = "chatgpt"',
+    '',
+].join('\n');
+const PROCESS_ENV_ALLOWLIST = [
+    'PATH',
+    'SHELL',
+    'USER',
+    'LOGNAME',
+    'LANG',
+    'LC_ALL',
+    'LC_CTYPE',
+    'TERM',
+    'COLORTERM',
+    'NO_COLOR',
+];
+function isInside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function storageUnavailable() {
+    return new ModelProviderConnectionError('Model connection credential storage is unavailable.', 503, 'MODEL_CONNECTION_STORAGE_UNAVAILABLE');
+}
+export class ModelProviderCredentialHomeManager {
+    root;
+    homesRoot;
+    constructor(rootPath = process.env.TASKFORCE_MODEL_CONNECTION_STORAGE_PATH) {
+        const configured = String(rootPath || '').trim();
+        if (!configured || !path.isAbsolute(configured)) {
+            this.root = '';
+            this.homesRoot = '';
+            return;
+        }
+        this.root = path.resolve(configured);
+        this.homesRoot = path.join(this.root, 'connections');
+    }
+    isConfigured() {
+        return Boolean(this.root);
+    }
+    prepareStorage() {
+        if (!this.root)
+            throw storageUnavailable();
+        try {
+            this.ensurePrivateDirectory(this.root);
+            this.ensurePrivateDirectory(this.homesRoot);
+        }
+        catch (error) {
+            if (error instanceof ModelProviderConnectionError)
+                throw error;
+            throw storageUnavailable();
+        }
+    }
+    provision(input) {
+        const homePath = this.resolveHomePath(input.credentialHomeRef);
+        try {
+            this.prepareStorage();
+            this.ensurePrivateDirectory(homePath);
+            this.ensurePrivateDirectory(path.join(homePath, 'tmp'));
+            this.ensurePrivateDirectory(path.join(homePath, 'xdg-config'));
+            this.ensurePrivateDirectory(path.join(homePath, 'xdg-cache'));
+            this.ensurePrivateDirectory(path.join(homePath, 'xdg-data'));
+            if (input.providerKey === 'openai' && input.authenticationType === 'chatgpt_device_code') {
+                this.writePrivateFile(path.join(homePath, 'config.toml'), CODEX_FILE_AUTH_CONFIG);
+            }
+        }
+        catch (error) {
+            if (error instanceof ModelProviderConnectionError)
+                throw error;
+            throw storageUnavailable();
+        }
+    }
+    assertReady(credentialHomeRef, connectionType) {
+        const homePath = this.resolveHomePath(credentialHomeRef);
+        try {
+            this.assertPrivateHomeLayout(homePath);
+            if (connectionType?.providerKey === 'openai'
+                && connectionType.authenticationType === 'chatgpt_device_code') {
+                const configPath = path.join(homePath, 'config.toml');
+                this.assertPrivateFile(configPath, true);
+                this.assertPrivateFile(path.join(homePath, 'auth.json'), false);
+                const config = parseToml(fs.readFileSync(configPath, 'utf8'));
+                if (config.cli_auth_credentials_store !== 'file'
+                    || config.forced_login_method !== 'chatgpt') {
+                    throw storageUnavailable();
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof ModelProviderConnectionError)
+                throw error;
+            throw storageUnavailable();
+        }
+    }
+    assertStorageReady() {
+        if (!this.root)
+            throw storageUnavailable();
+        try {
+            this.assertPrivateDirectory(this.root);
+            this.assertPrivateDirectory(this.homesRoot);
+        }
+        catch (error) {
+            if (error instanceof ModelProviderConnectionError)
+                throw error;
+            throw storageUnavailable();
+        }
+    }
+    buildCodexEnvironment(credentialHomeRef, source = process.env, connectionType) {
+        this.assertReady(credentialHomeRef, connectionType);
+        const homePath = this.resolveHomePath(credentialHomeRef);
+        const environment = {};
+        for (const key of PROCESS_ENV_ALLOWLIST) {
+            const value = source[key];
+            if (typeof value === 'string' && value)
+                environment[key] = value;
+        }
+        return {
+            ...environment,
+            HOME: homePath,
+            CODEX_HOME: this.resolveHomePath(credentialHomeRef),
+            XDG_CONFIG_HOME: path.join(homePath, 'xdg-config'),
+            XDG_CACHE_HOME: path.join(homePath, 'xdg-cache'),
+            XDG_DATA_HOME: path.join(homePath, 'xdg-data'),
+            TMPDIR: path.join(homePath, 'tmp'),
+            TEMP: path.join(homePath, 'tmp'),
+            TMP: path.join(homePath, 'tmp'),
+        };
+    }
+    /** Internal-only path list for diagnostics redaction. Never serialize this value. */
+    credentialPathsForRedaction(credentialHomeRef) {
+        return [this.resolveHomePath(credentialHomeRef), this.root];
+    }
+    hasCredentialHome(credentialHomeRef) {
+        const homePath = this.resolveHomePath(credentialHomeRef);
+        return fs.existsSync(homePath);
+    }
+    removeCredentialHome(credentialHomeRef) {
+        this.assertStorageReady();
+        const homePath = this.resolveHomePath(credentialHomeRef);
+        let stat;
+        try {
+            stat = fs.lstatSync(homePath);
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT')
+                return;
+            throw storageUnavailable();
+        }
+        try {
+            if (stat.isSymbolicLink()) {
+                fs.unlinkSync(homePath);
+                return;
+            }
+            if (!stat.isDirectory())
+                throw storageUnavailable();
+            this.assertPrivateHomeRoot(homePath);
+            fs.rmSync(homePath, { recursive: true, force: false });
+        }
+        catch {
+            throw storageUnavailable();
+        }
+    }
+    removeProvisioningFailure(credentialHomeRef) {
+        const homePath = this.resolveHomePath(credentialHomeRef);
+        try {
+            const stat = fs.lstatSync(homePath);
+            if (stat.isDirectory() && !stat.isSymbolicLink()) {
+                fs.rmSync(homePath, { recursive: true, force: false });
+            }
+        }
+        catch {
+            // Best-effort cleanup only; the failed home reference is never reused.
+        }
+    }
+    resolveHomePath(credentialHomeRefRaw) {
+        if (!this.root)
+            throw storageUnavailable();
+        const credentialHomeRef = String(credentialHomeRefRaw || '').trim();
+        if (!CREDENTIAL_HOME_REF_PATTERN.test(credentialHomeRef))
+            throw storageUnavailable();
+        const candidate = path.resolve(this.homesRoot, credentialHomeRef);
+        if (!isInside(this.homesRoot, candidate))
+            throw storageUnavailable();
+        return candidate;
+    }
+    ensurePrivateDirectory(directory) {
+        fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+        this.assertPrivateDirectory(directory);
+    }
+    assertPrivateDirectory(directory) {
+        const stat = fs.lstatSync(directory);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            throw storageUnavailable();
+        if (process.platform === 'win32') {
+            ensureWindowsUserOnlyDirectoryAcl(directory);
+            return;
+        }
+        if (typeof process.getuid === 'function' && stat.uid !== process.getuid())
+            throw storageUnavailable();
+        fs.chmodSync(directory, 0o700);
+        if ((fs.statSync(directory).mode & 0o077) !== 0)
+            throw storageUnavailable();
+    }
+    assertPrivateHomeLayout(homePath) {
+        this.assertPrivateHomeRoot(homePath);
+        for (const directory of [
+            path.join(homePath, 'tmp'),
+            path.join(homePath, 'xdg-config'),
+            path.join(homePath, 'xdg-cache'),
+            path.join(homePath, 'xdg-data'),
+        ]) {
+            this.assertPrivateDirectory(directory);
+        }
+    }
+    assertPrivateHomeRoot(homePath) {
+        for (const directory of [this.root, this.homesRoot, homePath]) {
+            this.assertPrivateDirectory(directory);
+        }
+        const rootRealPath = fs.realpathSync(this.homesRoot);
+        const homeRealPath = fs.realpathSync(homePath);
+        if (!isInside(rootRealPath, homeRealPath))
+            throw storageUnavailable();
+    }
+    assertPrivateFile(filePath, required) {
+        let stat;
+        try {
+            stat = fs.lstatSync(filePath);
+        }
+        catch (error) {
+            if (!required && error?.code === 'ENOENT')
+                return;
+            throw storageUnavailable();
+        }
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink > 1)
+            throw storageUnavailable();
+        if (process.platform === 'win32')
+            return;
+        if (typeof process.getuid === 'function' && stat.uid !== process.getuid())
+            throw storageUnavailable();
+        fs.chmodSync(filePath, 0o600);
+        if ((fs.statSync(filePath).mode & 0o077) !== 0)
+            throw storageUnavailable();
+    }
+    writePrivateFile(filePath, content) {
+        const temporaryPath = `${filePath}.${randomBytes(8).toString('hex')}.tmp`;
+        try {
+            fs.writeFileSync(temporaryPath, content, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+            if (process.platform !== 'win32')
+                fs.chmodSync(temporaryPath, 0o600);
+            fs.renameSync(temporaryPath, filePath);
+            if (process.platform !== 'win32')
+                fs.chmodSync(filePath, 0o600);
+        }
+        finally {
+            try {
+                if (fs.existsSync(temporaryPath))
+                    fs.unlinkSync(temporaryPath);
+            }
+            catch {
+                // Preserve the original storage failure.
+            }
+        }
+    }
+}

package/dist/services/ownerScopedModelConnectionGateway.d.ts

@@ -0,0 +1,12 @@
+import type { ModelGateway, ModelGatewayGenerateInput, ModelGatewayGenerateResult } from './modelGateway.js';
+import type { ModelProviderConnectionOperationContext, ModelProviderConnectionService } from './modelProviderConnectionService.js';
+type ConnectionService = Pick<ModelProviderConnectionService, 'withConnectionLease'>;
+export declare class OwnerScopedModelConnectionGateway implements ModelGateway {
+    private readonly connectionService;
+    private readonly ownerUserId;
+    private readonly connectionId;
+    private readonly createGateway;
+    constructor(connectionService: ConnectionService, ownerUserId: string, connectionId: string, createGateway: (context: ModelProviderConnectionOperationContext) => ModelGateway);
+    generate(input: ModelGatewayGenerateInput): Promise<ModelGatewayGenerateResult>;
+}
+export {};