agl 1.0.17 → 21.0.2

package/dist_ts/classes.terminalresourcehost.d.ts

@@ -0,0 +1,20 @@
+import type { SmartDataAuthStore } from './classes.authstore.js';
+import type { IControllerResourceRuntimeHost } from './classes.resourcecoordinator.js';
+import type { ControllerTerminalManager } from './classes.terminalmanager.js';
+import type { IControllerResourceDocument } from './interfaces.projects.js';
+export declare class ControllerTerminalResourceHost implements IControllerResourceRuntimeHost {
+    private readonly terminalManager;
+    private readonly store;
+    private readonly pendingStoppedResources;
+    constructor(terminalManager: ControllerTerminalManager, store: Pick<SmartDataAuthStore, 'markTerminalResourceRunning' | 'markTerminalResourceStopped'>);
+    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(): Promise<void>;
+    retireResource(resourceArg: IControllerResourceDocument, signalArg: AbortSignal): Promise<void>;
+    recordTerminalStopped(projectIdArg: string, resourceIdArg: string, lastExitCodeArg?: number): Promise<void>;
+    flushPendingStoppedResources(): Promise<void>;
+    private resourceKey;
+}

package/dist_ts/classes.terminalresourcehost.js

@@ -0,0 +1,84 @@
+export class ControllerTerminalResourceHost {
+    terminalManager;
+    store;
+    pendingStoppedResources = new Map();
+    constructor(terminalManager, store) {
+        this.terminalManager = terminalManager;
+        this.store = store;
+    }
+    async startResource(resourceArg, signalArg) {
+        signalArg.throwIfAborted();
+        this.pendingStoppedResources.delete(this.resourceKey(resourceArg.projectId, resourceArg.id));
+        try {
+            await this.terminalManager.startTerminalResource(resourceArg);
+            await this.store.markTerminalResourceRunning(resourceArg.projectId, resourceArg.id);
+        }
+        catch (errorArg) {
+            const cleanupErrors = [];
+            await this.terminalManager.stopTerminalResource(resourceArg.projectId, resourceArg.id)
+                .catch((cleanupErrorArg) => cleanupErrors.push(cleanupErrorArg));
+            await this.store.markTerminalResourceStopped(resourceArg.projectId, resourceArg.id)
+                .catch((cleanupErrorArg) => cleanupErrors.push(cleanupErrorArg));
+            if (cleanupErrors.length > 0) {
+                throw new AggregateError([errorArg, ...cleanupErrors], 'Terminal startup cleanup is incomplete.');
+            }
+            throw errorArg;
+        }
+    }
+    async stopResource(resourceArg, signalArg) {
+        signalArg.throwIfAborted();
+        await this.terminalManager.stopTerminalResource(resourceArg.projectId, resourceArg.id);
+        await this.store.markTerminalResourceStopped(resourceArg.projectId, resourceArg.id);
+        this.pendingStoppedResources.delete(this.resourceKey(resourceArg.projectId, resourceArg.id));
+    }
+    isRunning(resourceArg) {
+        return this.terminalManager.isTerminalRunning(resourceArg.projectId, resourceArg.id);
+    }
+    isAvailable() {
+        return true;
+    }
+    async renameResource(resourceArg) {
+        await this.terminalManager.renameTerminalResource(resourceArg.projectId, resourceArg.id, resourceArg.title);
+    }
+    async reconcileAttachment() {
+        await this.flushPendingStoppedResources();
+    }
+    async retireResource(resourceArg, signalArg) {
+        await this.stopResource(resourceArg, signalArg);
+    }
+    async recordTerminalStopped(projectIdArg, resourceIdArg, lastExitCodeArg) {
+        const key = this.resourceKey(projectIdArg, resourceIdArg);
+        const pending = {
+            projectId: projectIdArg,
+            resourceId: resourceIdArg,
+            ...(lastExitCodeArg === undefined ? {} : { lastExitCode: lastExitCodeArg }),
+        };
+        this.pendingStoppedResources.set(key, pending);
+        await this.store.markTerminalResourceStopped(projectIdArg, resourceIdArg, {
+            ...(lastExitCodeArg === undefined ? {} : { lastExitCode: lastExitCodeArg }),
+        });
+        if (this.pendingStoppedResources.get(key) === pending) {
+            this.pendingStoppedResources.delete(key);
+        }
+    }
+    async flushPendingStoppedResources() {
+        const results = await Promise.allSettled([...this.pendingStoppedResources.entries()].map(async ([key, pending]) => {
+            await this.store.markTerminalResourceStopped(pending.projectId, pending.resourceId, {
+                ...(pending.lastExitCode === undefined ? {} : { lastExitCode: pending.lastExitCode }),
+            });
+            if (this.pendingStoppedResources.get(key) === pending) {
+                this.pendingStoppedResources.delete(key);
+            }
+        }));
+        const errors = results
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (errors.length > 0) {
+            throw new AggregateError(errors, 'Terminal stopped-state persistence is incomplete.');
+        }
+    }
+    resourceKey(projectIdArg, resourceIdArg) {
+        return JSON.stringify([projectIdArg, resourceIdArg]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.upgradecoordinator.d.ts

@@ -0,0 +1,244 @@
+import { type IControllerRuntimeId, type IControllerUpgradeStatus } from '../dist_ts_interfaces/index.js';
+export declare const upgradeCoordinationVersion: 2;
+declare const coordinationVersion: 2;
+export declare const upgradePackageTransitionTransactionVersion: 3;
+export declare const upgradePackageTransitionSource: {
+    readonly packageName: "@modelprofile.com/harness-controller";
+    readonly version: "20.0.3";
+    readonly managementVersion: 1;
+    readonly cliName: "hcon";
+    readonly cliRelativePath: "./cli.js";
+};
+export declare const upgradePackageTransitionTarget: {
+    readonly packageName: "agl";
+    readonly version: "21.0.0";
+    readonly managementVersion: 2;
+    readonly cliName: "agl";
+    readonly cliRelativePath: "./cli.js";
+};
+export declare const upgradeTokenEnvironmentVariable = "HARNESS_CONTROLLER_UPGRADE_TOKEN";
+type TUpgradeOwnerKind = 'upgrade' | 'start';
+interface IUpgradeProcessOwner {
+    version: typeof coordinationVersion;
+    kind: TUpgradeOwnerKind;
+    uid: number;
+    tokenHash: string;
+    pid: number;
+    processGroupId: number;
+    fingerprint: string;
+    cliPath: string;
+    command: '__serve' | '__upgrade-worker' | 'upgrade' | 'start' | 'foreground' | 'temp-password';
+    createdAt: number;
+}
+export interface IUpgradeExpectedController {
+    pid: number;
+    processGroupId: number;
+    processFingerprint: string;
+}
+export interface IUpgradeWorkerPayload {
+    version: typeof coordinationVersion;
+    token: string;
+    port: number;
+    gracePeriodMs: number;
+    continueSessions: boolean;
+    expectedController?: IUpgradeExpectedController;
+}
+export type TUpgradeSessionTransitionState = 'pending' | 'submitting' | 'accepted' | 'paused' | 'outcomeUnknown' | 'failed';
+export interface IUpgradeSessionState {
+    projectId: string;
+    sessionId: IControllerRuntimeId;
+    pauseState: TUpgradeSessionTransitionState;
+    pauseQueueId?: string;
+    cleanupState?: TUpgradeSessionTransitionState;
+    continueState?: TUpgradeSessionTransitionState;
+    error?: string;
+}
+interface IUpgradeTransactionBase {
+    tokenHash: string;
+    revision: number;
+    port: number;
+    controllerWasRunning: boolean;
+    continueSessions: boolean;
+    gracePeriodMs: number;
+    preparationAcceptedAt?: number;
+    preparationDeadlineAt?: number;
+    preparationCompletedAt?: number;
+    phase: IControllerUpgradeStatus['phase'] | 'starting' | 'checking' | 'stopping';
+    message: string;
+    createdAt: number;
+    phaseStartedAt: number;
+    updatedAt: number;
+    retainedUntil?: number;
+    worker?: {
+        pid: number;
+        processGroupId: number;
+        fingerprint: string;
+        cliPath: string;
+        logFilePath?: string;
+    };
+    controller?: {
+        pid: number;
+        processGroupId: number;
+        fingerprint: string;
+        cliPath: string;
+        command: '__serve' | 'foreground';
+    };
+    sessions: IUpgradeSessionState[];
+    terminal?: {
+        success: boolean;
+        error?: string;
+    };
+}
+export interface IUpgradeTransactionV2 extends IUpgradeTransactionBase {
+    version: typeof coordinationVersion;
+    sourceVersion: string;
+    targetVersion?: string;
+    targetStartupInvoked?: true;
+}
+export interface IUpgradeTransactionV3 extends IUpgradeTransactionBase {
+    version: typeof upgradePackageTransitionTransactionVersion;
+    sourcePackageName: typeof upgradePackageTransitionSource.packageName;
+    sourceVersion: typeof upgradePackageTransitionSource.version;
+    sourceManagementVersion: typeof upgradePackageTransitionSource.managementVersion;
+    sourceCliName: typeof upgradePackageTransitionSource.cliName;
+    sourceCliRelativePath: typeof upgradePackageTransitionSource.cliRelativePath;
+    targetPackageName: typeof upgradePackageTransitionTarget.packageName;
+    targetVersion: typeof upgradePackageTransitionTarget.version;
+    targetManagementVersion: typeof upgradePackageTransitionTarget.managementVersion;
+    targetCliName: typeof upgradePackageTransitionTarget.cliName;
+    targetCliRelativePath: typeof upgradePackageTransitionTarget.cliRelativePath;
+    packageTransitionStarted?: true;
+    groupedTargetVerified?: true;
+    targetPackageCommitStarted?: true;
+    targetPackageCommitted?: true;
+    targetStartupInvoked?: true;
+}
+export type TUpgradeTransaction = IUpgradeTransactionV2 | IUpgradeTransactionV3;
+export type TUpgradeControllerAction = 'prepare' | 'finalize';
+export declare const upgradeTransactionIsStalled: (transactionArg: TUpgradeTransaction, nowArg?: number) => boolean;
+declare class UpgradeOwnedDirectory {
+    readonly directory: string;
+    readonly owner: IUpgradeProcessOwner;
+    private readonly releaseOwned;
+    private released;
+    private releaseTask?;
+    constructor(directory: string, owner: IUpgradeProcessOwner, releaseOwned: (directoryArg: string, ownerArg: IUpgradeProcessOwner, shouldReleaseArg?: () => boolean) => Promise<void>);
+    assertOwned(): Promise<void>;
+    release(shouldReleaseArg?: () => boolean): Promise<void>;
+    relinquishAfterTransfer(): void;
+}
+export declare class UpgradeInstallationLock extends UpgradeOwnedDirectory {
+}
+export declare class UpgradeStartLease extends UpgradeOwnedDirectory {
+}
+export declare class UpgradeCoordinator {
+    readonly canonicalGlobalRoot: string;
+    readonly uid: number;
+    readonly baseDirectory: string;
+    readonly upgradeLockDirectory: string;
+    readonly startLeasesDirectory: string;
+    readonly transactionsDirectory: string;
+    readonly ownershipGuardsDirectory: string;
+    private initializationTask?;
+    constructor(canonicalGlobalRoot: string);
+    init(): Promise<void>;
+    private performInitialization;
+    private ownershipGuardDirectory;
+    private acquireOwnershipMutationGuard;
+    private withOwnershipMutationGuard;
+    private reclaimStaleOwnedDirectory;
+    private releaseOwnedDirectory;
+    private inspectTransactionMutationDirectory;
+    private reclaimStaleTransactionMutationDirectory;
+    private inspectOwnedDirectory;
+    private createOwnedDirectory;
+    acquireUpgradeLock(optionsArg: {
+        token: string;
+        cliPath: string;
+        command?: '__serve' | '__upgrade-worker' | 'upgrade' | 'foreground';
+    }): Promise<UpgradeInstallationLock>;
+    transferUpgradeLockToWorker(optionsArg: {
+        lock: UpgradeInstallationLock;
+        token: string;
+        worker: NonNullable<TUpgradeTransaction['worker']>;
+    }): Promise<void>;
+    private readLiveUpgradeOwner;
+    acquireStartLease(optionsArg: {
+        token: string;
+        cliPath: string;
+        command: 'start' | 'foreground' | 'temp-password';
+        upgradeToken?: string;
+    }): Promise<UpgradeStartLease>;
+    waitForStartLeasesToDrain(lockArg: UpgradeInstallationLock): Promise<void>;
+    private tokenFilePath;
+    private transactionFilePath;
+    private transactionMutationDirectory;
+    private withTransactionMutation;
+    createTransaction(optionsArg: {
+        token: string;
+        port: number;
+        sourceVersion: string;
+        controllerWasRunning: boolean;
+        continueSessions: boolean;
+        gracePeriodMs: number;
+    }): Promise<IUpgradeTransactionV2>;
+    createPackageTransitionTransaction(optionsArg: {
+        token: string;
+        port: number;
+        controllerWasRunning: boolean;
+        continueSessions: boolean;
+        gracePeriodMs: number;
+    }): Promise<IUpgradeTransactionV3>;
+    readTransaction(tokenArg: string): Promise<TUpgradeTransaction>;
+    updateTransaction(tokenArg: string, expectedRevisionArg: number, updateArg: (currentArg: TUpgradeTransaction) => TUpgradeTransaction): Promise<TUpgradeTransaction>;
+    mutateTransaction(tokenArg: string, updateArg: (currentArg: TUpgradeTransaction) => TUpgradeTransaction): Promise<TUpgradeTransaction>;
+    private writeTransactionUpdate;
+    registerWorker(tokenArg: string, cliPathArg: string): Promise<TUpgradeTransaction>;
+    recordWorkerLaunch(tokenArg: string, pidArg: number, cliPathArg: string, logFilePathArg: string): Promise<TUpgradeTransaction>;
+    recordController(tokenArg: string, controllerArg: TUpgradeTransaction['controller']): Promise<TUpgradeTransaction>;
+    transactionControllerIsLive(transactionArg: TUpgradeTransaction): Promise<boolean>;
+    transactionWorkerIsLive(transactionArg: TUpgradeTransaction): Promise<boolean>;
+    terminateTransactionWorker(transactionArg: TUpgradeTransaction): Promise<void>;
+    terminateUpgradeWorkerCandidate(worker: NonNullable<TUpgradeTransaction['worker']>): Promise<void>;
+    readSanitizedUpgradeStatus(tokenArg: string): Promise<IControllerUpgradeStatus | undefined>;
+    finishTransaction(tokenArg: string, successArg: boolean, messageArg: string, errorArg?: string): Promise<TUpgradeTransaction>;
+    createLaunchGrant(optionsArg: {
+        token: string;
+        port: number;
+        packageName: string;
+        packageVersion: string;
+        cliPath: string;
+        controller: IUpgradeExpectedController;
+    }): Promise<void>;
+    removeLaunchGrant(tokenArg: string): Promise<void>;
+    consumeLaunchGrant(optionsArg: {
+        token: string;
+        port: number;
+        packageName: string;
+        packageVersion: string;
+        cliPath: string;
+        controller: IUpgradeExpectedController;
+    }): Promise<void>;
+    private actionGrantFilePath;
+    removeControllerActionGrant(actionArg: TUpgradeControllerAction, tokenArg: string): Promise<void>;
+    createControllerActionGrant(optionsArg: {
+        token: string;
+        action: TUpgradeControllerAction;
+        mode?: 'continue' | 'compensate' | 'reopen';
+        packageVersion: string;
+        controller: IUpgradeExpectedController;
+    }): Promise<void>;
+    consumeControllerActionGrant(optionsArg: {
+        token: string;
+        action: TUpgradeControllerAction;
+        mode?: 'continue' | 'compensate' | 'reopen';
+        packageVersion: string;
+        controller: IUpgradeExpectedController;
+    }): Promise<void>;
+    acknowledgeWorker(tokenArg: string): Promise<void>;
+    waitForWorkerAcknowledgement(tokenArg: string, timeoutMsArg?: number): Promise<void>;
+}
+export declare const createUpgradeToken: () => string;
+export declare const serializeUpgradeWorkerPayload: (payloadArg: IUpgradeWorkerPayload) => string;
+export declare const parseUpgradeWorkerPayload: (payloadArg: unknown, tokenArg: unknown) => IUpgradeWorkerPayload;
+export {};