termdock 1.4.45 → 1.4.47

package/scripts/classify-release.mjs

@@ -0,0 +1,88 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+function git(args) {
+  return execFileSync('git', args, { cwd: root, encoding: 'utf8' }).trim();
+}
+
+function stable(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stable(value[key])]));
+}
+
+function latestDesktopTag() {
+  return git(['tag', '--merged', 'HEAD', '--list', 'v*', '--sort=-version:refname'])
+    .split('\n')
+    .find(Boolean);
+}
+
+const requestedBase = process.argv.slice(2).find((argument) => !argument.startsWith('--'));
+const base = requestedBase || latestDesktopTag();
+if (!base) {
+  throw new Error('No desktop release tag found. Fetch tags or pass a base ref explicitly.');
+}
+
+const changedFiles = git(['diff', '--name-only', base, '--'])
+  .split('\n')
+  .map((file) => file.trim())
+  .filter(Boolean);
+const currentPackage = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+const basePackage = JSON.parse(git(['show', `${base}:package.json`]));
+const dependencyChanged = JSON.stringify(stable({
+  dependencies: currentPackage.dependencies ?? {},
+  engines: currentPackage.engines ?? {},
+})) !== JSON.stringify(stable({
+  dependencies: basePackage.dependencies ?? {},
+  engines: basePackage.engines ?? {},
+}));
+
+const desktopPatterns = [
+  /^desktop\//,
+  /^forge\.config\.cjs$/,
+  /^tsconfig\.desktop\.json$/,
+  /^scripts\/prepare-desktop-runtime\.mjs$/,
+  /^scripts\/prepare-desktop-tokens\.mjs$/,
+  /^\.github\/workflows\/release-macos\.yml$/,
+];
+const runtimePatterns = [
+  /^src\//,
+  /^public\//,
+  /^index\.html$/,
+  /^vite\.config\.ts$/,
+  /^tailwind\.config\.js$/,
+  /^postcss\.config\.js$/,
+  /^package(?:-lock)?\.json$/,
+  /^scripts\/generate-runtime-manifest\.mjs$/,
+];
+const testFile = /(?:^|\/)\w[^/]*\.test\.[cm]?[jt]sx?$/;
+const noReleaseFile = /^(?:docs\/|README|LICENSE|AGENTS|\.gitignore$|scripts\/classify-release\.mjs$)/;
+const desktopFiles = changedFiles.filter((file) =>
+  !testFile.test(file) && desktopPatterns.some((pattern) => pattern.test(file)));
+const runtimeFiles = changedFiles.filter((file) =>
+  !testFile.test(file) && runtimePatterns.some((pattern) => pattern.test(file)));
+const codeFiles = changedFiles.filter((file) => !noReleaseFile.test(file) && !testFile.test(file));
+const classified = new Set([...desktopFiles, ...runtimeFiles]);
+const unknownCodeFiles = codeFiles.filter((file) => !classified.has(file));
+const requiresDesktop = dependencyChanged || desktopFiles.length > 0 || unknownCodeFiles.length > 0;
+const requiresRuntime = runtimeFiles.length > 0 || requiresDesktop;
+const result = {
+  base,
+  requiresRuntime,
+  requiresDesktop,
+  dependencyChanged,
+  desktopFiles,
+  runtimeFiles,
+  unknownCodeFiles,
+};
+
+console.log(JSON.stringify(result, null, 2));
+if (process.argv.includes('--github-output') && process.env.GITHUB_OUTPUT) {
+  fs.appendFileSync(
+    process.env.GITHUB_OUTPUT,
+    `requires_runtime=${requiresRuntime}\nrequires_desktop=${requiresDesktop}\n`,
+  );
+}

package/scripts/generate-runtime-manifest.mjs

@@ -0,0 +1,77 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const packageJson = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+const packageLock = JSON.parse(fs.readFileSync(path.join(root, 'package-lock.json'), 'utf8'));
+const compatibility = JSON.parse(
+  fs.readFileSync(path.join(root, 'desktop', 'runtime-compatibility.json'), 'utf8'),
+);
+
+function stableObject(value) {
+  if (Array.isArray(value)) return value.map(stableObject);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(
+    Object.keys(value).sort().map((key) => [key, stableObject(value[key])]),
+  );
+}
+
+function hashDirectory(directory) {
+  const hash = crypto.createHash('sha256');
+  const visit = (current, relative = '') => {
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })
+      .sort((left, right) => left.name.localeCompare(right.name))) {
+      const entryPath = path.join(current, entry.name);
+      const relativePath = path.join(relative, entry.name).split(path.sep).join('/');
+      if (entry.isDirectory()) visit(entryPath, relativePath);
+      else if (entry.isFile()) {
+        hash.update(relativePath);
+        hash.update('\0');
+        hash.update(fs.readFileSync(entryPath));
+        hash.update('\0');
+      }
+    }
+  };
+  visit(directory);
+  return `sha256-${hash.digest('base64')}`;
+}
+
+const productionPackages = Object.fromEntries(
+  Object.entries(packageLock.packages ?? {})
+    .filter(([packagePath, entry]) => packagePath && entry?.dev !== true)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([packagePath, entry]) => [packagePath, {
+      version: entry.version ?? null,
+      integrity: entry.integrity ?? null,
+      optional: entry.optional === true,
+    }]),
+);
+const dependencyInput = stableObject({
+  dependencies: packageJson.dependencies ?? {},
+  packages: productionPackages,
+});
+const dependencyHash = `sha256-${crypto
+  .createHash('sha256')
+  .update(JSON.stringify(dependencyInput))
+  .digest('base64')}`;
+
+const manifest = {
+  schemaVersion: compatibility.schemaVersion,
+  packageName: packageJson.name,
+  version: packageJson.version,
+  runtimeProtocolVersion: compatibility.runtimeProtocolVersion,
+  minimumDesktopVersion: compatibility.minimumDesktopVersion,
+  nodeMajor: compatibility.nodeMajor,
+  dependencyHash,
+  serverBundleHash: hashDirectory(path.join(root, 'dist', 'server')),
+  entrypoint: 'dist/server/cli.js',
+  clientEntrypoint: 'dist/client/index.html',
+};
+
+fs.writeFileSync(
+  path.join(root, 'runtime-manifest.json'),
+  `${JSON.stringify(manifest, null, 2)}\n`,
+);
+console.log(`[runtime-manifest] ${manifest.version} ${manifest.dependencyHash}`);

package/scripts/prepare-desktop-runtime.mjs

@@ -14,6 +14,9 @@ const toolchainDir = path.join(stage, 'toolchain');
 const toolchainBinDir = path.join(toolchainDir, 'bin');
 const toolchainLibDir = path.join(toolchainDir, 'lib');
 const nodeDownloadDir = path.join(stage, 'node-download');
+const nodeArchiveCacheDir = process.env.TERMDOCK_NODE_ARCHIVE_CACHE
+  ? path.resolve(process.env.TERMDOCK_NODE_ARCHIVE_CACHE)
+  : path.join(os.homedir(), '.cache', 'termdock', 'node-archives');
 const desktopBuildNodeMajor = 22;
 
 const buildNodeMajor = Number.parseInt(process.versions.node.split('.')[0], 10);
@@ -126,7 +129,19 @@ const nodeArchiveName = `node-${process.version}-${nodePlatform}-${nodeArch}.${n
 const nodeArchiveUrl = `https://nodejs.org/dist/${process.version}/${nodeArchiveName}`;
 fs.mkdirSync(nodeDownloadDir, { recursive: true });
 const nodeArchivePath = path.join(nodeDownloadDir, nodeArchiveName);
-run('/usr/bin/curl', ['-fL', '--retry', '4', '--output', nodeArchivePath, nodeArchiveUrl]);
+fs.mkdirSync(nodeArchiveCacheDir, { recursive: true });
+const cachedNodeArchivePath = path.join(nodeArchiveCacheDir, nodeArchiveName);
+if (!fs.existsSync(cachedNodeArchivePath)) {
+  const temporaryArchivePath = `${cachedNodeArchivePath}.${process.pid}.tmp`;
+  try {
+    run('/usr/bin/curl', ['-fL', '--retry', '4', '--output', temporaryArchivePath, nodeArchiveUrl]);
+    run('/usr/bin/tar', ['-tzf', temporaryArchivePath], { stdio: 'ignore' });
+    fs.renameSync(temporaryArchivePath, cachedNodeArchivePath);
+  } finally {
+    fs.rmSync(temporaryArchivePath, { force: true });
+  }
+}
+fs.copyFileSync(cachedNodeArchivePath, nodeArchivePath);
 if (nodeArchiveExt !== 'tar.gz') {
   throw new Error(`Desktop runtime preparation is not implemented for ${process.platform}`);
 }
@@ -140,18 +155,26 @@ const extractedNode = path.join(
 copyMacBinary(extractedNode, runtimeNode);
 
 const rootPackage = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+const runtimeManifest = JSON.parse(
+  fs.readFileSync(path.join(root, 'runtime-manifest.json'), 'utf8'),
+);
 const runtimePackage = {
-  name: 'termdock-desktop-runtime',
+  name: rootPackage.name,
   version: rootPackage.version,
   private: true,
   type: 'module',
   dependencies: rootPackage.dependencies,
 };
 fs.writeFileSync(path.join(serverDir, 'package.json'), `${JSON.stringify(runtimePackage, null, 2)}\n`);
+fs.copyFileSync(path.join(root, 'package-lock.json'), path.join(serverDir, 'package-lock.json'));
+fs.copyFileSync(
+  path.join(root, 'runtime-manifest.json'),
+  path.join(serverDir, 'runtime-manifest.json'),
+);
 fs.cpSync(path.join(root, 'dist'), path.join(serverDir, 'dist'), { recursive: true });
 
 run(process.platform === 'win32' ? 'npm.cmd' : 'npm', [
-  'install',
+  'ci',
   '--omit=dev',
   '--no-audit',
   '--no-fund',
@@ -195,6 +218,7 @@ const manifest = {
   nodeVersion: process.version,
   createdAt: new Date().toISOString(),
   tools: fs.readdirSync(toolchainBinDir).sort(),
+  runtimeCompatibility: runtimeManifest,
 };
 fs.writeFileSync(path.join(stage, 'manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`);
 console.log(`[desktop-runtime] ready at ${stage}`);