@aopslabs/aops 0.2.0

package/dist/lib/setup-install-guide.js

@@ -0,0 +1,52 @@
+import { createHash } from 'node:crypto';
+import { lstatSync, readFileSync, realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+const MAX_INSTALL_SKILL_BYTES = 64 * 1024;
+function defaultCandidates() {
+    const moduleDirectory = path.dirname(fileURLToPath(import.meta.url));
+    return Object.freeze([
+        path.resolve(moduleDirectory, '..', 'skills', 'aops-install', 'SKILL.md'),
+        path.resolve(moduleDirectory, '..', '..', 'assets', 'skills', 'aops-install', 'SKILL.md'),
+    ]);
+}
+function readCandidate(candidate) {
+    try {
+        const absolutePath = path.resolve(candidate);
+        const stat = lstatSync(absolutePath);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.size < 1 || stat.size > MAX_INSTALL_SKILL_BYTES) {
+            return undefined;
+        }
+        const resolvedPath = realpathSync.native(absolutePath);
+        const content = readFileSync(resolvedPath, 'utf8');
+        if (!content.replaceAll('\r\n', '\n').startsWith('---\nname: aops-install\n') || content.includes('\0'))
+            return undefined;
+        return Object.freeze({
+            name: 'aops-install',
+            path: resolvedPath,
+            sha256: createHash('sha256').update(content, 'utf8').digest('hex'),
+            content,
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function loadAopsInstallSkill(dependencies = {}) {
+    for (const candidate of (dependencies.candidates ?? defaultCandidates)()) {
+        const skill = readCandidate(candidate);
+        if (skill)
+            return skill;
+    }
+    throw new Error('aops_install_skill_missing:reinstall_the_official_aops_cli_package');
+}
+export function buildAopsInstallAgentPrompt() {
+    return `Install AOPS Community on this computer with the installed \`aops\` command.
+
+1. Run \`aops setup guide --json\` and follow its packaged \`aops-install\` skill as the current installation guide.
+2. Run \`aops setup init --yes --json\` first and explain the available PostgreSQL paths and remaining actions briefly.
+3. Ask me only for choices or authority you cannot safely infer. Use the installed command's exact nested \`--help\`; do not guess flags.
+4. Never ask me to paste PostgreSQL URLs or passwords into chat and never place secrets in command arguments. Let me enter private values through AOPS's masked interactive prompts.
+5. Keep the signed official catalog and Gateway assets for all registered agent runtimes unless I explicitly opt out. Do not seed starter/demo user data.
+6. Apply the selected setup path, then verify migrations, server health, Gateway asset bindings, and Cockpit. Report the Cockpit URL and any remaining safe action.`;
+}

package/dist/lib/setup-installer-release.js

@@ -0,0 +1,47 @@
+import { assertCommercialHostAbiCompatible, commercialReleaseVersionOrdinal, CommercialArtifactError, verifyReleaseManifestEnvelope, } from '@aopslabs/artifact-trust-contracts';
+const verifiedReleases = new WeakSet();
+const releaseBindings = new WeakMap();
+function fail(reason) {
+    throw new CommercialArtifactError('setup-installer-release', reason);
+}
+export function verifySetupInstallerReleaseManifest(value, options) {
+    const verified = verifyReleaseManifestEnvelope(value, {
+        trustKeys: options.trustKeys,
+        now: options.now,
+        knownOperationIds: options.knownOperationIds,
+    });
+    const payload = verified.envelope.payload;
+    if (options.expectedPackageName !== undefined &&
+        payload.release.packageName !== options.expectedPackageName)
+        fail('release_package_mismatch');
+    assertCommercialHostAbiCompatible(options.hostProtocolVersion, payload.hostAbi.supportedRange);
+    const release = Object.freeze({});
+    const binding = Object.freeze({
+        schemaVersion: 1,
+        objectType: 'aops-setup-installer-release-binding-v1',
+        manifestDigest: verified.manifestDigest,
+        releaseId: payload.release.releaseId,
+        packageName: payload.release.packageName,
+        version: payload.release.version,
+        versionOrdinal: commercialReleaseVersionOrdinal(payload.release.version),
+        closureDigest: payload.closureDigest,
+        signerKid: verified.signerKid,
+        hostAbi: Object.freeze({
+            protocolVersion: payload.hostAbi.protocolVersion,
+            supportedRange: payload.hostAbi.supportedRange,
+            hostProtocolVersion: options.hostProtocolVersion,
+            decision: 'compatible',
+        }),
+    });
+    verifiedReleases.add(release);
+    releaseBindings.set(release, binding);
+    return release;
+}
+export function setupInstallerReleaseBinding(value) {
+    if (!verifiedReleases.has(value))
+        fail('unverified_release_identity');
+    const binding = releaseBindings.get(value);
+    if (!binding)
+        fail('unverified_release_identity');
+    return binding;
+}

package/dist/lib/setup-local-postgres.js

@@ -0,0 +1,329 @@
+import { spawnSync } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import net from 'node:net';
+import { userInfo } from 'node:os';
+import { Client } from 'pg';
+const POSTGRES_DOWNLOADS = 'https://www.postgresql.org/download/';
+const POSTGRES_WINDOWS = 'https://www.postgresql.org/download/windows/';
+const POSTGRES_MACOS = 'https://www.postgresql.org/download/macosx/';
+const POSTGRES_LINUX = 'https://www.postgresql.org/download/linux/';
+const IDENTIFIER = /^[a-z][a-z0-9_]{0,62}$/;
+const MINIMUM_POSTGRES_MAJOR = 17;
+function normalizeLoopbackHost(value) {
+    const host = typeof value === 'string' ? value.trim().toLowerCase() : '127.0.0.1';
+    const normalized = host.replace(/^\[|\]$/g, '');
+    if (normalized === 'localhost' || normalized === '::1')
+        return normalized;
+    const match = /^127\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(normalized);
+    if (match?.slice(1).every((octet) => Number(octet) <= 255))
+        return normalized;
+    throw new Error('setup_local_postgres_host_must_be_loopback');
+}
+function normalizePort(value) {
+    const port = Number(value ?? 5432);
+    if (!Number.isSafeInteger(port) || port < 1 || port > 65_535) {
+        throw new Error('setup_local_postgres_port_invalid');
+    }
+    return port;
+}
+function normalizeIdentifier(value, fallback, label) {
+    const normalized = (typeof value === 'string' ? value : fallback).trim().toLowerCase();
+    if (!IDENTIFIER.test(normalized))
+        throw new Error(`setup_local_postgres_${label}_invalid`);
+    return normalized;
+}
+function commandAvailable(command) {
+    const locator = process.platform === 'win32' ? 'where.exe' : 'which';
+    return spawnSync(locator, [command], {
+        encoding: 'utf8',
+        windowsHide: true,
+        timeout: 1_000,
+        stdio: 'ignore',
+    }).status === 0;
+}
+function platformName(value) {
+    if (value === 'win32')
+        return 'windows';
+    if (value === 'darwin')
+        return 'macos';
+    return 'linux';
+}
+export function defaultLocalPostgresAdminUser(platform = process.platform) {
+    if (platform !== 'darwin')
+        return 'postgres';
+    try {
+        return normalizeIdentifier(userInfo().username, 'postgres', 'admin_user');
+    }
+    catch {
+        return 'postgres';
+    }
+}
+export function defaultLocalPostgresDatabase(instance) {
+    const normalized = String(instance ?? 'default').trim().toLowerCase().replace(/[^a-z0-9_]+/g, '_');
+    return normalizeIdentifier(normalized === 'default' ? 'aops' : `aops_${normalized}`, 'aops', 'database');
+}
+export function localPostgresInstallGuidance(platform = process.platform, hasCommand = commandAvailable) {
+    const resolved = platformName(platform);
+    if (resolved === 'windows') {
+        return Object.freeze({
+            platform: resolved,
+            summary: 'Install PostgreSQL 17 or newer with the official Windows installer, start its service, then retry path 3.',
+            commands: Object.freeze([]),
+            url: POSTGRES_WINDOWS,
+        });
+    }
+    if (resolved === 'macos') {
+        return Object.freeze({
+            platform: resolved,
+            summary: hasCommand('brew')
+                ? 'Install and start PostgreSQL 17 with Homebrew, then retry path 3.'
+                : 'Install PostgreSQL 17 or newer from an official macOS option, start it, then retry path 3.',
+            commands: Object.freeze(hasCommand('brew')
+                ? ['brew install postgresql@17', 'brew services start postgresql@17']
+                : []),
+            url: POSTGRES_MACOS,
+        });
+    }
+    if (hasCommand('apt-get')) {
+        return Object.freeze({
+            platform: resolved,
+            summary: 'Install PostgreSQL with the distribution package manager, start its service, then retry path 3.',
+            commands: Object.freeze([
+                'sudo apt-get update',
+                'sudo apt-get install postgresql',
+                'sudo systemctl enable --now postgresql',
+            ]),
+            url: POSTGRES_LINUX,
+        });
+    }
+    if (hasCommand('dnf')) {
+        return Object.freeze({
+            platform: resolved,
+            summary: 'Install, initialize, and start PostgreSQL with the distribution package manager, then retry path 3.',
+            commands: Object.freeze([
+                'sudo dnf install postgresql-server',
+                'sudo postgresql-setup --initdb',
+                'sudo systemctl enable --now postgresql.service',
+            ]),
+            url: POSTGRES_LINUX,
+        });
+    }
+    return Object.freeze({
+        platform: resolved,
+        summary: 'Install PostgreSQL 17 or newer with the operating system package manager, start it, then retry path 3.',
+        commands: Object.freeze([]),
+        url: POSTGRES_DOWNLOADS,
+    });
+}
+function localPostgresStartGuidance(platform, hasCommand) {
+    const resolved = platformName(platform);
+    if (resolved === 'windows') {
+        return Object.freeze({
+            platform: resolved,
+            summary: 'PostgreSQL tools were found. Start the exact PostgreSQL service, confirm its loopback port, then retry path 3.',
+            commands: Object.freeze([
+                "Get-Service -Name 'postgresql*'",
+                'Start-Service -Name <exact-service-name>',
+            ]),
+            url: POSTGRES_WINDOWS,
+        });
+    }
+    if (resolved === 'macos' && hasCommand('brew')) {
+        return Object.freeze({
+            platform: resolved,
+            summary: 'PostgreSQL tools were found. Start the Homebrew service or confirm the configured loopback port, then retry path 3.',
+            commands: Object.freeze(['brew services start postgresql@17']),
+            url: POSTGRES_MACOS,
+        });
+    }
+    return Object.freeze({
+        platform: resolved,
+        summary: 'PostgreSQL tools were found. Start its service or confirm the configured loopback port, then retry path 3.',
+        commands: Object.freeze(['sudo systemctl start postgresql']),
+        url: resolved === 'macos' ? POSTGRES_MACOS : POSTGRES_LINUX,
+    });
+}
+async function probePort(host, port, timeoutMs) {
+    return new Promise((resolve) => {
+        const socket = net.createConnection({ host, port });
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.destroy();
+            resolve(result);
+        };
+        socket.setTimeout(timeoutMs);
+        socket.once('connect', () => finish(true));
+        socket.once('timeout', () => finish(false));
+        socket.once('error', () => finish(false));
+    });
+}
+function readPsqlVersion() {
+    const result = spawnSync('psql', ['--version'], {
+        encoding: 'utf8',
+        windowsHide: true,
+        timeout: 1_000,
+        stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    if (result.status !== 0)
+        return null;
+    const match = /psql\s+\(PostgreSQL\)\s+([^\s]+)/i.exec(String(result.stdout));
+    return match?.[1] ?? null;
+}
+export async function inspectLocalPostgres(options = {}) {
+    const host = normalizeLoopbackHost(options.host);
+    const port = normalizePort(options.port);
+    const timeoutMs = Math.min(Math.max(Number(options.timeoutMs ?? 750), 100), 5_000);
+    const hasCommand = options.commandAvailable ?? commandAvailable;
+    const psqlAvailable = hasCommand('psql');
+    const reachable = await (options.portProbe ?? probePort)(host, port, timeoutMs);
+    const guidance = !reachable && psqlAvailable
+        ? localPostgresStartGuidance(options.platform ?? process.platform, hasCommand)
+        : localPostgresInstallGuidance(options.platform, hasCommand);
+    return Object.freeze({
+        schemaVersion: 1,
+        status: reachable ? 'ready' : psqlAvailable ? 'installed-not-running' : 'not-detected',
+        host,
+        port,
+        reachable,
+        psqlAvailable,
+        psqlVersion: psqlAvailable && !options.commandAvailable ? readPsqlVersion() : null,
+        guidance,
+    });
+}
+function quoteIdentifier(value) {
+    return `"${value.replaceAll('"', '""')}"`;
+}
+function quoteLiteral(value) {
+    return `'${value.replaceAll("'", "''")}'`;
+}
+function generatedPassword() {
+    return randomBytes(32).toString('base64url');
+}
+function safePgError(error) {
+    const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+    if (code === '28P01')
+        return new Error('setup_local_postgres_admin_auth_failed');
+    if (code === 'ECONNREFUSED' || code === 'ETIMEDOUT')
+        return new Error('setup_local_postgres_unreachable');
+    if (code === '42501')
+        return new Error('setup_local_postgres_admin_privileges_required');
+    return new Error('setup_local_postgres_provision_failed');
+}
+export async function provisionLocalPostgres(options, dependencies = {}) {
+    const host = normalizeLoopbackHost(options.host);
+    const port = normalizePort(options.port);
+    const adminUser = normalizeIdentifier(options.adminUser, defaultLocalPostgresAdminUser(), 'admin_user');
+    const database = normalizeIdentifier(options.database, 'aops', 'database');
+    const appUser = normalizeIdentifier(options.appUser, database, 'app_user');
+    if (adminUser === appUser)
+        throw new Error('setup_local_postgres_admin_and_app_user_must_differ');
+    const connectTimeoutMillis = Math.min(Math.max(Number(options.connectTimeoutMs ?? 5_000), 500), 30_000);
+    const createClient = dependencies.createClient
+        ?? ((config) => new Client(config));
+    const admin = createClient({
+        host,
+        port,
+        user: adminUser,
+        password: options.adminPassword || undefined,
+        database: 'postgres',
+        ssl: false,
+        connectionTimeoutMillis: connectTimeoutMillis,
+    });
+    let createdRole = false;
+    let createdDatabase = false;
+    try {
+        await admin.connect();
+        const version = await admin.query('SHOW server_version_num');
+        const versionNumber = Number(version.rows[0]?.server_version_num);
+        const serverMajor = Math.floor(versionNumber / 10_000);
+        if (!Number.isSafeInteger(serverMajor) || serverMajor < MINIMUM_POSTGRES_MAJOR) {
+            throw new Error(`setup_local_postgres_version_unsupported:requires_${MINIMUM_POSTGRES_MAJOR}_or_newer`);
+        }
+        const privilege = await admin.query('SELECT rolsuper, rolcreatedb, rolcreaterole FROM pg_roles WHERE rolname = current_user');
+        const role = privilege.rows[0];
+        if (role?.rolsuper !== true && (role?.rolcreatedb !== true || role?.rolcreaterole !== true)) {
+            throw new Error('setup_local_postgres_admin_privileges_required');
+        }
+        const existing = await admin.query('SELECT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = $1) AS role_exists, EXISTS (SELECT 1 FROM pg_database WHERE datname = $2) AS database_exists', [appUser, database]);
+        if (existing.rows[0]?.role_exists === true || existing.rows[0]?.database_exists === true) {
+            throw new Error('setup_local_postgres_target_already_exists:choose_new_database_and_app_user');
+        }
+        const appPassword = (dependencies.createPassword ?? generatedPassword)();
+        if (appPassword.length < 32 || /\0|\r|\n/.test(appPassword)) {
+            throw new Error('setup_local_postgres_generated_password_invalid');
+        }
+        await admin.query(`CREATE ROLE ${quoteIdentifier(appUser)} LOGIN PASSWORD ${quoteLiteral(appPassword)}`);
+        createdRole = true;
+        try {
+            await admin.query(`CREATE DATABASE ${quoteIdentifier(database)} OWNER ${quoteIdentifier(appUser)} TEMPLATE template0 ENCODING 'UTF8'`);
+            createdDatabase = true;
+        }
+        catch (error) {
+            try {
+                await admin.query(`DROP ROLE ${quoteIdentifier(appUser)}`);
+            }
+            catch { }
+            createdRole = false;
+            throw error;
+        }
+        const connection = new URL('postgresql://localhost/');
+        connection.hostname = host === '::1' ? '[::1]' : host;
+        connection.port = String(port);
+        connection.username = appUser;
+        connection.password = appPassword;
+        connection.pathname = `/${database}`;
+        const app = createClient({
+            connectionString: connection.toString(),
+            ssl: false,
+            connectionTimeoutMillis: connectTimeoutMillis,
+        });
+        try {
+            await app.connect();
+            await app.query('SELECT current_database()');
+        }
+        finally {
+            await app.end().catch(() => undefined);
+        }
+        const result = {
+            schemaVersion: 1,
+            status: 'provisioned',
+            host,
+            port,
+            database,
+            appUser,
+            serverMajor,
+        };
+        Object.defineProperty(result, 'connectionUrl', {
+            value: connection.toString(),
+            enumerable: false,
+            configurable: false,
+            writable: false,
+        });
+        return Object.freeze(result);
+    }
+    catch (error) {
+        if (createdDatabase) {
+            try {
+                await admin.query(`DROP DATABASE ${quoteIdentifier(database)} WITH (FORCE)`);
+                createdDatabase = false;
+            }
+            catch { }
+        }
+        if (createdRole && !createdDatabase) {
+            try {
+                await admin.query(`DROP ROLE ${quoteIdentifier(appUser)}`);
+                createdRole = false;
+            }
+            catch { }
+        }
+        if (error instanceof Error && error.message.startsWith('setup_local_postgres_'))
+            throw error;
+        throw safePgError(error);
+    }
+    finally {
+        await admin.end().catch(() => undefined);
+    }
+}

package/dist/lib/setup-official-catalog-bridge.js

@@ -0,0 +1,148 @@
+import { lstatSync, realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { verifyAndLoadCommunityCatalogReleaseInputs } from './agent-assets/release-input.js';
+import { inspectCommunityInstall } from './community-lifecycle.js';
+import { inspectCommunityNativeInstall } from './community-native-lifecycle.js';
+import { resolveCommunityRepo } from './community-repo-discovery.js';
+import { createHostedOfficialCatalogAdapterV1 } from './official-catalog-gateway.js';
+import { buildOfficialCatalogPackageImports, OFFICIAL_CATALOG_NO_ACTIVATION_EFFECTS_V1, OFFICIAL_CATALOG_SCOPE_V1, OFFICIAL_CATALOG_TOOL_IDS_V1, reconcileOfficialCatalog, } from './official-catalog.js';
+export const SETUP_OFFICIAL_CATALOG_CONTRACT_V1 = Object.freeze({
+    schemaVersion: 1,
+    scope: OFFICIAL_CATALOG_SCOPE_V1,
+    defaultMode: 'import-inert',
+    optOutFlag: '--no-catalog',
+    releaseSource: 'verified-community-release-only',
+    activation: 'none',
+    reconcileCommand: 'aops-cli setup catalog reconcile --from-release <path> --apply --json',
+    rollbackCommand: 'aops-cli setup catalog rollback --receipt <id> --apply --confirm --json',
+    requiredTools: OFFICIAL_CATALOG_TOOL_IDS_V1,
+});
+function isOfficialCatalogAdapterUnavailable(error) {
+    return typeof error === 'object' && error !== null &&
+        error.code === 'catalog_adapter_unavailable';
+}
+export async function retryOfficialCatalogAdapterReady(operation, timeoutMs = 120_000, dependencies = {}) {
+    const now = dependencies.now ?? Date.now;
+    const sleep = dependencies.sleep ?? ((milliseconds) => new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
+    }));
+    const deadline = now() + Math.min(Math.max(timeoutMs, 1_000), 120_000);
+    let attempt = 0;
+    for (;;) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            if (!isOfficialCatalogAdapterUnavailable(error))
+                throw error;
+            const remaining = deadline - now();
+            if (remaining <= 0)
+                throw error;
+            const delayMs = Math.min(250 * (2 ** Math.min(attempt, 3)), 2_000, remaining);
+            attempt += 1;
+            await sleep(delayMs);
+        }
+    }
+}
+function localSignedReleaseRoot(candidate) {
+    if (!candidate)
+        return undefined;
+    const releaseRoot = path.resolve(candidate);
+    try {
+        const root = lstatSync(releaseRoot);
+        if (!root.isDirectory() || root.isSymbolicLink())
+            return undefined;
+        for (const name of ['agent-assets-release.json', 'agent-assets-release.sigstore.json']) {
+            const entry = lstatSync(path.join(releaseRoot, name));
+            if (!entry.isFile() || entry.isSymbolicLink())
+                return undefined;
+        }
+        return realpathSync.native(releaseRoot);
+    }
+    catch {
+        return undefined;
+    }
+}
+function defaultBundledCandidates() {
+    const moduleDirectory = path.dirname(fileURLToPath(import.meta.url));
+    return Object.freeze([
+        path.resolve(moduleDirectory, '..', 'agent-assets-release'),
+        path.resolve(moduleDirectory, '..', '..', 'agent-assets-release'),
+    ]);
+}
+export async function resolveSetupOfficialCatalogReleaseV1(options = {}, dependencies = {}) {
+    const sourceRoot = localSignedReleaseRoot(options.sourceRoot ? path.join(path.resolve(options.sourceRoot), 'release') : undefined);
+    if (sourceRoot)
+        return Object.freeze({ fromRelease: sourceRoot, source: 'source-root' });
+    for (const candidate of (dependencies.bundledCandidates ?? defaultBundledCandidates)()) {
+        const bundledRoot = localSignedReleaseRoot(candidate);
+        if (bundledRoot)
+            return Object.freeze({ fromRelease: bundledRoot, source: 'bundled-npm' });
+    }
+    const inspectNative = dependencies.inspectNative ?? inspectCommunityNativeInstall;
+    const native = inspectNative({ instanceName: options.instance, dataRoot: options.dataRoot });
+    const nativeRoot = localSignedReleaseRoot(native.status === 'installed' ? path.join(native.state.source.root, 'release') : undefined);
+    if (nativeRoot)
+        return Object.freeze({ fromRelease: nativeRoot, source: 'installed-native' });
+    const inspectOci = dependencies.inspectOci ?? inspectCommunityInstall;
+    const oci = inspectOci({ instanceName: options.instance, dataRoot: options.dataRoot });
+    const ociRoot = localSignedReleaseRoot(oci.status === 'installed' ? path.dirname(oci.state.activeRelease.manifestPath) : undefined);
+    if (ociRoot)
+        return Object.freeze({ fromRelease: ociRoot, source: 'installed-oci' });
+    try {
+        const repo = (dependencies.resolveRepo ?? resolveCommunityRepo)({ cwd: (dependencies.cwd ?? process.cwd)() });
+        const cwdRoot = localSignedReleaseRoot(repo.releaseDir);
+        if (cwdRoot)
+            return Object.freeze({ fromRelease: cwdRoot, source: 'cwd-community-repo' });
+    }
+    catch {
+    }
+    throw new Error('setup_init_catalog_verified_release_unavailable:reinstall_the_official_aops_cli_or_run_from_a_signed_community_release_or_use_--catalog-release_<path>_or_--no-catalog');
+}
+export function createSetupOfficialCatalogProviderV1(dependencies = {}) {
+    const loadRelease = dependencies.loadRelease ?? verifyAndLoadCommunityCatalogReleaseInputs;
+    const createAdapter = dependencies.createAdapter ?? createHostedOfficialCatalogAdapterV1;
+    return Object.freeze({
+        async resolveRelease(options) {
+            return resolveSetupOfficialCatalogReleaseV1(options, dependencies);
+        },
+        async reconcile(options) {
+            const inputs = await loadRelease({
+                releaseRoot: options.fromRelease,
+                verificationMode: 'offline',
+            });
+            const packages = buildOfficialCatalogPackageImports(inputs);
+            const adapter = await createAdapter({
+                apiBaseUrl: options.apiBaseUrl,
+                timeoutMs: options.timeoutMs,
+            });
+            const result = await retryOfficialCatalogAdapterReady(() => reconcileOfficialCatalog({
+                adapter,
+                packages,
+                mode: 'apply',
+                idempotencyKey: options.idempotencyKey,
+            }), options.timeoutMs);
+            if (result.kind === 'aops-official-catalog-reconcile-plan-v1') {
+                return Object.freeze({
+                    state: 'current',
+                    scopeSlug: OFFICIAL_CATALOG_SCOPE_V1.slug,
+                    releaseSetSha256: result.releaseSetSha256,
+                    mutation: 'not-required',
+                    historyDeleteCount: 0,
+                    activationEffects: OFFICIAL_CATALOG_NO_ACTIVATION_EFFECTS_V1,
+                });
+            }
+            return Object.freeze({
+                state: 'current',
+                scopeSlug: OFFICIAL_CATALOG_SCOPE_V1.slug,
+                releaseSetSha256: result.releaseSetSha256,
+                mutation: 'applied',
+                receiptId: result.receiptId,
+                catalogRevision: result.catalogRevision,
+                historyDeleteCount: 0,
+                activationEffects: OFFICIAL_CATALOG_NO_ACTIVATION_EFFECTS_V1,
+            });
+        },
+    });
+}