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

package/package.json

@@ -1,33 +1,9 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.60",
-  "main": "index.ts",
-  "scripts": {
-    "typecheck": "tsc --noEmit",
-    "build": "bun scripts/build.js"
-  },
+  "version": "2.25.0-beta.62",
+  "description": "Deprecated: ctor tooling moved to the `bricks ctor` commands in @fugood/bricks-cli. This package now only forwards legacy project scripts and triggers migration.",
   "dependencies": {
-    "@babel/generator": "7.28.5",
-    "@babel/parser": "7.28.5",
-    "@babel/traverse": "7.28.5",
-    "@babel/types": "7.28.5",
-    "@fugood/bricks-cli": "^2.25.0-beta.60",
-    "@huggingface/gguf": "^0.3.2",
-    "@iarna/toml": "^3.0.0",
-    "@modelcontextprotocol/sdk": "^1.15.0",
-    "@toon-format/toon": "^2.1.0",
-    "@types/bun": "^1.3.9",
-    "@types/escodegen": "^0.0.10",
-    "@types/lodash": "^4.17.12",
-    "acorn": "^8.13.0",
-    "escodegen": "2.1.0",
-    "fuse.js": "^7.0.0",
-    "json5": "^2.0.1",
-    "lodash": "^4.17.4",
-    "uuid": "^8.3.1"
-  },
-  "peerDependencies": {
-    "oxfmt": "^0.36.0"
+    "@fugood/bricks-cli": "^2.25.0-beta.62"
   },
-  "gitHead": "c0dd2ea071f45382808ad55acfc9837217d683ca"
+  "gitHead": "22ea0986230856c59dbf9acccc63bdc4fd97deed"
 }

package/tools/__tests__/legacy-forwarder.test.js

@@ -0,0 +1,91 @@
+const mockSpawnSync = jest.fn()
+const mockExistsSync = jest.fn()
+
+jest.mock('node:child_process', () => ({
+  __esModule: true,
+  spawnSync: (...args) => mockSpawnSync(...args),
+}))
+
+jest.mock('node:fs', () => ({
+  __esModule: true,
+  existsSync: (...args) => mockExistsSync(...args),
+}))
+
+const loadForwarder = () => require('../_forward.ts')
+
+describe('legacy bricks-ctor forwarder', () => {
+  let exitSpy
+  let errorSpy
+
+  beforeEach(() => {
+    jest.resetModules()
+    mockSpawnSync.mockReset()
+    mockExistsSync.mockReset()
+    exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {})
+    errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    exitSpy.mockRestore()
+    errorSpy.mockRestore()
+  })
+
+  it('prefers the local bricks CLI next to the legacy package', () => {
+    mockExistsSync.mockReturnValue(true)
+    mockSpawnSync.mockReturnValue({ status: 0 })
+    const { forwardLegacyCtorTool } = loadForwarder()
+
+    forwardLegacyCtorTool(
+      'deploy',
+      'file:///repo/node_modules/@fugood/bricks-ctor/tools/deploy.ts',
+      ['--target', 'device'],
+    )
+
+    expect(mockSpawnSync).toHaveBeenCalledWith(
+      '/repo/node_modules/.bin/bricks',
+      ['ctor', 'deploy', '--target', 'device'],
+      { stdio: 'inherit' },
+    )
+    expect(exitSpy).toHaveBeenCalledWith(0)
+  })
+
+  it('falls back to PATH when the local bricks CLI is missing', () => {
+    mockExistsSync.mockReturnValue(false)
+    mockSpawnSync.mockReturnValue({ status: 3 })
+    const { forwardLegacyCtorTool } = loadForwarder()
+
+    forwardLegacyCtorTool('pull', 'file:///repo/node_modules/@fugood/bricks-ctor/tools/pull.ts', [])
+
+    expect(mockSpawnSync).toHaveBeenCalledWith('bricks', ['ctor', 'pull'], { stdio: 'inherit' })
+    expect(exitSpy).toHaveBeenCalledWith(3)
+  })
+
+  it('reports spawn errors and exits with failure', () => {
+    mockExistsSync.mockReturnValue(false)
+    mockSpawnSync.mockReturnValue({ error: new Error('ENOENT') })
+    const { forwardLegacyCtorTool } = loadForwarder()
+
+    forwardLegacyCtorTool(
+      'mcp',
+      'file:///repo/node_modules/@fugood/bricks-ctor/tools/mcp-server.ts',
+      [],
+    )
+
+    expect(errorSpy).toHaveBeenCalledWith('bricks-ctor forwarder failed to run `bricks`: ENOENT')
+    expect(exitSpy).toHaveBeenCalledWith(1)
+  })
+
+  it('treats a missing child status as failure', () => {
+    mockExistsSync.mockReturnValue(false)
+    mockSpawnSync.mockReturnValue({})
+    const { forwardLegacyCtorTool } = loadForwarder()
+
+    forwardLegacyCtorTool(
+      'simulator',
+      'file:///repo/node_modules/@fugood/bricks-ctor/tools/simulator.ts',
+      [],
+    )
+
+    expect(exitSpy).toHaveBeenCalledWith(1)
+  })
+})

package/tools/_forward.ts

@@ -0,0 +1,26 @@
+import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+// @fugood/bricks-ctor is deprecated; all tooling now lives in @fugood/bricks-cli.
+// This shared forwarder keeps legacy project scripts working until postinstall migrates them.
+export function resolveLegacyBricksCommand(baseUrl: string) {
+  const localBricks = fileURLToPath(new URL('../../../.bin/bricks', baseUrl))
+  return existsSync(localBricks) ? localBricks : 'bricks'
+}
+
+export function forwardLegacyCtorTool(
+  command: string,
+  baseUrl: string,
+  args = process.argv.slice(2),
+) {
+  const bricks = resolveLegacyBricksCommand(baseUrl)
+  const result = spawnSync(bricks, ['ctor', command, ...args], { stdio: 'inherit' })
+
+  if (result.error) {
+    console.error(`bricks-ctor forwarder failed to run \`${bricks}\`: ${result.error.message}`)
+    process.exit(1)
+  }
+
+  process.exit(result.status ?? 1)
+}

package/tools/deploy.ts

@@ -1,176 +1,4 @@
-import { access, 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'
 
-if (!process.env.BRICKS_RELEASE_SIGN) {
-  process.env.BRICKS_RELEASE_SIGN = 'CTOR'
-}
-
-const cwd = process.cwd()
-
-const exists = async (p: string) => {
-  try {
-    await access(p)
-    return true
-  } catch {
-    return false
-  }
-}
-
-const readJson = async (p: string) => JSON.parse(await readFile(p, 'utf8'))
-
-const {
-  values: {
-    changelogs: changelogsArg,
-    'changelogs-file': changelogsFile,
-    'auto-commit': autoCommit,
-    'auto-version': autoVersion,
-    version: versionArg,
-    yes,
-    help,
-  },
-} = parseArgs({
-  args: process.argv.slice(2),
-  options: {
-    changelogs: { type: 'string' },
-    'changelogs-file': { type: 'string' },
-    'auto-commit': { type: 'boolean' },
-    'auto-version': { type: 'boolean' },
-    version: { type: 'string' },
-    yes: { type: 'boolean', short: 'y' },
-    help: { type: 'boolean', short: 'h' },
-  },
-  allowPositionals: true,
-})
-
-if (help) {
-  console.log(`Options:
-  --changelogs <text>        Changelogs text for the release
-  --changelogs-file <path>   Read changelogs from a file
-  --auto-commit              Auto-commit unstaged changes before deploying
-  --auto-version             Auto-bump patch version before deploying
-  --version <version>        Set explicit version for the release
-  -y, --yes                  Skip all prompts
-  -h, --help                 Show this help message`)
-  process.exit(0)
-}
-
-// Check git status
-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('Deployment cancelled')
-}
-
-// Read application.json
-const app = await readJson(`${cwd}/application.json`)
-const config = await readJson(`${cwd}/.bricks/build/application-config.json`)
-
-// Resolve version: explicit flag > auto-bump > package.json
-const pkgPath = `${cwd}/package.json`
-const pkgExists = await exists(pkgPath)
-let version: string | undefined
-
-if (versionArg) {
-  version = versionArg
-  if (pkgExists) {
-    const pkg = await readJson(pkgPath)
-    pkg.version = version
-    await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
-  }
-} else if (autoVersion && pkgExists) {
-  const pkg = await readJson(pkgPath)
-  const parts = (pkg.version || '0.0.0').split('.')
-  parts[2] = String(Number(parts[2] || 0) + 1)
-  version = parts.join('.')
-  pkg.version = version
-  await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
-} else {
-  version = pkgExists ? (await readJson(pkgPath)).version : undefined
-}
-
-// Get changelog from flag or file
-let changelogs = ''
-if (changelogsArg) {
-  changelogs = changelogsArg
-} else if (changelogsFile) {
-  if (!(await exists(changelogsFile))) {
-    throw new Error(`Changelogs file not found: ${changelogsFile}`)
-  }
-  changelogs = await readFile(changelogsFile, 'utf8')
-} else if (!yes) {
-  changelogs = prompt('Enter changelogs (optional, press Enter to skip):') || ''
-}
-
-// Handle unstaged changes
-let commitId = ''
-if (isGitRepo) {
-  const unstagedChanges = await sh`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
-  if (unstagedChanges) {
-    if (autoCommit) {
-      const commitMsg = `chore: release ${version || 'new version'}`
-      const commitBody = changelogs || '[no changelogs]'
-      await sh`cd ${cwd} && git add -A`
-      const commitArgs = await buildCommitArgs(cwd, [commitMsg, commitBody])
-      await sh`cd ${cwd} && git ${commitArgs}`
-    } else {
-      throw new Error(
-        'Unstaged changes found, please commit or stash your changes before deploying',
-      )
-    }
-  }
-  commitId = (await sh`cd ${cwd} && git rev-parse HEAD`.text()).trim()
-}
-
-// Ask for confirmation
-if (!yes) {
-  const confirm = prompt('Are you sure you want to deploy? (y/n)')
-  if (confirm !== 'y') throw new Error('Deployment cancelled')
-}
-
-const isModule = app.type === 'module'
-const command = isModule ? 'module' : 'app'
-
-// Add project-specific fields to config and write to temp file
-const releaseConfig = {
-  ...config,
-  title: version || config.title,
-  bricks_project_last_commit_id: commitId || undefined,
-}
-const configPath = `${cwd}/.bricks/build/release-config.json`
-await writeFile(configPath, JSON.stringify(releaseConfig))
-
-const args = ['bricks', command, 'release', app.id, '-c', configPath, '--json']
-
-if (app.name) {
-  args.push('--name', app.name)
-}
-
-if (version) {
-  args.push('--version', version)
-}
-
-if (changelogs) {
-  args.push('--changelogs', changelogs)
-}
-
-const result = await sh`${args}`.quiet().nothrow()
-
-if (result.exitCode !== 0) {
-  const output = result.stderr.toString() || result.stdout.toString()
-  throw new Error(extractCliErrorMessage(output, 'Release 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.
-if (commitId) await writeLastPushedCommit(cwd, commitId)
-
-console.log(`${isModule ? 'Module' : 'App'} deployed: ${output.name}`)
+forwardLegacyCtorTool('deploy', import.meta.url)

package/tools/mcp-server.ts

@@ -1,36 +1,4 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+#!/usr/bin/env bun
+import { forwardLegacyCtorTool } from './_forward.ts'
 
-import { register as registerCompile } from './mcp-tools/compile'
-import { register as registerLottie } from './mcp-tools/lottie'
-import { register as registerIcons } from './mcp-tools/icons'
-import { register as registerHuggingface } from './mcp-tools/huggingface'
-import { register as registerMedia } from './mcp-tools/media'
-import { register as registerEntryEditing } from './mcp-tools/entry-editing'
-import { register as registerDataCalcEditing } from './mcp-tools/data-calc-editing'
-import { shouldRegisterEditingTools } from './mcp-env'
-
-const server = new McpServer({
-  name: 'bricks-ctor',
-  version: '1.0.0',
-})
-
-const { dirname } = import.meta
-const projectDir = String(dirname).split('/node_modules/')[0]
-
-// NOTE: Cursor (Or VSCode) seems set ELECTRON_RUN_AS_NODE to 1, so we need to unset it
-process.env.ELECTRON_RUN_AS_NODE = ''
-
-registerCompile(server, projectDir)
-registerLottie(server)
-registerIcons(server)
-registerHuggingface(server)
-registerMedia(server, projectDir)
-
-if (shouldRegisterEditingTools()) {
-  registerEntryEditing(server, projectDir)
-  registerDataCalcEditing(server, projectDir)
-}
-
-const transport = new StdioServerTransport()
-await server.connect(transport)
+forwardLegacyCtorTool('mcp', import.meta.url)

package/tools/postinstall.ts

@@ -1,292 +1,4 @@
-import {
-  cp,
-  lstat,
-  mkdir,
-  readFile,
-  readdir,
-  readlink,
-  rm,
-  stat,
-  symlink,
-  writeFile,
-} from 'fs/promises'
-import * as path from 'path'
-import TOML from '@iarna/toml'
-import { handleMcpConfigOverride } from './_mcp-config'
+#!/usr/bin/env bun
+import { forwardLegacyCtorTool } from './_forward.ts'
 
-const cwd = process.cwd()
-const projectSkillsDir = path.join(cwd, '.bricks', 'skills')
-const compatibilitySkillLinks = [
-  path.join(cwd, '.claude', 'skills'),
-  path.join(cwd, '.codex', 'skills'),
-]
-
-async function exists(f: string) {
-  try {
-    await stat(f)
-    return true
-  } catch {
-    return false
-  }
-}
-
-async function pathExists(f: string) {
-  try {
-    await lstat(f)
-    return true
-  } catch {
-    return false
-  }
-}
-
-// Migrate old projects: remove legacy project/ directory
-const oldProjectDir = path.join(cwd, 'project')
-if (await exists(oldProjectDir)) {
-  await rm(oldProjectDir, { recursive: true, force: true })
-  console.log('Removed legacy project/ directory')
-}
-
-// handle flag --skip-copy
-const skipCopyProject = process.argv.includes('--skip-copy-project')
-if (skipCopyProject) {
-  console.log('Skipping copy of files to ctor/')
-} else {
-  const libFiles = ['types', 'utils', 'index.ts']
-
-  const ctorDir = path.join(cwd, 'ctor')
-  await mkdir(ctorDir, { recursive: true })
-  await Promise.all(
-    libFiles.map((file) =>
-      cp(path.join(import.meta.dirname, '..', file), path.join(ctorDir, file), {
-        recursive: true,
-      }),
-    ),
-  )
-  console.log('Copied files to ctor/')
-}
-
-const projectMcpServer = {
-  command: 'bun',
-  args: [`${cwd}/node_modules/@fugood/bricks-ctor/tools/mcp-server.ts`],
-}
-
-// Codex cancels MCP tool calls it cannot prompt approval for (e.g. `codex exec`),
-// so the project-local server's tools must be pre-approved in its config entry.
-const codexProjectMcpServer = {
-  ...projectMcpServer,
-  default_tools_approval_mode: 'approve',
-}
-
-type CodexMcpConfig = {
-  mcp_servers: Record<string, typeof codexProjectMcpServer | typeof projectMcpServer>
-}
-
-const hasClaudeCode = await exists(`${cwd}/CLAUDE.md`)
-const hasAgentsMd = await exists(`${cwd}/AGENTS.md`)
-
-if (hasClaudeCode || hasAgentsMd) {
-  // Keep the workspace-level JSON MCP config aligned for tools that read .mcp.json.
-  const mcpConfigPath = `${cwd}/.mcp.json`
-  await handleMcpConfigOverride(mcpConfigPath, projectMcpServer)
-}
-
-const copyMissingSkills = async (sourceDir: string, targetDir: string) => {
-  if (!(await exists(sourceDir))) return
-
-  const packageSkills = await readdir(sourceDir, { withFileTypes: true })
-  const skillsToInstall = packageSkills.filter(
-    (entry) => entry.isDirectory() && !entry.name.startsWith('.'),
-  )
-
-  await mkdir(targetDir, { recursive: true })
-
-  await Promise.all(
-    skillsToInstall.map(async (entry) => {
-      const targetSkillDir = path.join(targetDir, entry.name)
-      if (await exists(targetSkillDir)) {
-        console.log(`Skill '${entry.name}' already exists, skipping`)
-      } else {
-        await cp(path.join(sourceDir, entry.name), targetSkillDir, { recursive: true })
-        console.log(`Installed skill '${entry.name}' to ${targetDir}/`)
-      }
-    }),
-  )
-}
-
-const migrateSkillsDir = async (legacySkillsDir: string, canonicalSkillsDir: string) => {
-  if (!(await pathExists(legacySkillsDir))) return
-
-  const legacyStats = await lstat(legacySkillsDir)
-
-  if (legacyStats.isSymbolicLink()) {
-    const linkTarget = await readlink(legacySkillsDir)
-    const resolvedTarget = path.resolve(path.dirname(legacySkillsDir), linkTarget)
-    if (resolvedTarget === canonicalSkillsDir) return
-
-    await copyMissingSkills(resolvedTarget, canonicalSkillsDir)
-    await rm(legacySkillsDir, { force: true, recursive: true })
-    return
-  }
-
-  if (legacyStats.isDirectory()) {
-    await copyMissingSkills(legacySkillsDir, canonicalSkillsDir)
-    await rm(legacySkillsDir, { force: true, recursive: true })
-    return
-  }
-
-  console.warn(`Skipping skills migration for ${legacySkillsDir}; expected a directory or symlink`)
-}
-
-const ensureCompatibilitySkillLink = async (linkPath: string, targetDir: string) => {
-  await mkdir(path.dirname(linkPath), { recursive: true })
-
-  if (await pathExists(linkPath)) {
-    const linkStats = await lstat(linkPath)
-    if (linkStats.isSymbolicLink()) {
-      const linkTarget = await readlink(linkPath)
-      const resolvedTarget = path.resolve(path.dirname(linkPath), linkTarget)
-      if (resolvedTarget === targetDir) return
-    } else {
-      console.warn(
-        `Skipping skills symlink at ${linkPath}; path already exists and is not a symlink`,
-      )
-      return
-    }
-  }
-
-  const relativeTarget = path.relative(path.dirname(linkPath), targetDir)
-  const symlinkType = process.platform === 'win32' ? 'junction' : 'dir'
-  await symlink(relativeTarget, linkPath, symlinkType)
-  console.log(`Linked ${linkPath} -> ${relativeTarget}`)
-}
-
-const setupSkills = async () => {
-  const packageSkillsDir = path.join(import.meta.dirname, '..', 'skills')
-  await mkdir(projectSkillsDir, { recursive: true })
-  await copyMissingSkills(packageSkillsDir, projectSkillsDir)
-
-  for (const linkPath of compatibilitySkillLinks) {
-    await migrateSkillsDir(linkPath, projectSkillsDir)
-    await ensureCompatibilitySkillLink(linkPath, projectSkillsDir)
-  }
-}
-
-if (hasClaudeCode || hasAgentsMd) {
-  // Install project skills once and expose them through compatibility symlinks.
-  await setupSkills()
-}
-
-type ClaudeSettings = {
-  autoMode?: {
-    environment?: string[]
-    allow?: string[]
-    soft_deny?: string[]
-    hard_deny?: string[]
-  }
-  [key: string]: unknown
-}
-
-// Trusted infrastructure for auto mode's classifier. `$defaults` keeps the
-// built-in environment (the working repo and its git remotes); the extra
-// entries stop routine syncs to the BRICKS backend from being treated as
-// external exfiltration. See https://code.claude.com/docs/en/auto-mode-config
-const autoModeEnvironment = [
-  '$defaults',
-  'Organization: BRICKS (bricks.tools). Primary use: building BRICKS apps/modules with the bricks CLI and the local bricks-ctor MCP server.',
-  'Trusted internal domains: all *.bricks.tools services — api.bricks.tools (project GraphQL API), bank.bricks.tools (config & asset Bank API), cdn.bricks.tools (asset CDN), plus the control/display/activity services. This project syncs its config and assets to these endpoints.',
-]
-
-// `.claude/settings.local.json` is per-developer local config; keep it untracked.
-const ensureSettingsLocalGitignored = async () => {
-  const gitignorePath = path.join(cwd, '.gitignore')
-  const entry = '.claude/settings.local.json'
-  const coveredBy = new Set([entry, '.claude', '.claude/', '.claude/*', '*.local.json'])
-
-  let content = ''
-  if (await exists(gitignorePath)) {
-    content = await readFile(gitignorePath, 'utf-8')
-    if (content.split('\n').some((line) => coveredBy.has(line.trim()))) return
-  }
-
-  const separator = content.length === 0 ? '' : content.endsWith('\n') ? '\n' : '\n\n'
-  await writeFile(gitignorePath, `${content}${separator}# Claude Code local settings\n${entry}\n`)
-  console.log(`Added ${entry} to .gitignore`)
-}
-
-// Pre-configure auto mode once, on initial setup. We only seed the classifier's
-// trusted infrastructure — not `permissions.defaultMode: 'auto'`, which Claude
-// Code ignores from project/local settings (a repo can't grant itself auto mode;
-// it only takes effect from ~/.claude/settings.json). An existing autoMode block
-// is left untouched so reinstalls never clobber a developer's customizations.
-const setupClaudeAutoMode = async () => {
-  const settingsPath = path.join(cwd, '.claude', 'settings.local.json')
-
-  let settings: ClaudeSettings = {}
-  if (await exists(settingsPath)) {
-    try {
-      settings = JSON.parse(await readFile(settingsPath, 'utf-8'))
-    } catch {
-      console.warn(`Skipping auto mode setup; ${settingsPath} is not valid JSON`)
-      return
-    }
-    if (settings.autoMode) return
-  }
-
-  settings.autoMode = { environment: autoModeEnvironment }
-
-  await mkdir(path.dirname(settingsPath), { recursive: true })
-  await writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}\n`)
-  console.log(`Set up auto mode in ${settingsPath}`)
-
-  await ensureSettingsLocalGitignored()
-}
-
-if (hasClaudeCode) {
-  // Pre-configure auto mode's trusted infrastructure for Claude Code projects.
-  await setupClaudeAutoMode()
-}
-
-if (hasAgentsMd) {
-  // Codex stores its project-local MCP config in .codex/config.toml.
-  const defaultCodexMcpConfig = {
-    mcp_servers: {
-      'bricks-ctor': codexProjectMcpServer,
-    },
-  }
-
-  const handleCodexMcpConfigOverride = async (mcpConfigPath: string) => {
-    let mcpConfig: CodexMcpConfig
-    if (await exists(mcpConfigPath)) {
-      let parsed: unknown
-      try {
-        parsed = TOML.parse(await readFile(mcpConfigPath, 'utf-8'))
-      } catch {
-        // A malformed config is left untouched (with a warning) rather than overwritten with
-        // the default — clobbering it would silently delete the user's other server entries.
-        // Mirrors handleMcpConfigOverride's handling of a malformed .mcp.json.
-        console.warn(`Skipping .codex/config.toml update; ${mcpConfigPath} is not valid TOML`)
-        return
-      }
-      mcpConfig =
-        parsed && typeof parsed === 'object' ? (parsed as CodexMcpConfig) : { mcp_servers: {} }
-      if (!mcpConfig.mcp_servers || typeof mcpConfig.mcp_servers !== 'object') {
-        mcpConfig.mcp_servers = {}
-      }
-      mcpConfig.mcp_servers['bricks-ctor'] = codexProjectMcpServer
-      delete mcpConfig.mcp_servers['bricks-project']
-    } else {
-      mcpConfig = defaultCodexMcpConfig
-    }
-
-    await writeFile(mcpConfigPath, `${TOML.stringify(mcpConfig)}\n`)
-
-    console.log(`Updated ${mcpConfigPath}`)
-  }
-
-  // Keep the Codex TOML MCP config aligned with the same bricks-ctor server entry.
-  const codexConfigPath = `${cwd}/.codex/config.toml`
-  await handleCodexMcpConfigOverride(codexConfigPath)
-}
-
-// TODO: .cursor/skills if needed
-// TODO: User setting in application.json to avoid unnecessary skills/config setup
+forwardLegacyCtorTool('postinstall', import.meta.url)