@fugood/bricks-ctor 2.25.0-beta.60 → 2.25.0-beta.62

package/tools/pull.ts

@@ -1,199 +1,4 @@
-import { mkdir, readdir, readFile, unlink, writeFile } from 'node:fs/promises'
-import { existsSync } from 'node:fs'
-import { dirname, join, relative } from 'node:path'
-import { format } from 'oxfmt'
-import { sh } from './_shell'
-import { extractCliErrorMessage } from './_cli-error'
-import { buildCommitArgs } from './_git-author'
-import { readLastPushedCommit, writeLastPushedCommit } from './_last-pushed-commit'
+#!/usr/bin/env bun
+import { forwardLegacyCtorTool } from './_forward.ts'
 
-// Directories whose .ts contents are entirely owned by the generator.
-// Anything under these dirs not present in the freshly pulled file list is an orphan.
-const ownedTsDirs = ['subspaces', 'automation-tests']
-
-async function walkTsFiles(dir: string, baseDir: string): Promise<string[]> {
-  if (!existsSync(dir)) return []
-  const result: string[] = []
-  const entries = await readdir(dir, { withFileTypes: true })
-  await Promise.all(
-    entries.map(async (entry) => {
-      const full = join(dir, entry.name)
-      if (entry.isDirectory()) {
-        result.push(...(await walkTsFiles(full, baseDir)))
-      } else if (entry.isFile() && entry.name.endsWith('.ts')) {
-        result.push(relative(baseDir, full))
-      }
-    }),
-  )
-  return result
-}
-
-const cwd = process.cwd()
-const args = process.argv.slice(2)
-const force = args.includes('--force') || args.includes('-f')
-
-// Check git status
-const { exitCode } = await sh`cd ${cwd} && git status`.nothrow()
-const isGitRepo = exitCode === 0
-
-if (isGitRepo) {
-  const unstagedChanges = await sh`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
-  if (unstagedChanges) {
-    if (force) {
-      console.log('Force mode: committing unstaged changes before pull...')
-      await sh`cd ${cwd} && git add .`
-      const preCommitArgs = await buildCommitArgs(cwd, [
-        'chore(force-pull): saved unstaged changes before pull',
-      ])
-      await sh`cd ${cwd} && git ${preCommitArgs}`
-    } else {
-      throw new Error('Unstaged changes found, please commit or stash your changes before pulling')
-    }
-  }
-} else {
-  const confirmContinue = prompt(
-    'No git repository found, so it will not be safe to pull, continue? (y/n)',
-  )
-  if (confirmContinue !== 'y') throw new Error('Pull cancelled')
-}
-
-// Read application.json
-const app = JSON.parse(await readFile(`${cwd}/application.json`, 'utf8'))
-
-const isModule = app.type === 'module'
-const command = isModule ? 'module' : 'app'
-
-// Fetch project files using CLI
-console.log(`Pulling ${command} project (${app.id})...`)
-const result = await sh`bricks ${command} project-pull ${app.id} --json`.quiet().nothrow()
-
-if (result.exitCode !== 0) {
-  const output = result.stderr.toString() || result.stdout.toString()
-  throw new Error(extractCliErrorMessage(output, 'Pull failed'))
-}
-
-const { files, lastCommitId: serverLastCommitId } = JSON.parse(result.stdout.toString())
-
-// The locally-saved commit (recorded by deploy/push-config) is the
-// authoritative merge base for THIS clone — the server's value can be an
-// opaque nanoid (config-only updates) or point to a commit other clients
-// produced. Fall back to the server's value only if we have no local
-// record yet.
-const savedLocalCommitId = await readLastPushedCommit(cwd)
-const baseCommitId = savedLocalCommitId || serverLastCommitId
-
-const branchName = isModule
-  ? 'BRICKS_PROJECT_try-pull-module'
-  : 'BRICKS_PROJECT_try-pull-application'
-
-let landingBranch = ''
-if (isGitRepo && !force) {
-  landingBranch = (await sh`cd ${cwd} && git branch --show-current`.text()).trim()
-  if (!landingBranch) throw new Error('Cannot pull from a detached HEAD')
-
-  console.log(`Checking commit ${baseCommitId}...`)
-  const found = (await sh`cd ${cwd} && git rev-list -1 ${baseCommitId}`.nothrow().text())
-    .trim()
-    .match(/^[\da-f]{40}$/)
-
-  const headCommitId = (await sh`cd ${cwd} && git rev-parse HEAD`.text()).trim()
-
-  if (headCommitId === serverLastCommitId) throw new Error('Commit not changed')
-
-  await sh`cd ${cwd} && git branch -D ${branchName}`.nothrow()
-
-  // When the base commit isn't reachable in this clone (server stored a
-  // nanoid, or the commit was pruned), fall back to forking from current
-  // HEAD. The downstream merge into the starting branch collapses both paths
-  // into the same result, just with different merge bases.
-  if (found) {
-    await sh`cd ${cwd} && git checkout -b ${branchName} ${baseCommitId}`.nothrow()
-  } else {
-    await sh`cd ${cwd} && git checkout -b ${branchName}`
-  }
-}
-
-const oxfmtConfig = await readFile(`${cwd}/.oxfmtrc.json`, 'utf8')
-  .then(JSON.parse)
-  .catch(() => ({
-    trailingComma: 'all',
-    tabWidth: 2,
-    semi: false,
-    singleQuote: true,
-    printWidth: 100,
-  }))
-
-const expectedFiles = new Set(files.map((file: { name: string }) => file.name))
-
-// Remove orphan .ts files under generator-owned directories before writing.
-// File paths are produced by buildApplicationFiles and use forward slashes,
-// so normalise the walked paths the same way for comparison.
-const orphans: string[] = []
-await Promise.all(
-  ownedTsDirs.map(async (dir) => {
-    const existing = await walkTsFiles(join(cwd, dir), cwd)
-    for (const file of existing) {
-      const normalized = file.split(/[\\/]/).join('/')
-      if (!expectedFiles.has(normalized)) orphans.push(normalized)
-    }
-  }),
-)
-await Promise.all(orphans.map((name) => unlink(`${cwd}/${name}`)))
-
-await Promise.all(
-  files.map(async (file: { name: string; input: string; formatable?: boolean }) => {
-    let content = file.input
-    if (file.formatable) {
-      const result = await format(file.name, file.input, oxfmtConfig)
-      content = result.code
-    }
-    const target = join(cwd, file.name)
-    await mkdir(dirname(target), { recursive: true })
-    return writeFile(target, content)
-  }),
-)
-
-if (isGitRepo) {
-  await sh`cd ${cwd} && git add .`
-  const hasChanges = !!(await sh`cd ${cwd} && git diff --cached --name-only`.text()).trim()
-  if (hasChanges) {
-    const commitMsg = force
-      ? `chore(force-pull): apply force pull-${command}`
-      : isModule
-        ? 'chore(project): apply file changes from BRICKS module'
-        : 'chore(project): apply file changes from BRICKS application'
-    const commitArgs = await buildCommitArgs(cwd, [commitMsg])
-    await sh`cd ${cwd} && git ${commitArgs}`
-  }
-  if (!force) {
-    // Land the pulled commits on the starting branch with a single 3-way merge using
-    // baseCommit as the merge base. The user doesn't have to manage a side
-    // branch, and conflicts (if any) land in the working tree on the starting branch where
-    // auto-compile surfaces them as typecheck errors to resolve in-place.
-    await sh`cd ${cwd} && git checkout ${landingBranch}`
-    const mergeResult = await sh`cd ${cwd} && git merge ${branchName} --no-edit`.nothrow()
-    if (mergeResult.exitCode !== 0) {
-      // Conflict markers are in the working tree — commit them so the tree
-      // is clean for auto-compile to detect, leaving the resolution to the
-      // user. Pre-commit hooks would reject markers (lint/format fail on
-      // invalid syntax), so bypass them for this controlled case.
-      await sh`cd ${cwd} && git add .`
-      const conflictArgs = await buildCommitArgs(
-        cwd,
-        [`chore(project): merge with conflicts (resolve in ${landingBranch})`],
-        ['--no-verify'],
-      )
-      await sh`cd ${cwd} && git ${conflictArgs}`
-    }
-    // The try-pull branch served its purpose; delete it so `git branch`
-    // stays tidy. The next pull recreates it anyway (line 103).
-    await sh`cd ${cwd} && git branch -D ${branchName}`.nothrow()
-  }
-  // Record the new sync point so a follow-up pull starts from the right base.
-  const newHead = (await sh`cd ${cwd} && git rev-parse HEAD`.nothrow().text()).trim()
-  if (newHead) await writeLastPushedCommit(cwd, newHead)
-}
-
-console.log(
-  `${isModule ? 'Module' : 'App'} project pulled: ${files.length} files${orphans.length ? `, removed ${orphans.length} orphan .ts file${orphans.length === 1 ? '' : 's'}` : ''}${force ? ' (force)' : ''}`,
-)
+forwardLegacyCtorTool('pull', import.meta.url)

package/tools/push-config.ts

@@ -1,114 +1,4 @@
-import { readFile, writeFile } from 'node:fs/promises'
-import { parseArgs } from 'util'
-import { sh } from './_shell'
-import { extractCliErrorMessage } from './_cli-error'
-import { buildCommitArgs } from './_git-author'
-import { writeLastPushedCommit } from './_last-pushed-commit'
+#!/usr/bin/env bun
+import { forwardLegacyCtorTool } from './_forward.ts'
 
-const cwd = process.cwd()
-
-const readJson = async (p: string) => JSON.parse(await readFile(p, 'utf8'))
-
-const {
-  values: { 'auto-commit': autoCommit, 'no-check': noCheck, 'no-validate': noValidate, yes, help },
-} = parseArgs({
-  args: process.argv.slice(2),
-  options: {
-    'auto-commit': { type: 'boolean' },
-    'no-check': { type: 'boolean' },
-    'no-validate': { type: 'boolean' },
-    yes: { type: 'boolean', short: 'y' },
-    help: { type: 'boolean', short: 'h' },
-  },
-  allowPositionals: true,
-})
-
-if (help) {
-  console.log(`Push compiled config to BRICKS without creating a release.
-
-Options:
-  --auto-commit              Auto-commit unstaged changes before pushing
-  --no-check                 Skip the conflict guard (don't pass --last-commit-id)
-  --no-validate              Skip server-side config schema validation
-  -y, --yes                  Skip all prompts
-  -h, --help                 Show this help message`)
-  process.exit(0)
-}
-
-// Detect git repo (mirrors deploy.ts)
-const { exitCode } = await sh`cd ${cwd} && git status`.quiet().nothrow()
-const isGitRepo = exitCode === 0
-
-if (!isGitRepo && !yes) {
-  const confirmContinue = prompt('No git repository found, continue? (y/n)')
-  if (confirmContinue !== 'y') throw new Error('Update cancelled')
-}
-
-// Read application.json + compiled config
-const app = await readJson(`${cwd}/application.json`)
-const config = await readJson(`${cwd}/.bricks/build/application-config.json`)
-
-// Handle unstaged changes the same way deploy.ts does.
-let commitId = ''
-let parentCommitId = ''
-if (isGitRepo) {
-  const unstagedChanges = await sh`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
-  if (unstagedChanges) {
-    if (autoCommit) {
-      // Capture the pre-commit HEAD so we can use it as the conflict-check
-      // baseline (the server should still hold it from the prior deploy).
-      parentCommitId = (await sh`cd ${cwd} && git rev-parse HEAD`.nothrow().text()).trim()
-      await sh`cd ${cwd} && git add -A`
-      const commitArgs = await buildCommitArgs(cwd, ['chore: update bricks config'])
-      await sh`cd ${cwd} && git ${commitArgs}`
-    } else {
-      throw new Error('Unstaged changes found, please commit or stash your changes before updating')
-    }
-  }
-  commitId = (await sh`cd ${cwd} && git rev-parse HEAD`.text()).trim()
-}
-
-// Auto-derive --last-commit-id for the server-side conflict guard.
-//   - parent of the auto-commit (server still holds it from the prior deploy)
-//   - current HEAD (clean tree — server should be at the same commit too)
-let lastCommitId: string | undefined
-if (!noCheck) {
-  if (parentCommitId) lastCommitId = parentCommitId
-  else if (commitId) lastCommitId = commitId
-}
-
-if (!yes) {
-  const confirm = prompt('Are you sure you want to push the new config? (y/n)')
-  if (confirm !== 'y') throw new Error('Update cancelled')
-}
-
-const isModule = app.type === 'module'
-const command = isModule ? 'module' : 'app'
-
-const updateConfig = {
-  ...config,
-  bricks_project_last_commit_id: commitId || undefined,
-}
-const configPath = `${cwd}/.bricks/build/push-config.json`
-await writeFile(configPath, JSON.stringify(updateConfig))
-
-const args = ['bricks', command, 'update', app.id, '-f', configPath, '--json']
-if (noValidate) args.push('--no-validate')
-if (lastCommitId) args.push('--last-commit-id', lastCommitId)
-
-const result = await sh`${args}`.quiet().nothrow()
-
-if (result.exitCode !== 0) {
-  const output = result.stderr.toString() || result.stdout.toString()
-  throw new Error(extractCliErrorMessage(output, 'Update failed'))
-}
-
-const output = JSON.parse(result.stdout.toString())
-
-// Record the commit we just pushed from so a later pull can use it as the
-// merge base regardless of what the server stores in
-// bricks_project_last_commit_id (which may be an opaque nanoid for
-// content-only edits).
-if (commitId) await writeLastPushedCommit(cwd, commitId)
-
-console.log(`${isModule ? 'Module' : 'App'} config updated: ${output.target?.name || app.name}`)
+forwardLegacyCtorTool('push', import.meta.url)

package/tools/simulator.ts

@@ -1,150 +1,4 @@
-import { spawn } from 'node:child_process'
-import { readFile, writeFile } from 'node:fs/promises'
-import { watch, unlinkSync } from 'fs'
-import type { FSWatcher } from 'fs'
-import { createInterface } from 'node:readline'
-import { parseArgs } from 'util'
-import debounce from 'lodash/debounce'
-import { sh } from './_shell'
+#!/usr/bin/env bun
+import { forwardLegacyCtorTool } from './_forward.ts'
 
-const { values } = parseArgs({
-  args: process.argv,
-  options: {
-    'skip-typecheck': { type: 'boolean' },
-    'clear-cache': { type: 'boolean' },
-    screenshot: { type: 'boolean' },
-    'screenshot-delay': { type: 'string' },
-    'screenshot-width': { type: 'string' },
-    'screenshot-height': { type: 'string' },
-    'screenshot-path': { type: 'string' },
-    'screenshot-no-headless': { type: 'boolean' },
-    'show-menu': { type: 'boolean' },
-    'test-id': { type: 'string' },
-    'test-title-like': { type: 'string' },
-    'no-keep-open': { type: 'boolean' },
-    'cdp-port': { type: 'string' },
-    'no-cdp': { type: 'boolean' },
-  },
-  strict: true,
-  allowPositionals: true,
-})
-
-const cwd = process.cwd()
-
-const app = JSON.parse(await readFile(`${cwd}/application.json`, 'utf8'))
-
-const args: string[] = []
-if (values['clear-cache']) args.push('--clear-cache')
-
-let needWatcher = true
-if (values['screenshot']) {
-  args.push(`--take-screenshot`)
-  args.push(
-    JSON.stringify({
-      delay: Number(values['screenshot-delay']) || 1000,
-      width: Number(values['screenshot-width']) || 600,
-      height: Number(values['screenshot-height']) || 480,
-      path: values['screenshot-path'] || `${cwd}/screenshot.jpg`,
-      noHeadless: values['screenshot-no-headless'] ?? false,
-    }),
-  )
-  needWatcher = !values['no-keep-open']
-}
-
-if (values['show-menu']) {
-  args.push('--show-menu')
-}
-
-if (values['test-id']) {
-  args.push('--test-id', values['test-id'])
-}
-
-if (values['test-title-like']) {
-  args.push('--test-title-like', values['test-title-like'])
-}
-
-if (values['no-keep-open']) {
-  args.push('--no-keep-open')
-}
-
-if (!values['no-cdp']) {
-  const cdpPort = parseInt(values['cdp-port'] || '', 10) || 19852
-  args.push('--cdp-port', String(cdpPort))
-}
-
-const useTypecheck = !values['skip-typecheck']
-
-const compile = async () => {
-  if (useTypecheck) await sh`bun typecheck`
-  await sh`bun compile.ts`
-}
-
-await compile()
-
-let watcher: FSWatcher | null = null
-if (needWatcher) {
-  const compileDebounced = debounce(compile, 500)
-  watcher = watch(`${cwd}/subspaces`, { recursive: true }, async (event, filename) => {
-    console.log(`Detected ${event} in ${filename}`)
-    compileDebounced()
-  })
-}
-
-const devtoolsInfoPath = `${cwd}/.bricks/devtools.json`
-
-const cleanupDevtoolsInfo = () => {
-  try {
-    unlinkSync(devtoolsInfoPath)
-  } catch {}
-}
-
-// Kill existing simulator process if devtools.json contains a stale pid
-try {
-  const devtoolsInfo = JSON.parse(await readFile(devtoolsInfoPath, 'utf8'))
-  if (devtoolsInfo.pid) {
-    try {
-      process.kill(devtoolsInfo.pid)
-    } catch {}
-    cleanupDevtoolsInfo()
-  }
-} catch {}
-
-const proc = spawn(
-  'bunx',
-  ['--bun', 'electron', `${import.meta.dirname}/simulator-main.mjs`, ...args],
-  {
-    env: { ...process.env, BRICKS_STAGE: app.stage || 'production' },
-    stdio: ['inherit', 'pipe', 'inherit'],
-  },
-)
-
-const rl = createInterface({ input: proc.stdout! })
-
-rl.on('line', (line) => {
-  if (line.startsWith('[TEST_RESULT_TOON]')) {
-    const toonData = line.replace('[TEST_RESULT_TOON]', '')
-    console.log(toonData)
-    return
-  }
-  if (!line) return
-  // Detect CDP server startup from simulator-main output
-  const cdpMatch = line.match(/^CDP server: ws:\/\/localhost:(\d+)/)
-  if (cdpMatch) {
-    const info = {
-      port: parseInt(cdpMatch[1], 10),
-      pid: proc.pid,
-      address: 'localhost',
-      name: `${app.name || 'Unnamed'} (CTOR Simulator)`,
-      startedAt: new Date().toISOString(),
-    }
-    writeFile(devtoolsInfoPath, JSON.stringify(info, null, 2))
-  }
-  console.log(line)
-})
-
-await new Promise<void>((resolve) => {
-  proc.on('close', () => resolve())
-})
-
-cleanupDevtoolsInfo()
-if (watcher) watcher.close()
+forwardLegacyCtorTool('simulator', import.meta.url)

package/compile/__tests__/config-diff.test.js

@@ -1,100 +0,0 @@
-import { computeConfigChange } from '../config-diff'
-
-describe('computeConfigChange', () => {
-  test('ignores the volatile top-level title and update_timestamp', () => {
-    const before = { title: 'App(1)', update_timestamp: 1, subspace_map: {} }
-    const after = { title: 'App(2)', update_timestamp: 2, subspace_map: {} }
-    expect(computeConfigChange(before, after)).toEqual({ status: 'ok', ops: [], opCount: 0 })
-  })
-
-  test('still diffs nested (subspace/brick) titles', () => {
-    const before = { title: 'App(1)', subspace_map: { S: { title: 'Home' } } }
-    const after = { title: 'App(2)', subspace_map: { S: { title: 'Start' } } }
-    expect(computeConfigChange(before, after).ops).toEqual([
-      { op: 'set', path: ['subspace_map', 'S', 'title'], value: 'Start' },
-    ])
-  })
-
-  test('emits a leaf set for a scalar property change', () => {
-    const wrap = (url) => ({ subspace_map: { S: { brick_map: { B: { property: { url } } } } } })
-    expect(computeConfigChange(wrap('a'), wrap('b')).ops).toEqual([
-      { op: 'set', path: ['subspace_map', 'S', 'brick_map', 'B', 'property', 'url'], value: 'b' },
-    ])
-  })
-
-  test('added key → set, removed key → unset', () => {
-    const change = computeConfigChange({ m: { a: 1 } }, { m: { b: 2 } })
-    expect(change.opCount).toBe(2)
-    expect(change.ops).toContainEqual({ op: 'unset', path: ['m', 'a'] })
-    expect(change.ops).toContainEqual({ op: 'set', path: ['m', 'b'], value: 2 })
-  })
-
-  test('equal-length arrays diff element-wise', () => {
-    const before = { items: [{ x: 1 }, { x: 2 }] }
-    const after = { items: [{ x: 1 }, { x: 9 }] }
-    expect(computeConfigChange(before, after).ops).toEqual([
-      { op: 'set', path: ['items', 1, 'x'], value: 9 },
-    ])
-  })
-
-  test('length-changed arrays emit a single whole-array set', () => {
-    const before = { items: [1, 2] }
-    const after = { items: [1, 2, 3] }
-    expect(computeConfigChange(before, after).ops).toEqual([
-      { op: 'set', path: ['items'], value: [1, 2, 3] },
-    ])
-  })
-
-  test('identical configs produce no ops', () => {
-    const config = { subspace_map: { S: { brick_map: { B: { property: { a: 1, b: [1, 2] } } } } } }
-    expect(computeConfigChange(config, structuredClone(config))).toEqual({
-      status: 'ok',
-      ops: [],
-      opCount: 0,
-    })
-  })
-
-  test('ignores object fields omitted by JSON.stringify', () => {
-    const before = { subspace_map: { S: { title: 'Home' } } }
-    const after = {
-      subspace_map: {
-        S: {
-          title: 'Home',
-          description: undefined,
-        },
-      },
-    }
-    expect(computeConfigChange(before, after)).toEqual({ status: 'ok', ops: [], opCount: 0 })
-  })
-
-  test('emits added values in JSON-compatible shape', () => {
-    const before = { m: {} }
-    const after = {
-      m: {
-        nested: {
-          keep: 1,
-          drop: undefined,
-        },
-        items: [undefined, 2],
-      },
-    }
-    const change = computeConfigChange(before, after)
-    expect(change.ops).toEqual([
-      { op: 'set', path: ['m', 'nested'], value: { keep: 1 } },
-      { op: 'set', path: ['m', 'items'], value: [null, 2] },
-    ])
-  })
-
-  test('compares array undefined entries like JSON nulls', () => {
-    expect(computeConfigChange({ items: [null] }, { items: [undefined] })).toEqual({
-      status: 'ok',
-      ops: [],
-      opCount: 0,
-    })
-  })
-
-  test('reports no_baseline / unavailable for missing sides', () => {
-    expect(computeConfigChange(null, { a: 1 })).toEqual({ status: 'no_baseline' })
-    expect(computeConfigChange({ a: 1 }, null)).toEqual({ status: 'unavailable' })
-  })
-})