@t3x-dev/local 0.1.2

package/scripts/generate-runtime-manifest.mjs

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { FIXED_VERSION_PACKAGES, verifyVersionsOrThrow } from '../../../tools/verify-versions.mjs';
+import {
+  getLocalPackageDir,
+  getRuntimeArtifactsDir,
+  getRuntimeManifestPath,
+  readJson,
+  sha256File,
+  statSize,
+  writeJson,
+} from './runtime-helpers.mjs';
+
+const packageDir = getLocalPackageDir();
+const repoRoot = path.resolve(packageDir, '../..');
+await verifyVersionsOrThrow({ repoRoot, verifyManifest: false });
+const localPackageJson = await readJson(path.join(packageDir, 'package.json'));
+const webPackageJson = await readJson(path.join(repoRoot, 'apps', 'web', 'package.json'));
+const artifactsDir = path.resolve(
+  process.env.T3X_LOCAL_RUNTIME_OUTPUT_DIR ?? getRuntimeArtifactsDir(packageDir)
+);
+const manifestPath = getRuntimeManifestPath(packageDir);
+const releaseBaseUrl =
+  process.env.T3X_LOCAL_RUNTIME_BASE_URL ??
+  `https://github.com/t3x-dev/t3x-core/releases/download/t3x-local-v${localPackageJson.version}`;
+const versions = await readFixedPackageVersions(repoRoot);
+const runtimeArtifacts = await collectRuntimeArtifacts(artifactsDir, localPackageJson.version);
+
+const manifest = {
+  manifestVersion: 1,
+  packageVersion: localPackageJson.version,
+  fixedVersion: localPackageJson.version,
+  generatedAt: new Date().toISOString(),
+  dependencies: {
+    ...versions,
+    web: webPackageJson.version,
+  },
+  platforms: runtimeArtifacts.reduce((accumulator, artifact) => {
+    accumulator[artifact.platformKey] = {
+      fileName: artifact.fileName,
+      url: `${releaseBaseUrl.replace(/\/$/, '')}/${artifact.fileName}`,
+      sha256: artifact.sha256,
+      size: artifact.size,
+    };
+    return accumulator;
+  }, {}),
+};
+
+await writeJson(manifestPath, manifest);
+console.log(`[generate-runtime-manifest] Wrote ${manifestPath}`);
+
+async function readFixedPackageVersions(rootDir) {
+  const versionMap = {};
+
+  for (const packageName of FIXED_VERSION_PACKAGES) {
+    versionMap[packageName] = (
+      await readJson(path.join(rootDir, getWorkspacePackagePath(packageName), 'package.json'))
+    ).version;
+  }
+
+  return versionMap;
+}
+
+async function collectRuntimeArtifacts(artifactDir, packageVersion) {
+  const entries = await fs.readdir(artifactDir, { withFileTypes: true });
+  const prefix = `t3x-local-runtime-${packageVersion}-`;
+  const suffix = '.tar.gz';
+  const artifacts = [];
+
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.startsWith(prefix) || !entry.name.endsWith(suffix)) {
+      continue;
+    }
+
+    const platformKey = entry.name.slice(prefix.length, -suffix.length);
+    const artifactPath = path.join(artifactDir, entry.name);
+
+    artifacts.push({
+      platformKey,
+      fileName: entry.name,
+      sha256: await sha256File(artifactPath),
+      size: await statSize(artifactPath),
+    });
+  }
+
+  if (artifacts.length === 0) {
+    throw new Error(
+      `No runtime artifacts found in ${artifactDir} for @t3x-dev/local ${packageVersion}`
+    );
+  }
+
+  artifacts.sort((left, right) => left.platformKey.localeCompare(right.platformKey));
+  return artifacts;
+}
+
+function getWorkspacePackagePath(packageName) {
+  switch (packageName) {
+    case '@t3x-dev/yops':
+      return path.join('packages', 'yops');
+    case '@t3x-dev/yschema':
+      return path.join('packages', 'yschema');
+    case '@t3x-dev/core':
+      return path.join('packages', 'core');
+    case '@t3x-dev/storage':
+      return path.join('packages', 'storage');
+    case '@t3x-dev/api':
+      return path.join('packages', 'api');
+    case '@t3x-dev/api-client':
+      return path.join('packages', 'api-client');
+    case '@t3x-dev/cli':
+      return path.join('apps', 'cli');
+    case '@t3x-dev/mcp':
+      return path.join('apps', 'mcp');
+    case '@t3x-dev/local':
+      return path.join('apps', 'local');
+    default:
+      throw new Error(`Unsupported fixed package ${packageName}`);
+  }
+}

package/scripts/postinstall-download.mjs

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+
+import { spawnSync } from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  assertRuntimeLayout,
+  ensureDir,
+  fileExists,
+  findWorkspaceRepoRoot,
+  getDefaultInstalledRuntimeDir,
+  getLocalPackageDir,
+  getPlatformKey,
+  getRuntimeManifestPath,
+  readJson,
+  resolveMirrorArtifactLocation,
+} from './runtime-helpers.mjs';
+
+const FIXED_VERSION_PACKAGES = [
+  '@t3x-dev/yops',
+  '@t3x-dev/yschema',
+  '@t3x-dev/core',
+  '@t3x-dev/storage',
+  '@t3x-dev/api',
+  '@t3x-dev/api-client',
+  '@t3x-dev/cli',
+  '@t3x-dev/mcp',
+  '@t3x-dev/local',
+];
+const LOCAL_DIRECT_FIXED_DEPENDENCIES = [
+  '@t3x-dev/api',
+  '@t3x-dev/cli',
+  '@t3x-dev/mcp',
+  '@t3x-dev/storage',
+];
+
+if (process.env.T3X_LOCAL_SKIP_DOWNLOAD === '1' || process.env.T3X_LOCAL_SKIP_DOWNLOAD === 'true') {
+  console.log(
+    '[t3x-local:postinstall] Skipping runtime download because T3X_LOCAL_SKIP_DOWNLOAD is set.'
+  );
+  process.exit(0);
+}
+
+const packageDir = getLocalPackageDir();
+const manifestPath = getRuntimeManifestPath(packageDir);
+const workspaceRepoRoot = await findWorkspaceRepoRoot(packageDir);
+
+if (workspaceRepoRoot) {
+  console.log(
+    `[t3x-local:postinstall] Detected workspace install at ${workspaceRepoRoot}. Skipping runtime download.`
+  );
+  process.exit(0);
+}
+
+if (!(await fileExists(manifestPath))) {
+  console.log('[t3x-local:postinstall] No runtime manifest found. Skipping runtime download.');
+  process.exit(0);
+}
+
+const manifest = await readJson(manifestPath);
+await verifyInstalledVersionLock(packageDir, manifest);
+const platformKey = getPlatformKey();
+const artifact = manifest.platforms?.[platformKey];
+
+if (!artifact) {
+  throw new Error(`[t3x-local:postinstall] No runtime artifact configured for ${platformKey}`);
+}
+
+const runtimeDir = path.resolve(
+  process.env.T3X_LOCAL_RUNTIME_DIR ?? getDefaultInstalledRuntimeDir(packageDir)
+);
+const downloadSource = process.env.T3X_LOCAL_RUNTIME_MIRROR
+  ? resolveMirrorArtifactLocation(process.env.T3X_LOCAL_RUNTIME_MIRROR, artifact.fileName)
+  : artifact.url;
+
+if (!downloadSource) {
+  throw new Error(
+    '[t3x-local:postinstall] Runtime manifest did not contain a URL and no T3X_LOCAL_RUNTIME_MIRROR was provided.'
+  );
+}
+
+const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 't3x-local-postinstall-'));
+const archivePath = path.join(tempDir, artifact.fileName);
+
+try {
+  await downloadArtifact(downloadSource, archivePath);
+  await verifyArchiveSha(archivePath, artifact.sha256);
+
+  await fs.rm(runtimeDir, { recursive: true, force: true });
+  await ensureDir(runtimeDir);
+
+  const extractResult = spawnSync('tar', ['-xzf', archivePath, '-C', runtimeDir], {
+    stdio: 'inherit',
+  });
+
+  if (extractResult.status !== 0) {
+    throw new Error(
+      `[t3x-local:postinstall] tar extraction failed with exit code ${String(extractResult.status)}`
+    );
+  }
+
+  await assertRuntimeLayout(runtimeDir);
+  await ensurePackageNodeModulesLink(runtimeDir, packageDir);
+  await fs.writeFile(
+    path.join(runtimeDir, '.runtime-download.json'),
+    `${JSON.stringify(
+      {
+        packageVersion: manifest.packageVersion,
+        platform: platformKey,
+        source: downloadSource,
+        sha256: artifact.sha256,
+        installedAt: new Date().toISOString(),
+      },
+      null,
+      2
+    )}\n`,
+    'utf8'
+  );
+
+  console.log(`[t3x-local:postinstall] Runtime ready at ${runtimeDir}`);
+} finally {
+  await fs.rm(tempDir, { recursive: true, force: true });
+}
+
+async function downloadArtifact(source, destinationPath) {
+  if (source.startsWith('file://')) {
+    await fs.copyFile(new URL(source), destinationPath);
+    return;
+  }
+
+  if (source.startsWith('http://') || source.startsWith('https://')) {
+    const response = await fetch(source);
+
+    if (!response.ok) {
+      throw new Error(
+        `[t3x-local:postinstall] Failed to download runtime: HTTP ${response.status}`
+      );
+    }
+
+    const arrayBuffer = await response.arrayBuffer();
+    await fs.writeFile(destinationPath, new Uint8Array(arrayBuffer));
+    return;
+  }
+
+  await fs.copyFile(source, destinationPath);
+}
+
+async function verifyArchiveSha(archivePath, expectedSha) {
+  const file = await fs.readFile(archivePath);
+  const actualSha = crypto.createHash('sha256').update(file).digest('hex');
+
+  if (actualSha !== expectedSha) {
+    throw new Error(
+      `[t3x-local:postinstall] SHA256 mismatch for runtime archive. Expected ${expectedSha}, got ${actualSha}`
+    );
+  }
+}
+
+async function ensurePackageNodeModulesLink(runtimeDir, packageDir) {
+  const runtimeNodeModulesPath = path.join(runtimeDir, 'node_modules');
+  const packageNodeModulesPath = path.join(packageDir, 'node_modules');
+
+  if (!(await fileExists(packageNodeModulesPath))) {
+    return;
+  }
+
+  await fs.rm(runtimeNodeModulesPath, { recursive: true, force: true });
+  await fs.symlink(packageNodeModulesPath, runtimeNodeModulesPath, 'junction');
+}
+
+async function verifyInstalledVersionLock(packageDir, manifest) {
+  const packageJson = await readJson(path.join(packageDir, 'package.json'));
+  const expectedVersion = packageJson.version;
+  const problems = [];
+
+  for (const dependencyName of LOCAL_DIRECT_FIXED_DEPENDENCIES) {
+    const actual = packageJson.dependencies?.[dependencyName];
+
+    if (actual !== expectedVersion && actual !== `workspace:${expectedVersion}`) {
+      problems.push(
+        `package.json dependency ${dependencyName} must pin ${expectedVersion}, found ${actual ?? 'missing'}`
+      );
+    }
+  }
+
+  if (manifest.packageVersion !== expectedVersion) {
+    problems.push(
+      `runtime-manifest.json packageVersion must be ${expectedVersion}, found ${manifest.packageVersion ?? 'missing'}`
+    );
+  }
+
+  for (const packageName of FIXED_VERSION_PACKAGES) {
+    const manifestVersion = manifest.dependencies?.[packageName];
+    if (manifestVersion !== expectedVersion) {
+      problems.push(
+        `runtime-manifest.json dependency ${packageName} must be ${expectedVersion}, found ${manifestVersion ?? 'missing'}`
+      );
+    }
+  }
+
+  if (problems.length > 0) {
+    throw new Error(
+      '[t3x-local:postinstall] Fixed version verification failed.\n' +
+        problems.map((problem) => `- ${problem}`).join('\n')
+    );
+  }
+}

package/scripts/postpack-restore-package-json.mjs

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileExists, getLocalPackageDir } from './runtime-helpers.mjs';
+
+const packageDir = getLocalPackageDir();
+const packageJsonPath = path.join(packageDir, 'package.json');
+const backupPath = path.join(packageDir, '.pack-package.json.backup');
+
+if (!(await fileExists(backupPath))) {
+  console.log('[postpack] No package.json backup found. Nothing to restore.');
+  process.exit(0);
+}
+
+await fs.copyFile(backupPath, packageJsonPath);
+await fs.rm(backupPath, { force: true });
+console.log('[postpack] Restored apps/local/package.json');

package/scripts/prepack-rewrite-package-json.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+import path from 'node:path';
+import { getLocalPackageDir, readJson, writeJson } from './runtime-helpers.mjs';
+
+const packageDir = getLocalPackageDir();
+const repoRoot = path.resolve(packageDir, '../..');
+const backupPath = path.join(packageDir, '.pack-package.json.backup');
+const packageJsonPath = path.join(packageDir, 'package.json');
+
+const packageJson = await readJson(packageJsonPath);
+const resolvedVersions = {
+  '@t3x-dev/api': (await readJson(path.join(repoRoot, 'packages', 'api', 'package.json'))).version,
+  '@t3x-dev/cli': (await readJson(path.join(repoRoot, 'apps', 'cli', 'package.json'))).version,
+  '@t3x-dev/mcp': (await readJson(path.join(repoRoot, 'apps', 'mcp', 'package.json'))).version,
+  '@t3x-dev/storage': (await readJson(path.join(repoRoot, 'packages', 'storage', 'package.json')))
+    .version,
+};
+
+await writeJson(backupPath, packageJson);
+
+const rewrittenPackageJson = {
+  ...packageJson,
+  dependencies: {
+    ...packageJson.dependencies,
+    ...resolvedVersions,
+  },
+};
+
+await writeJson(packageJsonPath, rewrittenPackageJson);
+console.log('[prepack] Rewrote workspace dependencies in apps/local/package.json');

package/scripts/prepare-runtime.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  assertRuntimeLayout,
+  ensureDir,
+  fileExists,
+  getLocalPackageDir,
+  getPlatformKey,
+  getRepoRoot,
+  getRuntimeArtifactFileName,
+  getRuntimeArtifactsDir,
+  readJson,
+} from './runtime-helpers.mjs';
+
+const packageDir = getLocalPackageDir();
+const repoRoot = getRepoRoot();
+const localPackageJson = await readJson(path.join(packageDir, 'package.json'));
+const platformKey = process.env.T3X_LOCAL_RUNTIME_PLATFORM ?? getPlatformKey();
+const artifactDir = path.resolve(
+  process.env.T3X_LOCAL_RUNTIME_OUTPUT_DIR ?? getRuntimeArtifactsDir(packageDir)
+);
+const artifactFileName = getRuntimeArtifactFileName(localPackageJson.version, platformKey);
+const artifactPath = path.join(artifactDir, artifactFileName);
+const stagingDir = await fs.mkdtemp(path.join(os.tmpdir(), 't3x-local-runtime-'));
+
+const sources = {
+  apiDist: path.join(repoRoot, 'apps', 'api', 'dist'),
+  webStandalone: path.join(repoRoot, 'apps', 'web', '.next', 'standalone'),
+  webStatic: path.join(repoRoot, 'apps', 'web', '.next', 'static'),
+  webPublic: path.join(repoRoot, 'apps', 'web', 'public'),
+};
+
+const missingSources = [];
+for (const [label, sourcePath] of Object.entries(sources)) {
+  if (!(await fileExists(sourcePath))) {
+    missingSources.push(`${label}: ${sourcePath}`);
+  }
+}
+
+if (missingSources.length > 0) {
+  throw new Error(
+    'Missing runtime build outputs. Build API and Web before preparing the runtime tarball.\n' +
+      missingSources.join('\n')
+  );
+}
+
+try {
+  await ensureDir(path.join(stagingDir, 'api'));
+  await ensureDir(path.join(stagingDir, 'web'));
+  await ensureDir(artifactDir);
+
+  await fs.cp(sources.apiDist, path.join(stagingDir, 'api', 'dist'), { recursive: true });
+  await fs.cp(sources.webStandalone, path.join(stagingDir, 'web', 'standalone'), {
+    recursive: true,
+    verbatimSymlinks: true,
+  });
+  await fs.cp(sources.webStatic, path.join(stagingDir, 'web', 'static'), { recursive: true });
+  await fs.cp(sources.webPublic, path.join(stagingDir, 'web', 'public'), { recursive: true });
+
+  await assertRuntimeLayout(stagingDir);
+
+  const tarResult = spawnSync('tar', ['-czf', artifactPath, '-C', stagingDir, '.'], {
+    cwd: repoRoot,
+    stdio: 'inherit',
+  });
+
+  if (tarResult.status !== 0) {
+    throw new Error(`tar failed with exit code ${String(tarResult.status)}`);
+  }
+
+  console.log(`[prepare-runtime] Wrote ${artifactPath}`);
+} finally {
+  await fs.rm(stagingDir, { recursive: true, force: true });
+}

package/scripts/runtime-helpers.mjs

@@ -0,0 +1,115 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const SUPPORTED_RUNTIME_PATHS = [
+  path.join('api', 'dist', 'index.js'),
+  path.join('web', 'standalone', 'apps', 'web', 'server.js'),
+  path.join('web', 'static'),
+  path.join('web', 'public'),
+];
+
+export function getLocalPackageDir() {
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+}
+
+export function getRepoRoot() {
+  return path.resolve(getLocalPackageDir(), '../..');
+}
+
+export async function findWorkspaceRepoRoot(startDir) {
+  let current = path.resolve(startDir);
+
+  while (current !== path.dirname(current)) {
+    if (await fileExists(path.join(current, 'pnpm-workspace.yaml'))) {
+      return current;
+    }
+    current = path.dirname(current);
+  }
+
+  return null;
+}
+
+export function getPlatformKey() {
+  return `${process.platform}-${process.arch}`;
+}
+
+export function getRuntimeArtifactFileName(packageVersion, platformKey) {
+  return `t3x-local-runtime-${packageVersion}-${platformKey}.tar.gz`;
+}
+
+export function getRuntimeArtifactsDir(packageDir = getLocalPackageDir()) {
+  return path.join(packageDir, 'runtime-artifacts');
+}
+
+export function getRuntimeManifestPath(packageDir = getLocalPackageDir()) {
+  return path.join(packageDir, 'runtime-manifest.json');
+}
+
+export function getDefaultInstalledRuntimeDir(packageDir = getLocalPackageDir()) {
+  return path.join(packageDir, 'runtime', getPlatformKey());
+}
+
+export async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+export async function readJson(filePath) {
+  return JSON.parse(await fs.readFile(filePath, 'utf8'));
+}
+
+export async function writeJson(filePath, value) {
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+export async function sha256File(filePath) {
+  const hash = crypto.createHash('sha256');
+  const file = await fs.readFile(filePath);
+  hash.update(file);
+  return hash.digest('hex');
+}
+
+export async function statSize(filePath) {
+  const stat = await fs.stat(filePath);
+  return stat.size;
+}
+
+export async function assertRuntimeLayout(rootDir) {
+  const missing = [];
+
+  for (const relativePath of SUPPORTED_RUNTIME_PATHS) {
+    const absolutePath = path.join(rootDir, relativePath);
+    try {
+      await fs.access(absolutePath);
+    } catch {
+      missing.push(absolutePath);
+    }
+  }
+
+  if (missing.length > 0) {
+    throw new Error(`Runtime directory is missing required files:\n${missing.join('\n')}`);
+  }
+}
+
+export async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function resolveMirrorArtifactLocation(mirror, fileName) {
+  if (
+    mirror.startsWith('http://') ||
+    mirror.startsWith('https://') ||
+    mirror.startsWith('file://')
+  ) {
+    const base = mirror.endsWith('/') ? mirror : `${mirror}/`;
+    return new URL(fileName, base).toString();
+  }
+
+  return path.resolve(mirror, fileName);
+}