sneakoscope 7.1.0 → 7.3.0

package/dist/scripts/release-dag-full-coverage-check.js

@@ -1,98 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-import { releaseGateContractSnapshot } from '../core/release/release-gate-contract.js';
-const packageJson = readPackageJson(path.join(root, 'package.json'));
-const releaseManifest = readReleaseGateManifest(path.join(root, 'release-gates.v2.json'), 'sks.release-gates.v2');
-const harnessManifest = readReleaseGateManifest(path.join(root, 'infra-harness-gates.json'), 'sks.infra-harness-gates.v1');
-const releasePreset = releaseManifest.gates.filter((gate) => gate.preset.includes('release'));
-const harnessPreset = harnessManifest.gates.filter((gate) => gate.preset.includes('harness'));
-const releaseIds = new Set(releasePreset.map((gate) => gate.id));
-const harnessIds = new Set(harnessPreset.map((gate) => gate.id));
-const releaseContract = releaseGateContractSnapshot();
-const requiredReleasePresetIds = releaseContract.ids;
-const requiredHarnessPresetIds = [
-    'zellij:layout-valid',
-    'zellij:compact-slot-renderer',
-    'zellij:slot-telemetry',
-    'zellij:slot-pane-telemetry-renderer',
-    'zellij:first-slot-down-stack',
-    'zellij:right-column-geometry-proof'
-];
-const missingRequiredReleasePreset = requiredReleasePresetIds.filter((id) => !releaseIds.has(id));
-const unexpectedReleasePreset = [...releaseIds].filter((id) => !requiredReleasePresetIds.includes(id)).sort();
-const missingRequiredHarnessPreset = requiredHarnessPresetIds.filter((id) => !harnessIds.has(id));
-const duplicateAcrossManifests = [...releaseIds].filter((id) => harnessIds.has(id));
-const releaseZellij = [...releaseIds].filter((id) => id.startsWith('zellij:'));
-const harnessNonZellij = [...harnessIds].filter((id) => !id.startsWith('zellij:'));
-const npmRunCommands = [...releasePreset, ...harnessPreset].filter((gate) => /\bnpm\s+run\b/.test(gate.command)).map((gate) => gate.id);
-const schemaComplete = [...releaseManifest.gates, ...harnessManifest.gates].every(isReleaseGate);
-const report = {
-    schema: 'sks.release-dag-full-coverage-check.v2',
-    ok: schemaComplete
-        && releasePreset.length <= 200
-        && missingRequiredReleasePreset.length === 0
-        && unexpectedReleasePreset.length === 0
-        && missingRequiredHarnessPreset.length === 0
-        && duplicateAcrossManifests.length === 0
-        && releaseZellij.length === 0
-        && harnessNonZellij.length === 0
-        && npmRunCommands.length === 0,
-    release_gate_count: releasePreset.length,
-    harness_gate_count: harnessPreset.length,
-    required_release_preset_ids: requiredReleasePresetIds,
-    missing_required_release_preset: missingRequiredReleasePreset,
-    unexpected_release_preset: unexpectedReleasePreset,
-    release_gate_contract: releaseContract,
-    required_harness_preset_ids: requiredHarnessPresetIds,
-    missing_required_harness_preset: missingRequiredHarnessPreset,
-    duplicate_across_manifests: duplicateAcrossManifests,
-    release_zellij: releaseZellij,
-    harness_non_zellij: harnessNonZellij,
-    npm_run_commands: npmRunCommands,
-    schema_complete: schemaComplete,
-    package_script_count: Object.keys(packageJson.scripts || {}).length
-};
-assertGate(report.ok, 'release/harness gate manifests must satisfy consolidated v2 coverage policy', report);
-emitGate('release:dag-full-coverage', report);
-function readPackageJson(file) {
-    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-    assertGate(isRecord(parsed), 'package.json must be an object', { file });
-    const record = parsed;
-    const scripts = isRecord(record.scripts) ? Object.fromEntries(Object.entries(record.scripts).filter((entry) => typeof entry[1] === 'string')) : {};
-    return { scripts };
-}
-function readReleaseGateManifest(file, expectedSchema) {
-    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-    assertGate(isRecord(parsed), 'gate manifest must be an object', { file });
-    assertGate(parsed.schema === expectedSchema, 'gate manifest schema mismatch', { file, schema: parsed.schema, expected_schema: expectedSchema });
-    const gatesValue = parsed.gates;
-    assertGate(Array.isArray(gatesValue), 'gate manifest missing gates array', { file });
-    const gatesRaw = Array.isArray(gatesValue) ? gatesValue : [];
-    const gates = gatesRaw.filter(isReleaseGate);
-    assertGate(gates.length === gatesRaw.length, 'gate manifest contains invalid gates', {
-        file,
-        invalid_count: gatesRaw.length - gates.length
-    });
-    return { schema: expectedSchema, gates };
-}
-function isReleaseGate(value) {
-    if (!isRecord(value))
-        return false;
-    return typeof value.id === 'string'
-        && typeof value.command === 'string'
-        && typeof value.side_effect === 'string'
-        && typeof value.timeout_ms === 'number'
-        && normalizeStringList(value.deps).length === (Array.isArray(value.deps) ? value.deps.length : 0)
-        && normalizeStringList(value.resource).length === (Array.isArray(value.resource) ? value.resource.length : 0)
-        && normalizeStringList(value.preset).length === (Array.isArray(value.preset) ? value.preset.length : 0)
-        && value.cache !== undefined
-        && value.isolation !== undefined;
-}
-function normalizeStringList(value) {
-    return Array.isArray(value) ? value.filter((item) => typeof item === 'string').map((item) => item.trim()).filter(Boolean) : [];
-}
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}

package/dist/scripts/release-dist-freshness-check.js

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-import { ensureDistFresh } from './lib/ensure-dist-fresh.js';
-const report = ensureDistFresh({ rebuild: process.env.SKS_RELEASE_DIST_FRESHNESS_NO_REBUILD !== '1' });
-console.log(JSON.stringify(report, null, 2));
-if (!report.ok)
-    process.exitCode = 1;

package/dist/scripts/release-file-ownership-check.js

@@ -1,35 +0,0 @@
-#!/usr/bin/env node
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { inspectReleaseFileOwnership, readReleaseFileOwnershipManifest } from '../core/release/file-ownership.js';
-import { writeReleaseJson } from '../core/release/release-pack-receipt.js';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const manifestFile = path.resolve(root, required('--manifest'));
-const base = required('--base');
-const head = required('--head');
-const manifest = readReleaseFileOwnershipManifest(manifestFile);
-const report = inspectReleaseFileOwnership({
-    root,
-    manifest,
-    base,
-    head,
-    ...(option('--workstream') ? { workstream: option('--workstream') } : {})
-});
-const owner = report.workstream || 'unresolved';
-const output = path.resolve(root, option('--output') || `.sneakoscope/release/6.3.0/ownership-reports/${owner}.json`);
-writeReleaseJson(output, report);
-console.log(JSON.stringify({ ...report, report_path: path.relative(root, output).split(path.sep).join('/') }, null, 2));
-if (!report.ok)
-    process.exitCode = 1;
-function required(name) {
-    const value = option(name);
-    if (!value) {
-        console.error(`Release file ownership check failed: ${name} is required`);
-        process.exit(2);
-    }
-    return value;
-}
-function option(name) {
-    const index = process.argv.indexOf(name);
-    return index >= 0 ? String(process.argv[index + 1] || '').trim() : '';
-}

package/dist/scripts/release-gate-script-parity-check.js

@@ -1,148 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { assertGate, emitGate, readJson, root } from './sks-1-18-gate-lib.js';
-import { writeJsonAtomic } from '../core/fsx.js';
-export const REQUIRED_3110_RELEASE_IDS = [
-    'core-skill:manifest',
-    'core-skill:immutable-sync',
-    'core-skill:no-drift',
-    'core-skill:integrity-blackbox',
-    'skill:name-canonicalizer',
-    'skill:registry-ledger',
-    'skill:dedupe',
-    'skill:sync-atomic',
-    'skill:dedupe-blackbox',
-    'native-capability:repair-matrix',
-    'native-capability:repair',
-    'native-capability:postcheck',
-    'native:image-generation-repair',
-    'native:computer-use-repair',
-    'native:chrome-web-review-repair',
-    'native:app-screenshot-repair',
-    'doctor:native-capability-repair',
-    'doctor:native-repair-output',
-    'doctor:native-capability-repair-blackbox',
-    'secret:preservation',
-    'config:managed-merge',
-    'secret:preservation-guard',
-    'secret:supabase-preservation-blackbox',
-    'update:preserves-supabase-keys',
-    'update:secret-preservation-guard',
-    'update:secret-migration-journal',
-    'safety:mutation-callsite-coverage',
-    'release:gate-script-parity',
-    'release:wiring-3110-blackbox',
-    'sks:3112-all-feature-regression'
-];
-if (isMain()) {
-    main().catch((err) => {
-        console.error(err instanceof Error ? err.stack || err.message : String(err));
-        process.exit(1);
-    });
-}
-export async function main() {
-    const report = buildReleaseGateScriptParityReport();
-    const out = path.join(root, '.sneakoscope', 'reports', 'release-gate-script-parity.json');
-    await writeJsonAtomic(out, report);
-    assertGate(report.ok, 'release gate script parity failed', report);
-    emitGate('release:gate-script-parity', {
-        release_gate_count: report.release_gate_count,
-        checked_required_ids: report.checked_required_ids
-    });
-}
-export function buildReleaseGateScriptParityReport() {
-    const pkg = readJson('package.json');
-    const manifest = readJson('release-gates.v2.json');
-    const scripts = pkg.scripts || {};
-    const gates = Array.isArray(manifest.gates) ? manifest.gates : [];
-    const gateById = new Map(gates.map((gate) => [gate.id, gate]));
-    const releaseGateIds = gates.filter((gate) => gate.preset?.includes('release')).map((gate) => gate.id);
-    const requiredReleaseIds = releaseGateIds;
-    const requiredRealCheckIds = gates.filter((gate) => gate.preset?.includes('real-check')).map((gate) => gate.id);
-    const requiredAllIds = [...new Set([...requiredReleaseIds, ...requiredRealCheckIds])];
-    const requiredEntryScripts = [
-        'build',
-        'build:incremental',
-        'typecheck',
-        'release:check',
-        'release:metadata',
-        'release:check:affected',
-        'release:check:fast',
-        'release:check:confidence',
-        'release:check:full',
-        'prepublishOnly',
-        'release:file-ownership',
-        'release:macos-menubar-proof',
-        'release:main-push-guard',
-        'release:main-push-receipt',
-        'release:pack-receipt',
-        'runtime:installed-smoke',
-        'gates:run',
-        'policy:gate-audit'
-    ];
-    const missingEntryScripts = requiredEntryScripts.filter((id) => !scripts[id]).sort();
-    const missingGates = requiredAllIds.filter((id) => !gateById.has(id)).sort();
-    const missingReleasePreset = requiredReleaseIds.filter((id) => !gateById.get(id)?.preset?.includes('release')).sort();
-    const missingRealCheckPreset = requiredRealCheckIds.filter((id) => !gateById.get(id)?.preset?.includes('real-check')).sort();
-    const wrongCommands = requiredAllIds
-        .map((id) => {
-        const actual = gateById.get(id)?.command || '';
-        return { id, actual, reason: directManifestCommandIssue(actual) };
-    })
-        .filter((row) => row.reason);
-    const missingSourceTargets = requiredAllIds
-        .map((id) => ({ id, source: sourceTargetForScript(gateById.get(id)?.command) }))
-        .filter((row) => row.source && !fs.existsSync(path.join(root, row.source)))
-        .map((row) => row.source)
-        .sort();
-    const missingDistTargets = requiredAllIds
-        .map((id) => ({ id, dist: distTargetForScript(gateById.get(id)?.command) }))
-        .filter((row) => row.dist && fs.existsSync(path.join(root, 'dist')) && !fs.existsSync(path.join(root, row.dist)))
-        .map((row) => row.dist)
-        .sort();
-    return {
-        schema: 'sks.release-gate-script-parity.v1',
-        ok: missingEntryScripts.length === 0 && missingGates.length === 0 && missingReleasePreset.length === 0 && missingRealCheckPreset.length === 0 && wrongCommands.length === 0 && missingSourceTargets.length === 0 && missingDistTargets.length === 0,
-        release_gate_count: releaseGateIds.length,
-        package_script_count: Object.keys(scripts).length,
-        checked_required_ids: requiredAllIds.length,
-        missing_entry_scripts: missingEntryScripts,
-        missing_gates: missingGates,
-        missing_release_preset: missingReleasePreset,
-        missing_real_check_preset: missingRealCheckPreset,
-        wrong_commands: wrongCommands,
-        missing_source_targets: missingSourceTargets,
-        missing_dist_targets: missingDistTargets
-    };
-}
-function directManifestCommandIssue(command) {
-    const text = String(command || '');
-    if (!text)
-        return 'missing_command';
-    if (/\bnpm\s+run\b/.test(text))
-        return 'gate_command_must_not_require_package_script_alias';
-    const segments = text.split(/\s+(?:&&|\|\|)\s+/).map((part) => part.trim()).filter(Boolean);
-    const invalid = segments.find((part) => !(/^node\s+\.\/dist\/scripts\/[^\s]+\.js\b/.test(part)
-        || /^node\s+\.\/dist\/bin\/sks\.js\b/.test(part)
-        || /^node\s+\.\/node_modules\/typescript\/bin\/tsc\s+-p\s+tsconfig\.json\s+--noEmit$/.test(part)
-        || /^node\s+--test\b/.test(part)));
-    if (invalid) {
-        return 'gate_command_must_execute_dist_script_or_typecheck_directly';
-    }
-    return '';
-}
-function distTargetForScript(script) {
-    const match = String(script || '').match(/node\s+\.\/dist\/scripts\/([^\s]+\.js)/);
-    return match ? `dist/scripts/${match[1]}` : null;
-}
-function sourceTargetForScript(script) {
-    const dist = distTargetForScript(script);
-    if (!dist)
-        return null;
-    return dist.replace(/^dist\/scripts\//, 'src/scripts/').replace(/\.js$/, '.ts');
-}
-function isMain() {
-    return path.resolve(process.argv[1] || '') === fileURLToPath(import.meta.url);
-}

package/dist/scripts/release-macos-menubar-proof.js

@@ -1,167 +0,0 @@
-#!/usr/bin/env node
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { MACOS_MENUBAR_PROOF_SCHEMA, validateMacosInstallReportOutcome, writeMacosMenubarProof } from '../core/release/macos-menubar-proof.js';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-const installReportFile = path.resolve(root, required('--install-report'));
-const installReportBytes = fs.readFileSync(installReportFile);
-const installReport = JSON.parse(installReportBytes.toString('utf8'));
-const appPath = String(installReport?.result?.app_path || installReport?.app_path || '');
-const resources = path.join(appPath, 'Contents', 'Resources');
-const plist = path.join(appPath, 'Contents', 'Info.plist');
-const executable = String(installReport?.result?.executable_path || '');
-const installChecks = booleanRecord(installReport?.checks);
-const buildStamp = installReport?.result?.build_stamp || installReport?.build_stamp || {};
-const sourceRoot = firstExisting([
-    path.join(path.dirname(appPath), 'Sources'),
-    path.join(root, 'dist', 'native', 'sks-menubar', 'Sources'),
-    path.join(root, 'native', 'sks-menubar', 'Sources')
-]);
-const swiftFiles = sourceRoot ? fs.readdirSync(sourceRoot).filter((name) => name.endsWith('.swift')).map((name) => path.join(sourceRoot, name)) : [];
-const swiftParse = process.platform === 'darwin' && swiftFiles.length > 0
-    ? run('swiftc', ['-parse', ...swiftFiles]).status === 0
-    : false;
-const resourceNames = [
-    'AppIcon.icns',
-    'SKSStatusTemplate.pdf',
-    'SKSStatusUpdateTemplate.pdf',
-    'SKSStatusWarningTemplate.pdf',
-    'SKSStatusAttentionTemplate.pdf',
-    'Localizable.strings'
-];
-const installedResourceNames = fs.existsSync(resources) ? fs.readdirSync(resources).sort() : [];
-const resourcesOk = Boolean(appPath)
-    && JSON.stringify(installedResourceNames) === JSON.stringify([...resourceNames].sort());
-const plistIcon = process.platform === 'darwin' && fs.existsSync(plist)
-    ? String(run('/usr/libexec/PlistBuddy', ['-c', 'Print :CFBundleIconFile', plist]).stdout || '').trim() === 'AppIcon'
-    : false;
-const codesign = process.platform === 'darwin' && Boolean(appPath)
-    ? run('codesign', ['--verify', '--deep', '--strict', appPath]).status === 0
-    : false;
-const codesignDetail = process.platform === 'darwin' && Boolean(appPath) ? run('codesign', ['-dv', '--verbose=4', appPath]) : null;
-const codesignText = `${codesignDetail?.stdout || ''}\n${codesignDetail?.stderr || ''}`;
-const codesignIdentifier = codesignDetail?.status === 0 && /\bIdentifier=com\.sneakoscope\.sks-menubar\b/.test(codesignText);
-const resourceHashes = hashFiles(resources, resourceNames);
-const sourceNames = Object.keys(installReport?.source_files_sha256 || {}).sort();
-const sourceHashes = hashFiles(sourceRoot, sourceNames);
-const resourceAggregate = aggregateFileHashes(resourceHashes);
-const sourceAggregate = aggregateFileHashes(sourceHashes);
-const resourceHash = resourceNames.length > 0
-    && recordsEqual(resourceHashes, installReport?.resource_files_sha256)
-    && recordsEqual(resourceHashes, buildStamp?.resource_files_sha256)
-    && resourceAggregate === installReport?.resources_sha256
-    && resourceAggregate === buildStamp?.resources_sha256;
-const sourceHash = sourceNames.length === 17
-    && recordsEqual(sourceHashes, installReport?.source_files_sha256)
-    && recordsEqual(sourceHashes, buildStamp?.source_files_sha256)
-    && sourceAggregate === installReport?.source_sha256
-    && sourceAggregate === buildStamp?.source_sha256;
-const iconLoad = process.platform === 'darwin' && fs.existsSync(path.join(resources, 'AppIcon.icns'))
-    ? run('sips', ['-g', 'pixelWidth', '-g', 'pixelHeight', path.join(resources, 'AppIcon.icns')]).status === 0
-    : false;
-const checks = {
-    swift_parse: swiftParse && installChecks.swift_parse === true,
-    swift_compile: installChecks.swift_compile === true,
-    appkit_link: installChecks.swift_compile === true && fs.existsSync(executable),
-    source_inventory: installChecks.source_inventory === true && sourceNames.length === 17,
-    resources: resourcesOk && installChecks.resources_inventory === true && installChecks.expected_resources_present === true,
-    plist_icon: plistIcon && installChecks.info_plist_icon_verified === true,
-    app_icon_load: iconLoad && installChecks.app_icon_load_smoke === true,
-    codesign: codesign && installChecks.codesign_strict_verified === true,
-    codesign_identifier: codesignIdentifier && installChecks.codesign_identifier_verified === true,
-    install_idempotence: installReport?.is_idempotent === true && installChecks.is_idempotent === true,
-    previous_app_rollback: installReport?.previous_app_rollback_verified === true && installChecks.previous_app_rollback_verified === true,
-    resource_hash: resourceHash,
-    source_hash: sourceHash,
-    build_stamp_binding: installChecks.build_stamp_version_source_binding === true
-        && buildStamp?.schema === 'sks.sks-menubar-build-stamp.v2'
-        && buildStamp?.package_version === String(pkg.version || ''),
-    notification_actions: installChecks.notification_action_test === true,
-    accessibility: installChecks.accessibility_smoke === true,
-    reduced_motion: installChecks.reduced_motion_smoke === true,
-    action_script: installChecks.action_script_executable === true,
-    launch_agent: installChecks.launch_agent_safe === true
-};
-const blockers = [
-    ...(process.platform === 'darwin' ? [] : ['not_macos']),
-    ...validateMacosInstallReportOutcome(installReport).blockers.map((blocker) => `menubar_install_report_${blocker}`),
-    ...Object.entries(checks).filter(([, ok]) => !ok).map(([name]) => `macos_check_failed:${name}`)
-];
-const proof = {
-    schema: MACOS_MENUBAR_PROOF_SCHEMA,
-    ok: blockers.length === 0,
-    version: String(pkg.version || ''),
-    source_commit: gitHead(),
-    runner_os: 'macOS',
-    swift_version: String(run('swiftc', ['--version']).stdout || '').trim(),
-    xcode_version: String(run('xcodebuild', ['-version']).stdout || '').trim(),
-    app_path: appPath,
-    install_report_path: path.relative(root, installReportFile).split(path.sep).join('/'),
-    install_report_sha256: crypto.createHash('sha256').update(installReportBytes).digest('hex'),
-    install_report: {
-        schema: String(installReport?.schema || ''),
-        checks: installChecks,
-        failed_checks: Array.isArray(installReport?.failed_checks) ? installReport.failed_checks.map(String) : [],
-        resources_sha256: String(installReport?.resources_sha256 || ''),
-        source_sha256: String(installReport?.source_sha256 || ''),
-        build_stamp_schema: String(buildStamp?.schema || ''),
-        build_stamp_package_version: String(buildStamp?.package_version || ''),
-        build_stamp_resources_sha256: String(buildStamp?.resources_sha256 || ''),
-        build_stamp_source_sha256: String(buildStamp?.source_sha256 || '')
-    },
-    checks,
-    generated_at: new Date().toISOString(),
-    blockers
-};
-const file = writeMacosMenubarProof(root, proof);
-console.log(JSON.stringify({ ...proof, proof_path: path.relative(root, file).split(path.sep).join('/') }, null, 2));
-if (!proof.ok)
-    process.exitCode = 1;
-function run(command, args) {
-    return spawnSync(command, args, { cwd: root, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
-}
-function firstExisting(candidates) {
-    return candidates.find((candidate) => fs.existsSync(candidate)) || '';
-}
-function booleanRecord(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return {};
-    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, item === true]));
-}
-function hashFiles(directory, names) {
-    if (!directory || !fs.existsSync(directory))
-        return {};
-    const output = {};
-    for (const name of names) {
-        const file = path.join(directory, name);
-        if (!fs.existsSync(file) || !fs.statSync(file).isFile())
-            continue;
-        output[name] = crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
-    }
-    return output;
-}
-function aggregateFileHashes(hashes) {
-    const value = Object.entries(hashes).sort(([left], [right]) => left.localeCompare(right)).map(([name, digest]) => `${name}:${digest}`).join('\n');
-    return crypto.createHash('sha256').update(value).digest('hex');
-}
-function recordsEqual(left, right) {
-    if (!right || typeof right !== 'object' || Array.isArray(right))
-        return false;
-    return JSON.stringify(Object.entries(left).sort()) === JSON.stringify(Object.entries(right).sort());
-}
-function gitHead() {
-    return String(run('git', ['rev-parse', 'HEAD']).stdout || '').trim();
-}
-function required(name) {
-    const index = process.argv.indexOf(name);
-    const value = index >= 0 ? String(process.argv[index + 1] || '').trim() : '';
-    if (!value) {
-        console.error(`Release macOS proof failed: ${name} is required`);
-        process.exit(2);
-    }
-    return value;
-}

package/dist/scripts/release-main-push-guard.js

@@ -1,37 +0,0 @@
-#!/usr/bin/env node
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { inspectMainPushGuard, RELEASE_630_MISSION_ID } from '../core/release/main-push-guard.js';
-import { releaseProofDir, writeReleaseJson } from '../core/release/release-pack-receipt.js';
-import { RELEASE_ORIGIN_IDENTITY } from '../core/release/release-origin.js';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const expectedVersion = required('--expected-version');
-const expectedOriginMain = required('--expected-origin-main');
-const report = inspectMainPushGuard({
-    root,
-    expectedVersion,
-    expectedOriginMain,
-    expectedOriginIdentity: RELEASE_ORIGIN_IDENTITY,
-    requireReleaseStamp: process.argv.includes('--require-release-stamp'),
-    requirePackProof: process.argv.includes('--require-pack-proof'),
-    requireMacosProof: process.argv.includes('--require-macos-proof'),
-    requireCleanTree: process.argv.includes('--require-clean-tree'),
-    expectedReleaseMissionId: value('--release-mission') || RELEASE_630_MISSION_ID
-});
-const output = path.join(releaseProofDir(root, expectedVersion), 'main-push-guard.json');
-writeReleaseJson(output, report);
-console.log(JSON.stringify({ ...report, report_path: path.relative(root, output).split(path.sep).join('/') }, null, 2));
-if (!report.ok)
-    process.exitCode = 1;
-function required(name) {
-    const result = value(name);
-    if (!result) {
-        console.error(`Release main push guard failed: ${name} is required`);
-        process.exit(2);
-    }
-    return result;
-}
-function value(name) {
-    const index = process.argv.indexOf(name);
-    return index >= 0 ? String(process.argv[index + 1] || '').trim() : '';
-}

package/dist/scripts/release-main-push-receipt.js

@@ -1,43 +0,0 @@
-#!/usr/bin/env node
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { inspectMainPushReceipt } from '../core/release/main-push-receipt.js';
-import { RELEASE_630_MISSION_ID } from '../core/release/main-push-guard.js';
-import { releaseProofDir, writeReleaseJson } from '../core/release/release-pack-receipt.js';
-import { RELEASE_ORIGIN_IDENTITY } from '../core/release/release-origin.js';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const version = required('--version');
-const baseline = required('--baseline');
-const method = required('--method');
-const expectedReleaseMissionId = value('--release-mission') || RELEASE_630_MISSION_ID;
-const expectedWorkOrderSha256 = value('--work-order-sha256');
-if (method !== 'fast-forward' && method !== 'protected-pr-merge') {
-    console.error('Release main push receipt failed: --method must be fast-forward or protected-pr-merge');
-    process.exit(2);
-}
-const receipt = inspectMainPushReceipt({
-    root,
-    version,
-    baseline,
-    method,
-    expectedOriginIdentity: RELEASE_ORIGIN_IDENTITY,
-    expectedReleaseMissionId,
-    ...(expectedWorkOrderSha256 ? { expectedWorkOrderSha256 } : {})
-});
-const output = path.join(releaseProofDir(root, version), 'main-push-receipt.json');
-writeReleaseJson(output, receipt);
-console.log(JSON.stringify({ ...receipt, receipt_path: path.relative(root, output).split(path.sep).join('/') }, null, 2));
-if (!receipt.ok)
-    process.exitCode = 1;
-function required(name) {
-    const result = value(name);
-    if (!result) {
-        console.error(`Release main push receipt failed: ${name} is required`);
-        process.exit(2);
-    }
-    return result;
-}
-function value(name) {
-    const index = process.argv.indexOf(name);
-    return index >= 0 ? String(process.argv[index + 1] || '').trim() : '';
-}