@aifabrix/builder 2.49.2 → 2.50.0

package/scripts/pnpm/lib/dev-reload-core.mjs

@@ -0,0 +1,189 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolveAifabrixBin } from './resolve-aifabrix-bin.mjs';
+import { resolveAppUrl } from './resolve-app-url.mjs';
+import { createSpinner } from './spinner.mjs';
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../..');
+const LOG_FILE = 'dev-reload.log';
+const CAPTURE_PID_FILE = 'dev-reload-capture.pid';
+
+/**
+ * @typedef {Object} DevReloadProfile
+ * @property {string} appKey
+ * @property {string} displayName
+ * @property {number} portBase
+ * @property {string} [webServerUrlEnvKey]
+ * @property {string} [healthPath]
+ * @property {boolean} [apiOnly]
+ * @property {string} [uiBuildCommand]
+ * @property {string} [uiOutputDir]
+ */
+
+/**
+ * @param {DevReloadProfile} profile
+ * @returns {Promise<void>}
+ */
+export async function runDevReload(profile) {
+  const logPath = prepareLogFile();
+  appendSessionBanner(profile.appKey, logPath);
+
+  const aifabrix = resolveAifabrixBin();
+  const spinner = createSpinner(`Starting ${profile.displayName} (live reload)…`);
+  spinner.start();
+
+  await runToLogFile(aifabrix, ['resolve', profile.appKey], logPath);
+  const runExit = await runToLogFile(aifabrix, ['run', profile.appKey, '--reload'], logPath);
+  if (runExit !== 0) {
+    spinner.stop();
+    printRunFailure(logPath);
+    process.exit(runExit);
+  }
+  spinner.stop();
+
+  startBackgroundLogCapture(profile.appKey, logPath);
+  printDevReloadSummary(profile, logPath);
+}
+
+/**
+ * @returns {string}
+ */
+function prepareLogFile() {
+  const logDir = path.join(repoRoot, '.temp');
+  fs.mkdirSync(logDir, { recursive: true });
+  const logPath = path.join(logDir, LOG_FILE);
+  fs.writeFileSync(logPath, '');
+  return logPath;
+}
+
+/**
+ * @returns {string}
+ */
+function capturePidPath() {
+  return path.join(repoRoot, '.temp', CAPTURE_PID_FILE);
+}
+
+function stopPreviousCapture() {
+  const pidPath = capturePidPath();
+  if (!fs.existsSync(pidPath)) {
+    return;
+  }
+  const pid = Number.parseInt(fs.readFileSync(pidPath, 'utf8').trim(), 10);
+  if (!pid) {
+    return;
+  }
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch {
+    // already stopped
+  }
+}
+
+/**
+ * @param {string} appKey
+ * @param {string} logPath
+ */
+function startBackgroundLogCapture(appKey, logPath) {
+  stopPreviousCapture();
+
+  const captureScript = path.join(
+    path.dirname(fileURLToPath(import.meta.url)),
+    'dev-reload-log-capture.mjs'
+  );
+  const child = spawn(process.execPath, [captureScript, appKey, logPath], {
+    cwd: repoRoot,
+    env: process.env,
+    detached: true,
+    stdio: 'ignore'
+  });
+  child.unref();
+  fs.writeFileSync(capturePidPath(), String(child.pid));
+}
+
+/**
+ * @param {DevReloadProfile} profile
+ * @param {string} logPath
+ */
+function printDevReloadSummary(profile, logPath) {
+  const appUrl = resolveAppUrl(profile, { repoRoot }).replace(/\/+$/, '');
+  const absLog = path.resolve(logPath);
+  const healthUrl = profile.healthPath ? `${appUrl}${profile.healthPath}` : `${appUrl}/`;
+
+  console.log('');
+  console.log('═'.repeat(60));
+  console.log(`  ${profile.displayName} — live reload (Docker)`);
+  console.log('═'.repeat(60));
+  console.log('');
+  console.log(`  App URL:  ${appUrl}/`);
+  if (profile.healthPath) {
+    console.log(`  Health:   ${healthUrl}`);
+  }
+  console.log(`  Logs:     ${absLog}`);
+  console.log('');
+  console.log('  Backend code on mounted paths reloads automatically.');
+  if (!profile.apiOnly && profile.uiBuildCommand && profile.uiOutputDir) {
+    console.log('');
+    console.log('  UI changes: run');
+    console.log(`    ${profile.uiBuildCommand}`);
+    console.log(`    → ${profile.uiOutputDir}`);
+  }
+  console.log('');
+  console.log('  Log capture runs in the background (this command exits).');
+  console.log('═'.repeat(60));
+  console.log('');
+}
+
+/**
+ * @param {string} logPath
+ */
+function printRunFailure(logPath) {
+  console.error(`\n[dev-reload] Start failed. Logs: ${path.resolve(logPath)}\n`);
+  if (!fs.existsSync(logPath)) {
+    return;
+  }
+  const lines = fs.readFileSync(logPath, 'utf8').trim().split('\n').filter(Boolean);
+  const tail = lines.slice(-15).join('\n');
+  if (tail) {
+    console.error(tail);
+    console.error('');
+  }
+}
+
+/**
+ * @param {string} appKey
+ * @param {string} logPath
+ */
+function appendSessionBanner(appKey, logPath) {
+  const banner =
+    `\n${'='.repeat(72)}\n` +
+    `[${new Date().toISOString()}] dev-reload session: ${appKey}\n` +
+    `${'='.repeat(72)}\n`;
+  fs.appendFileSync(logPath, banner);
+}
+
+/**
+ * @param {string} command
+ * @param {string[]} args
+ * @param {string} logPath
+ * @returns {Promise<number>}
+ */
+function runToLogFile(command, args, logPath) {
+  return new Promise((resolve) => {
+    const proc = spawn(command, args, {
+      cwd: repoRoot,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+
+    const append = (chunk) => {
+      fs.appendFileSync(logPath, chunk);
+    };
+
+    proc.stdout.on('data', append);
+    proc.stderr.on('data', append);
+    proc.on('close', (code) => resolve(typeof code === 'number' ? code : 1));
+    proc.on('error', () => resolve(1));
+  });
+}

package/scripts/pnpm/lib/dev-reload-log-capture.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/**
+ * Background log capture for dev-reload (detached child).
+ * Usage: node dev-reload-log-capture.mjs <appKey> <logPath>
+ */
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { resolveAifabrixBin } from './resolve-aifabrix-bin.mjs';
+import { resolveLogKeys } from './dev-reload-log-utils.mjs';
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../..');
+const appKey = process.argv[2];
+const logPath = process.argv[3];
+
+if (!appKey || !logPath) {
+  console.error('Usage: node dev-reload-log-capture.mjs <appKey> <logPath>');
+  process.exit(2);
+}
+
+const aifabrix = resolveAifabrixBin();
+const logKeys = resolveLogKeys(repoRoot, appKey);
+
+await Promise.all(
+  logKeys.map((key) => followAppLogsToFile(aifabrix, key, logPath, key === appKey))
+);
+
+/**
+ * @param {string} aifabrix
+ * @param {string} key
+ * @param {string} filePath
+ * @param {boolean} required
+ */
+function followAppLogsToFile(aifabrix, key, filePath, required) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(aifabrix, ['logs', key, '-f', '--tail', '100'], {
+      cwd: repoRoot,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+
+    const prefix = `[${key}] `;
+    const onLine = (line) => {
+      fs.appendFileSync(filePath, `${new Date().toISOString()} ${prefix}${line}\n`);
+    };
+
+    readline.createInterface({ input: proc.stdout }).on('line', onLine);
+    readline.createInterface({ input: proc.stderr }).on('line', onLine);
+
+    proc.on('close', (code) => {
+      if (code !== 0 && required) {
+        reject(new Error(`Log capture ended for ${key} (exit ${code ?? 1})`));
+        return;
+      }
+      resolve();
+    });
+    proc.on('error', (err) => {
+      if (required) {
+        reject(err);
+        return;
+      }
+      resolve();
+    });
+  });
+}

package/scripts/pnpm/lib/dev-reload-log-utils.mjs

@@ -0,0 +1,32 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * @param {string} repoRoot
+ * @param {string} appKey
+ * @returns {string[]}
+ */
+export function resolveLogKeys(repoRoot, appKey) {
+  return [appKey, ...readCompanionKeys(repoRoot, appKey)];
+}
+
+/**
+ * @param {string} repoRoot
+ * @param {string} appKey
+ * @returns {string[]}
+ */
+function readCompanionKeys(repoRoot, appKey) {
+  const yamlPath = path.join(repoRoot, 'builder', appKey, 'application.yaml');
+  if (!fs.existsSync(yamlPath)) {
+    return [];
+  }
+  const text = fs.readFileSync(yamlPath, 'utf8');
+  if (!/^\s*worker:\s*true\s*$/m.test(text)) {
+    return [];
+  }
+  const companions = [`${appKey}-worker`];
+  if (/^\s*imageRunBeat:/m.test(text)) {
+    companions.push(`${appKey}-beat`);
+  }
+  return companions;
+}

package/scripts/pnpm/lib/resolve-aifabrix-bin.mjs

@@ -0,0 +1,124 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../..');
+
+/** application.yaml / platform apps need manifest-aware builder (not variables.yaml-only CLIs). */
+const MIN_AIFABRIX_VERSION = '2.45.0';
+
+/**
+ * @param {string} version
+ * @returns {number[]}
+ */
+function parseSemver(version) {
+  return String(version)
+    .trim()
+    .split('.')
+    .map((part) => parseInt(part, 10) || 0);
+}
+
+/**
+ * @param {string} left
+ * @param {string} right
+ * @returns {number}
+ */
+function compareSemver(left, right) {
+  const a = parseSemver(left);
+  const b = parseSemver(right);
+  for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+    const av = a[i] || 0;
+    const bv = b[i] || 0;
+    if (av > bv) return 1;
+    if (av < bv) return -1;
+  }
+  return 0;
+}
+
+/**
+ * @param {string} bin
+ * @returns {string|null}
+ */
+function readAifabrixVersion(bin) {
+  try {
+    return execFileSync(bin, ['--version'], { encoding: 'utf8' }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @returns {string[]}
+ */
+function collectAifabrixCandidates() {
+  const candidates = [];
+  const seen = new Set();
+
+  const push = (candidate) => {
+    if (!candidate || seen.has(candidate)) {
+      return;
+    }
+    seen.add(candidate);
+    candidates.push(candidate);
+  };
+
+  push(path.join(repoRoot, 'bin', 'aifabrix.js'));
+
+  if (process.env.AIFABRIX_CLI) {
+    push(process.env.AIFABRIX_CLI);
+  }
+
+  const home = os.homedir();
+  push(path.join(home, '.npm-global', 'bin', 'aifabrix'));
+  push(path.join(home, '.local', 'bin', 'aifabrix'));
+
+  for (const dir of (process.env.PATH || '').split(path.delimiter)) {
+    if (!dir) continue;
+    push(path.join(dir, 'aifabrix'));
+  }
+
+  return candidates;
+}
+
+/**
+ * Prefer this repo's bin/aifabrix.js when developing the builder package locally.
+ *
+ * @returns {string}
+ */
+export function resolveAifabrixBin() {
+  let bestBin = null;
+  let bestVersion = null;
+
+  for (const candidate of collectAifabrixCandidates()) {
+    let resolved = candidate;
+    try {
+      if (fs.existsSync(candidate)) {
+        resolved = fs.realpathSync(candidate);
+      } else {
+        continue;
+      }
+    } catch {
+      continue;
+    }
+
+    const version = readAifabrixVersion(resolved);
+    if (!version) {
+      continue;
+    }
+    if (!bestVersion || compareSemver(version, bestVersion) > 0) {
+      bestBin = resolved;
+      bestVersion = version;
+    }
+  }
+
+  if (!bestBin || !bestVersion || compareSemver(bestVersion, MIN_AIFABRIX_VERSION) < 0) {
+    throw new Error(
+      `@aifabrix/builder >= ${MIN_AIFABRIX_VERSION} is required (found ${bestVersion || 'none'}). ` +
+        'Install: npm run install:local — or set AIFABRIX_CLI to a newer aifabrix binary.'
+    );
+  }
+
+  return bestBin;
+}

package/scripts/pnpm/lib/resolve-app-url.mjs

@@ -0,0 +1,183 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+/**
+ * @typedef {Object} AppUrlProfile
+ * @property {string} appKey
+ * @property {number} portBase
+ * @property {string} [webServerUrlEnvKey]
+ * @property {string} [healthPath]
+ */
+
+/**
+ * @returns {string}
+ */
+function readDeveloperIdRaw() {
+  const configPath = path.join(os.homedir(), '.aifabrix', 'config.yaml');
+  if (!fs.existsSync(configPath)) {
+    return '0';
+  }
+  const match = fs.readFileSync(configPath, 'utf8').match(/^developer-id:\s*['"]?(\d+)['"]?\s*$/m);
+  return match ? match[1] : '0';
+}
+
+/**
+ * @param {string} appKey
+ * @param {string} developerIdRaw
+ * @returns {string}
+ */
+function buildContainerName(appKey, developerIdRaw) {
+  const idNum = Number.parseInt(developerIdRaw, 10) || 0;
+  if (idNum === 0) {
+    return `aifabrix-${appKey}`;
+  }
+  return `aifabrix-dev${developerIdRaw}-${appKey}`;
+}
+
+/**
+ * @param {string} filePath
+ * @returns {Record<string, string>}
+ */
+function parseEnvFile(filePath) {
+  const values = {};
+  for (const line of fs.readFileSync(filePath, 'utf8').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) {
+      continue;
+    }
+    const eq = trimmed.indexOf('=');
+    if (eq === -1) {
+      continue;
+    }
+    const key = trimmed.slice(0, eq).trim();
+    let value = trimmed.slice(eq + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    values[key] = value;
+  }
+  return values;
+}
+
+/**
+ * @param {string} raw
+ * @returns {string|null}
+ */
+function normalizeHttpUrl(raw) {
+  const trimmed = raw?.trim();
+  if (!trimmed || trimmed.startsWith('kv://')) {
+    return null;
+  }
+  try {
+    const parsed = new URL(trimmed);
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+      return null;
+    }
+    return parsed.toString().replace(/\/+$/, '');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {string} repoRoot
+ * @param {string} appKey
+ * @param {string} envKey
+ * @returns {string|null}
+ */
+function readBuilderEnvUrl(repoRoot, appKey, envKey) {
+  const envPath = path.join(repoRoot, 'builder', appKey, '.env');
+  if (!fs.existsSync(envPath)) {
+    return null;
+  }
+  return normalizeHttpUrl(parseEnvFile(envPath)[envKey]);
+}
+
+/**
+ * @param {string} containerName
+ * @param {string} envKey
+ * @returns {string|null}
+ */
+function readContainerEnvUrl(containerName, envKey) {
+  const result = spawnSync('docker', ['exec', containerName, 'env'], {
+    encoding: 'utf8',
+    timeout: 8000
+  });
+  if (result.status !== 0) {
+    return null;
+  }
+  for (const line of result.stdout.split('\n')) {
+    if (!line.startsWith(`${envKey}=`)) {
+      continue;
+    }
+    return normalizeHttpUrl(line.slice(envKey.length + 1));
+  }
+  return null;
+}
+
+/**
+ * @param {string} containerName
+ * @returns {string|null}
+ */
+function readDockerPublishedUrl(containerName) {
+  const result = spawnSync(
+    'docker',
+    ['ps', '--filter', `name=^/${containerName}$`, '--format', '{{.Ports}}'],
+    { encoding: 'utf8', timeout: 8000 }
+  );
+  if (result.status !== 0) {
+    return null;
+  }
+  const portMatch = result.stdout.match(/:(\d+)->\d+\//);
+  if (!portMatch) {
+    return null;
+  }
+  return `http://localhost:${portMatch[1]}`;
+}
+
+/**
+ * @param {number} portBase
+ * @returns {number}
+ */
+function resolveHostPort(portBase) {
+  const devId = Number.parseInt(readDeveloperIdRaw(), 10) || 0;
+  return devId === 0 ? portBase : portBase + devId * 100;
+}
+
+/**
+ * @param {AppUrlProfile} profile
+ * @param {{ repoRoot: string }} options
+ * @returns {string}
+ */
+export function resolveAppUrl(profile, options) {
+  const { repoRoot } = options;
+  const envKey = profile.webServerUrlEnvKey;
+  const containerName = buildContainerName(profile.appKey, readDeveloperIdRaw());
+
+  if (envKey) {
+    const fromContainer = readContainerEnvUrl(containerName, envKey);
+    if (fromContainer) {
+      return `${fromContainer}/`;
+    }
+  }
+
+  const fromDockerPort = readDockerPublishedUrl(containerName);
+  if (fromDockerPort) {
+    return `${fromDockerPort}/`;
+  }
+
+  if (envKey) {
+    const fromBuilderEnv = readBuilderEnvUrl(repoRoot, profile.appKey, envKey);
+    if (fromBuilderEnv) {
+      return `${fromBuilderEnv}/`;
+    }
+  }
+
+  const port = resolveHostPort(profile.portBase);
+  return `http://localhost:${port}/`;
+}

package/scripts/pnpm/lib/spinner.mjs

@@ -0,0 +1,42 @@
+/** Minimal TTY spinner (no extra dependencies). */
+
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+/**
+ * @param {string} label
+ * @returns {{ start: () => void, stop: (finalLine?: string) => void }}
+ */
+export function createSpinner(label) {
+  let frameIndex = 0;
+  /** @type {NodeJS.Timeout | null} */
+  let timer = null;
+  const enabled = process.stdout.isTTY && process.env.CI !== 'true';
+
+  function clearLine() {
+    if (enabled) {
+      process.stdout.write('\r\x1b[K');
+    }
+  }
+
+  return {
+    start() {
+      if (!enabled) {
+        console.log(label);
+        return;
+      }
+      timer = setInterval(() => {
+        process.stdout.write(`\r${FRAMES[frameIndex++ % FRAMES.length]} ${label}`);
+      }, 80);
+    },
+    stop(finalLine) {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      clearLine();
+      if (finalLine) {
+        console.log(finalLine);
+      }
+    }
+  };
+}

package/scripts/stage_builder_api_for_docker.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+/**
+ * Stage builder-api runtime files for Docker image build (plan 154.3).
+ *
+ * @fileoverview Host-side staging before `docker build`
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const {
+  discoverRuntimeFiles,
+  findManifestViolations
+} = require('./lib/builder-api-docker-staging-core');
+const { stageFiles } = require('./lib/builder-api-docker-staging-copy');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+
+/**
+ * @param {string[]} argv
+ * @returns {number}
+ */
+function main(argv) {
+  const args = argv.slice(2);
+  let destination = path.join(REPO_ROOT, 'docker-builder-api-staging');
+  let manifestPath = '';
+
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === '--destination' && args[i + 1]) {
+      destination = path.resolve(args[i + 1]);
+      i += 1;
+    } else if (args[i] === '--manifest' && args[i + 1]) {
+      manifestPath = path.resolve(args[i + 1]);
+      i += 1;
+    }
+  }
+
+  const manifest = discoverRuntimeFiles(REPO_ROOT);
+  const violations = findManifestViolations(manifest);
+  if (violations.length > 0) {
+    console.error('Staging manifest contains forbidden paths:');
+    for (const item of violations) {
+      console.error(`  - ${item}`);
+    }
+    return 1;
+  }
+
+  const staged = stageFiles(REPO_ROOT, destination, manifest);
+  if (manifestPath) {
+    fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+    fs.writeFileSync(manifestPath, `${JSON.stringify(staged, null, 2)}\n`, 'utf8');
+  }
+
+  console.log(`OK: staged ${staged.length} files → ${destination}`);
+  return 0;
+}
+
+if (require.main === module) {
+  process.exit(main(process.argv));
+}
+
+module.exports = { main };