amalgm 0.1.124 → 0.1.125

package/runtime/scripts/amalgm-mcp/tests/desktop-release-runner.test.js

@@ -0,0 +1,313 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const yaml = require('js-yaml');
+
+const {
+  absoluteAssetUrl,
+  applyDesktopReleaseEnv,
+  bridgeChannelInfoForBase,
+  desktopLegacyBridgePlan,
+  desktopLegacyBridgeRepository,
+  desktopReleaseArtifactPaths,
+  desktopReleaseProvider,
+  desktopReleasePublishTarget,
+  desktopReleaseRepository,
+  desktopReleaseToolEnv,
+  desktopUpdateUrlForLane,
+  desktopVersion,
+  envForBuild,
+  parseEnvFile,
+  publishDesktopRelease,
+  requestFromEnv,
+  shouldHandleRequest,
+} = require('../events/desktop-release-runner');
+
+test('desktop release runner maps engine pushes to engine SHA plus UI branch', () => {
+  const request = requestFromEnv({
+    AMALGM_DESKTOP_RELEASE_DRY_RUN: '1',
+    AMALGM_DESKTOP_RELEASE_SOURCE_REPO: 'amalgm-inc/amalgm-engine',
+    AMALGM_DESKTOP_RELEASE_REF: 'refs/heads/main',
+    AMALGM_DESKTOP_RELEASE_AFTER: '1'.repeat(40),
+  });
+
+  const result = publishDesktopRelease(request, {
+    checkoutRoot: '/tmp/amalgm-desktop-release-test',
+  });
+
+  assert.equal(result.dryRun, true);
+  assert.equal(result.lane, 'main');
+  assert.deepEqual(result.refs, {
+    engineRef: '1'.repeat(40),
+    uiRef: 'main',
+  });
+  assert.equal(result.releaseProvider, 'fly');
+  assert.equal(result.updateProvider, 'generic');
+  assert.equal(result.updateUrl, 'https://amalgm-desktop-releases.fly.dev/main/');
+  assert.equal(result.releaseUrl, 'https://amalgm-desktop-releases.fly.dev/main/latest-mac.yml');
+  assert.equal(result.flyApp, 'amalgm-desktop-releases');
+  assert.equal(result.flyRemoteDir, '/data/main');
+  assert.equal(result.releaseRepository, 'amalgm-inc/amalgm-desktop-releases');
+  assert.deepEqual(result.legacyBridge, {
+    enabled: true,
+    repository: 'amalgm-inc/amalgm-engine',
+    channelFile: 'latest-mac.yml',
+    updateUrl: 'https://amalgm-desktop-releases.fly.dev/main/',
+  });
+});
+
+test('desktop release runner maps UI pushes to UI SHA plus engine branch', () => {
+  const request = requestFromEnv({
+    AMALGM_DESKTOP_RELEASE_DRY_RUN: 'true',
+    AMALGM_DESKTOP_RELEASE_SOURCE_REPO: 'amalgm-inc/amalgm-ui',
+    AMALGM_DESKTOP_RELEASE_REF: 'refs/heads/preview',
+    AMALGM_DESKTOP_RELEASE_AFTER: '2'.repeat(40),
+  });
+
+  const result = publishDesktopRelease(request, {
+    checkoutRoot: '/tmp/amalgm-desktop-release-test',
+  });
+
+  assert.equal(result.dryRun, true);
+  assert.equal(result.lane, 'preview');
+  assert.deepEqual(result.refs, {
+    engineRef: 'preview',
+    uiRef: '2'.repeat(40),
+  });
+});
+
+test('desktop release runner skips irrelevant pushes and branch deletions', () => {
+  assert.equal(shouldHandleRequest({
+    repository: 'amalgm-inc/amalgm-engine',
+    branch: 'feature',
+    lane: null,
+    after: '3'.repeat(40),
+  }).ok, false);
+
+  assert.equal(shouldHandleRequest({
+    repository: 'amalgm-inc/amalgm-ui',
+    branch: 'main',
+    lane: 'main',
+    after: '0'.repeat(40),
+  }).ok, false);
+});
+
+test('desktop versions stay compatible with existing release ordering', () => {
+  assert.equal(desktopVersion('0.1.124', 'main', 45), '0.1.124000045');
+  assert.equal(desktopVersion('0.1.124-preview.1', 'preview', 45), '0.1.124000045-preview.1');
+});
+
+test('desktop release runner loads env-file fallbacks without overriding explicit env', () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-desktop-release-env-test-'));
+  const envFile = path.join(tempRoot, 'desktop-release.env');
+  fs.writeFileSync(envFile, [
+    'NEXT_PUBLIC_SUPABASE_URL=https://example.supabase.co',
+    'NEXT_PUBLIC_SUPABASE_ANON_KEY="anon-key"',
+    'NEXT_PUBLIC_SITE_URL=https://from-file.example',
+    '',
+  ].join('\n'));
+
+  try {
+    const env = {
+      AMALGM_DESKTOP_RELEASE_ENV_FILE: envFile,
+      NEXT_PUBLIC_SITE_URL: 'https://explicit.example',
+    };
+    applyDesktopReleaseEnv(env);
+    assert.deepEqual(parseEnvFile('FOO=bar\nQUOTED="hi there"'), {
+      FOO: 'bar',
+      QUOTED: 'hi there',
+    });
+    assert.equal(env.NEXT_PUBLIC_SUPABASE_URL, 'https://example.supabase.co');
+    assert.equal(env.NEXT_PUBLIC_SUPABASE_ANON_KEY, 'anon-key');
+    assert.equal(env.NEXT_PUBLIC_SITE_URL, 'https://explicit.example');
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test('desktop release runner pins child build toolchain from env file', () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-desktop-release-toolchain-test-'));
+  const envFile = path.join(tempRoot, 'desktop-release.env');
+  const nodeBin = path.join(tempRoot, 'node-bin', 'node');
+  fs.mkdirSync(path.dirname(nodeBin), { recursive: true });
+  fs.writeFileSync(nodeBin, '');
+  fs.writeFileSync(envFile, [
+    `AMALGM_DESKTOP_RELEASE_NODE_BIN=${nodeBin}`,
+    'AMALGM_DESKTOP_RELEASE_PYTHON=/usr/bin/python3',
+    '',
+  ].join('\n'));
+
+  try {
+    const env = desktopReleaseToolEnv({
+      AMALGM_DESKTOP_RELEASE_ENV_FILE: envFile,
+      PATH: '/usr/local/bin:/usr/bin',
+    });
+    assert.equal(env.PATH.split(path.delimiter)[0], path.dirname(nodeBin));
+    assert.equal(env.npm_config_python, '/usr/bin/python3');
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test('desktop release runner uses electron-builder compatible signing identity name', () => {
+  const env = envForBuild(
+    { GH_TOKEN: 'token' },
+    { lane: 'preview', delivery: 'delivery-id' },
+    '0.1.124-canary.1',
+    '0.1.124000001-preview.1',
+    { engineRef: 'engine', uiRef: 'ui' },
+    { engineSha: 'engine-sha', uiSha: 'ui-sha' },
+    'https://preview.amalgm.ai',
+  );
+  assert.equal(env.CSC_NAME, 'amalgm, Inc. (C5S6UATV3L)');
+  assert.equal(env.CSC_NAME.includes('Developer ID Application:'), false);
+  assert.equal(env.AMALGM_DESKTOP_RELEASE_PROVIDER, 'fly');
+  assert.equal(env.AMALGM_DESKTOP_UPDATE_PROVIDER, 'generic');
+  assert.equal(env.AMALGM_DESKTOP_UPDATE_BASE_URL, 'https://amalgm-desktop-releases.fly.dev/');
+  assert.equal(env.AMALGM_DESKTOP_UPDATE_URL, 'https://amalgm-desktop-releases.fly.dev/preview/');
+  assert.equal(env.AMALGM_DESKTOP_RELEASE_UPLOAD_METHOD, 'http');
+  assert.equal(env.AMALGM_DESKTOP_RELEASE_UPLOAD_URL, 'https://amalgm-desktop-releases.fly.dev/');
+  assert.equal(env.AMALGM_DESKTOP_RELEASE_FLY_APP, 'amalgm-desktop-releases');
+  assert.equal(env.AMALGM_DESKTOP_RELEASE_FLY_ROOT, '/data');
+});
+
+test('desktop release runner omits blank certificate file secrets', () => {
+  const env = envForBuild(
+    {
+      GH_TOKEN: 'token',
+      CSC_LINK: '',
+      CSC_KEY_PASSWORD: '   ',
+    },
+    { lane: 'main', delivery: 'delivery-id' },
+    '0.1.124',
+    '0.1.124000001',
+    { engineRef: 'engine', uiRef: 'ui' },
+    { engineSha: 'engine-sha', uiSha: 'ui-sha' },
+    'https://amalgm.ai',
+  );
+  assert.equal(Object.hasOwn(env, 'CSC_LINK'), false);
+  assert.equal(Object.hasOwn(env, 'CSC_KEY_PASSWORD'), false);
+  assert.equal(env.CSC_NAME, 'amalgm, Inc. (C5S6UATV3L)');
+});
+
+test('desktop release repository can be overridden as owner/repo or full name', () => {
+  assert.deepEqual(desktopReleaseRepository({
+    AMALGM_DESKTOP_UPDATE_OWNER: 'example',
+    AMALGM_DESKTOP_UPDATE_REPO: 'desktop-feed',
+  }), {
+    owner: 'example',
+    repo: 'desktop-feed',
+    fullName: 'example/desktop-feed',
+  });
+  assert.deepEqual(desktopReleaseRepository({
+    AMALGM_DESKTOP_RELEASE_REPOSITORY: 'other/feed',
+  }), {
+    owner: 'other',
+    repo: 'feed',
+    fullName: 'other/feed',
+  });
+});
+
+test('desktop release runner defaults to Fly generic feed and keeps GitHub as explicit fallback', () => {
+  assert.equal(desktopReleaseProvider({}), 'fly');
+  assert.equal(desktopUpdateUrlForLane('main', {}), 'https://amalgm-desktop-releases.fly.dev/main/');
+  assert.deepEqual(desktopReleasePublishTarget({}, 'preview'), {
+    provider: 'fly',
+    updateProvider: 'generic',
+    updateUrl: 'https://amalgm-desktop-releases.fly.dev/preview/',
+    channelFile: 'preview-mac.yml',
+    channelUrl: 'https://amalgm-desktop-releases.fly.dev/preview/preview-mac.yml',
+    uploadMethod: 'http',
+    uploadBaseUrl: 'https://amalgm-desktop-releases.fly.dev/',
+    flyApp: 'amalgm-desktop-releases',
+    flyRoot: '/data',
+    remoteDir: '/data/preview',
+    lane: 'preview',
+  });
+
+  const githubTarget = desktopReleasePublishTarget({
+    AMALGM_DESKTOP_RELEASE_PROVIDER: 'github',
+    AMALGM_DESKTOP_RELEASE_REPOSITORY: 'example/desktop-feed',
+  }, 'main');
+  assert.equal(githubTarget.provider, 'github');
+  assert.equal(githubTarget.updateProvider, 'github');
+  assert.equal(githubTarget.releaseRepository.fullName, 'example/desktop-feed');
+});
+
+test('desktop release runner builds legacy GitHub bridge metadata for old clients', () => {
+  assert.equal(
+    absoluteAssetUrl('https://amalgm-desktop-releases.fly.dev/main/', 'amalgm-0.1.1-arm64-mac.zip'),
+    'https://amalgm-desktop-releases.fly.dev/main/amalgm-0.1.1-arm64-mac.zip',
+  );
+  assert.equal(
+    absoluteAssetUrl('https://amalgm-desktop-releases.fly.dev/main/', 'https://cdn.example/release.zip'),
+    'https://cdn.example/release.zip',
+  );
+  assert.deepEqual(desktopLegacyBridgeRepository({}), {
+    owner: 'amalgm-inc',
+    repo: 'amalgm-engine',
+    fullName: 'amalgm-inc/amalgm-engine',
+  });
+  assert.deepEqual(desktopLegacyBridgePlan({}, desktopReleasePublishTarget({}, 'preview')), {
+    enabled: true,
+    repository: 'amalgm-inc/amalgm-engine',
+    channelFile: 'preview-mac.yml',
+    updateUrl: 'https://amalgm-desktop-releases.fly.dev/preview/',
+  });
+});
+
+test('desktop release runner rewrites bridge channel YAML to absolute Fly asset URLs', () => {
+  const bridged = bridgeChannelInfoForBase([
+    'version: 0.1.124000001',
+    'files:',
+    '  - url: amalgm-0.1.124000001-arm64-mac.zip',
+    '    sha512: zip-sha',
+    '    size: 123',
+    '  - url: amalgm-0.1.124000001-arm64.dmg',
+    '    sha512: dmg-sha',
+    '    size: 456',
+    'path: amalgm-0.1.124000001-arm64-mac.zip',
+    'sha512: zip-sha',
+    'packages:',
+    '  arm64:',
+    '    path: amalgm-0.1.124000001-arm64.pkg',
+    '',
+  ].join('\n'), 'https://amalgm-desktop-releases.fly.dev/main/');
+  const info = yaml.load(bridged);
+
+  assert.equal(info.files[0].url, 'https://amalgm-desktop-releases.fly.dev/main/amalgm-0.1.124000001-arm64-mac.zip');
+  assert.equal(info.files[1].url, 'https://amalgm-desktop-releases.fly.dev/main/amalgm-0.1.124000001-arm64.dmg');
+  assert.equal(info.path, 'https://amalgm-desktop-releases.fly.dev/main/amalgm-0.1.124000001-arm64-mac.zip');
+  assert.equal(info.packages.arm64.path, 'https://amalgm-desktop-releases.fly.dev/main/amalgm-0.1.124000001-arm64.pkg');
+});
+
+test('desktop release runner requires all updater artifacts', () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-desktop-release-artifacts-test-'));
+  const version = '0.1.124000001-preview.1';
+  const files = [
+    `amalgm-preview-${version}-arm64.dmg`,
+    `amalgm-preview-${version}-arm64.dmg.blockmap`,
+    `amalgm-preview-${version}-arm64.zip`,
+    `amalgm-preview-${version}-arm64.zip.blockmap`,
+    'preview-mac.yml',
+  ];
+
+  try {
+    for (const file of files) fs.writeFileSync(path.join(tempRoot, file), '');
+    const artifacts = desktopReleaseArtifactPaths(tempRoot, 'preview', version)
+      .map((filePath) => path.basename(filePath));
+    assert.deepEqual(artifacts, files);
+
+    fs.rmSync(path.join(tempRoot, 'preview-mac.yml'));
+    assert.throws(
+      () => desktopReleaseArtifactPaths(tempRoot, 'preview', version),
+      /Missing desktop release artifact\(s\): preview-mac\.yml/,
+    );
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+});

package/runtime/scripts/amalgm-mcp/tests/desktop-release-server.test.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-desktop-release-server-test-'));
+process.env.DATA_ROOT = tempRoot;
+
+const {
+  createServer,
+  latestArtifactName,
+  latestDownloadTarget,
+  parseDownloadPath,
+} = require(path.resolve(__dirname, '../../../../infra/desktop-release-server/server.js'));
+
+test.after(() => {
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+function writeReleaseMetadata(lane, artifacts) {
+  const laneDir = path.join(tempRoot, lane);
+  fs.mkdirSync(laneDir, { recursive: true });
+  fs.writeFileSync(path.join(laneDir, 'desktop-release.json'), `${JSON.stringify({ lane, artifacts }, null, 2)}\n`);
+}
+
+test('desktop release server resolves stable bridge download targets from metadata', () => {
+  const artifacts = [
+    'amalgm-0.1.1-arm64-mac.zip',
+    'amalgm-0.1.1-arm64-mac.zip.blockmap',
+    'amalgm-0.1.1-arm64.dmg',
+    'amalgm-0.1.1-arm64.dmg.blockmap',
+    'latest-mac.yml',
+  ];
+  writeReleaseMetadata('main', artifacts);
+
+  assert.deepEqual(parseDownloadPath('/main/download'), { lane: 'main', kind: 'dmg' });
+  assert.deepEqual(parseDownloadPath('/main/download/zip'), { lane: 'main', kind: 'zip' });
+  assert.deepEqual(parseDownloadPath('/main/latest.dmg'), { lane: 'main', kind: 'dmg' });
+  assert.equal(parseDownloadPath('/main/latest-mac.yml'), null);
+  assert.equal(latestArtifactName({ artifacts }, 'dmg'), 'amalgm-0.1.1-arm64.dmg');
+  assert.deepEqual(latestDownloadTarget('main', 'zip'), {
+    metadata: { lane: 'main', artifacts },
+    artifactName: 'amalgm-0.1.1-arm64-mac.zip',
+  });
+});
+
+test('desktop release server redirects public bridge download URLs to current assets', async () => {
+  writeReleaseMetadata('preview', [
+    'amalgm-preview-0.1.1-preview.1-arm64.zip',
+    'amalgm-preview-0.1.1-preview.1-arm64.dmg',
+    'preview-mac.yml',
+  ]);
+
+  const server = createServer();
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const { port } = server.address();
+
+  try {
+    const response = await fetch(`http://127.0.0.1:${port}/preview/download`, { redirect: 'manual' });
+    assert.equal(response.status, 302);
+    assert.equal(
+      response.headers.get('location'),
+      `http://127.0.0.1:${port}/preview/amalgm-preview-0.1.1-preview.1-arm64.dmg`,
+    );
+
+    const zipResponse = await fetch(`http://127.0.0.1:${port}/preview/latest.zip`, {
+      method: 'HEAD',
+      redirect: 'manual',
+    });
+    assert.equal(zipResponse.status, 302);
+    assert.equal(
+      zipResponse.headers.get('location'),
+      `http://127.0.0.1:${port}/preview/amalgm-preview-0.1.1-preview.1-arm64.zip`,
+    );
+
+    const forwardedResponse = await fetch(`http://127.0.0.1:${port}/preview/download`, {
+      headers: {
+        'x-forwarded-proto': 'https',
+        'x-forwarded-host': 'amalgm-desktop-releases.fly.dev',
+      },
+      redirect: 'manual',
+    });
+    assert.equal(forwardedResponse.status, 302);
+    assert.equal(
+      forwardedResponse.headers.get('location'),
+      'https://amalgm-desktop-releases.fly.dev/preview/amalgm-preview-0.1.1-preview.1-arm64.dmg',
+    );
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+  }
+});

package/runtime/scripts/amalgm-mcp/tests/npm-release-runner.test.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  baseVersion,
+  npmReleasePlan,
+  publishNpmRelease,
+  requestFromEnv,
+  shouldHandleRequest,
+  timestampForVersion,
+} = require('../events/npm-release-runner');
+
+test('npm release runner maps main pushes to stable latest and main tags', () => {
+  const request = requestFromEnv({
+    AMALGM_NPM_RELEASE_DRY_RUN: '1',
+    AMALGM_NPM_RELEASE_SOURCE_REPO: 'amalgm-inc/amalgm-engine',
+    AMALGM_NPM_RELEASE_REF: 'refs/heads/main',
+    AMALGM_NPM_RELEASE_AFTER: '1'.repeat(40),
+  });
+
+  const result = publishNpmRelease(request, {
+    sourcePackageVersion: '0.1.124',
+  });
+
+  assert.equal(result.dryRun, true);
+  assert.equal(result.lane, 'main');
+  assert.deepEqual(result.plan, {
+    lane: 'main',
+    version: '0.1.124',
+    publishTag: 'latest',
+    distTags: ['latest', 'main'],
+    sourcePackageVersion: '0.1.124',
+  });
+});
+
+test('npm release runner maps preview pushes to unique canary versions', () => {
+  const request = requestFromEnv({
+    AMALGM_NPM_RELEASE_DRY_RUN: 'true',
+    AMALGM_NPM_RELEASE_SOURCE_REPO: 'amalgm-inc/amalgm-engine',
+    AMALGM_NPM_RELEASE_REF: 'refs/heads/preview',
+    AMALGM_NPM_RELEASE_AFTER: '2'.repeat(40),
+  });
+
+  const result = publishNpmRelease(request, {
+    sourcePackageVersion: '0.1.124-canary.20260620215843',
+    timestamp: '20260621224500',
+  });
+
+  assert.equal(result.dryRun, true);
+  assert.equal(result.lane, 'preview');
+  assert.deepEqual(result.plan, {
+    lane: 'preview',
+    version: '0.1.124-canary.20260621224500',
+    publishTag: 'canary',
+    distTags: ['canary'],
+    sourcePackageVersion: '0.1.124-canary.20260620215843',
+  });
+});
+
+test('npm release runner rejects unsupported pushes and skip markers', () => {
+  assert.equal(shouldHandleRequest({
+    repository: 'amalgm-inc/amalgm-ui',
+    branch: 'main',
+    lane: 'main',
+    after: '3'.repeat(40),
+    messages: [],
+  }).ok, false);
+
+  assert.equal(shouldHandleRequest({
+    repository: 'amalgm-inc/amalgm-engine',
+    branch: 'feature',
+    lane: null,
+    after: '3'.repeat(40),
+    messages: [],
+  }).ok, false);
+
+  assert.equal(shouldHandleRequest({
+    repository: 'amalgm-inc/amalgm-engine',
+    branch: 'preview',
+    lane: 'preview',
+    after: '3'.repeat(40),
+    messages: ['Release automation plumbing [skip npm]'],
+  }).ok, false);
+});
+
+test('npm release plans enforce stable main and derive canary base versions', () => {
+  assert.throws(
+    () => npmReleasePlan('0.1.124-canary.1', 'main'),
+    /Main npm releases must use a stable package version/,
+  );
+  assert.equal(baseVersion('0.1.124-canary.1'), '0.1.124');
+  assert.equal(
+    npmReleasePlan('0.1.124', 'preview', { timestamp: '20260621230000' }).version,
+    '0.1.124-canary.20260621230000',
+  );
+  assert.equal(
+    timestampForVersion(new Date(Date.UTC(2026, 5, 21, 22, 45, 7))),
+    '20260621224507',
+  );
+});