@fugood/bricks-project 2.25.0-beta.42 → 2.25.0-beta.45

package/tools/postinstall.ts

@@ -69,8 +69,15 @@ const projectMcpServer = {
   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 projectMcpServer>
+  mcp_servers: Record<string, typeof codexProjectMcpServer | typeof projectMcpServer>
 }
 
 // Claude Code and AGENTS.md projects both use the shared project .mcp.json file.
@@ -196,11 +203,81 @@ if (hasClaudeCode || hasAgentsMd) {
   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': projectMcpServer,
+      'bricks-ctor': codexProjectMcpServer,
     },
   }
 
@@ -212,7 +289,7 @@ if (hasAgentsMd) {
         const parsed = TOML.parse(configStr) as Partial<CodexMcpConfig>
         if (!parsed?.mcp_servers) throw new Error('mcp_servers is not defined')
         mcpConfig = { mcp_servers: parsed.mcp_servers }
-        mcpConfig.mcp_servers['bricks-ctor'] = projectMcpServer
+        mcpConfig.mcp_servers['bricks-ctor'] = codexProjectMcpServer
         delete mcpConfig.mcp_servers['bricks-project']
       } catch {
         mcpConfig = defaultCodexMcpConfig

package/types/data-calc-command/color.d.ts

@@ -250,7 +250,7 @@ export type DataCommandColorRandom = DataCommand & {
   outputs?: Array<DataCalcOutput<'result'> /* target: string */>
 }
 
-/* RGBA — Generate color string RGBA values */
+/* RGBA — Generate a color from RGBA channels (red/green/blue: 0-255, alpha: 0-1) */
 export type DataCommandColorRgba = DataCommand & {
   __commandName: 'COLOR_RGBA'
   inputs?: Array<

package/types/data-calc-command/datetime.d.ts

@@ -22,7 +22,7 @@ export type DataCommandDatetimeDate = DataCommand & {
   outputs?: Array<DataCalcOutput<'result'> /* target: number */>
 }
 
-/* Day — Get day (Sunday is 7) */
+/* Day — Get day of week (0-based: Sunday is 0, Saturday is 6) */
 export type DataCommandDatetimeDay = DataCommand & {
   __commandName: 'DATETIME_DAY'
   inputs?: Array<
@@ -64,7 +64,7 @@ export type DataCommandDatetimeMinute = DataCommand & {
   outputs?: Array<DataCalcOutput<'result'> /* target: number */>
 }
 
-/* Month — Get month (January is 1) */
+/* Month — Get month (0-based: January is 0, December is 11) */
 export type DataCommandDatetimeMonth = DataCommand & {
   __commandName: 'DATETIME_MONTH'
   inputs?: Array<

package/utils/calc.ts

@@ -28,6 +28,10 @@ export const generateDataCalculationMapEditorInfo = (
     DataCalculationData | DataCommand,
     Set<DataCalculationData | DataCommand>
   >()
+  const nodeById = new Map<string, DataCalculationData | DataCommand>()
+  for (const node of nodes) {
+    if ('id' in node) nodeById.set(node.id, node)
+  }
 
   // Analyze node connections
   nodes.forEach((node) => {
@@ -48,7 +52,7 @@ export const generateDataCalculationMapEditorInfo = (
             if (!connectedTo.has(node)) {
               connectedTo.set(node, new Set())
             }
-            const sourceNode = nodes.find((n) => 'id' in n && n.id === conn.id)
+            const sourceNode = nodeById.get(conn.id)
             if (sourceNode) {
               connectedTo.get(node)!.add(sourceNode)
             }

package/utils/data.ts

@@ -7,14 +7,12 @@ export const linkData: (dataGetter: () => Data) => DataLink = (dataGetter) => ({
   data: dataGetter,
 })
 
-const idOpts = {
-  snapshotMode: process.env.BRICKS_SNAPSHOT_MODE === '1',
-}
-
 export const createCanvasIdRef: (canvasGetter: () => Canvas) => Data<string> = (canvasGetter) => {
   const data: Data<string> = {
     __typename: 'Data',
-    id: makeId('data', idOpts),
+    // Stable by default (utils/id.ts) so recompiling unchanged source yields an
+    // identical config; the legacy snapshotMode opt-out made this id churn per compile.
+    id: makeId('data'),
     type: 'string',
     routing: 'read-only',
     kind: {

package/utils/id.ts

@@ -69,63 +69,65 @@ const makeStableUuid = (type: string, alias?: string) => {
   })
 }
 
-// Make stable ids by default; explicit snapshotMode: false preserves the random escape hatch.
-export const makeId = (type: IdType, aliasOrOpts?: string | IdOptions, opts?: IdOptions) => {
-  if (type === 'subspace') {
-    throw new Error('Currently subspace is not supported for ID generation, please use a fixed ID')
-  }
-
-  const alias = typeof aliasOrOpts === 'string' ? aliasOrOpts : undefined
-  const options = typeof aliasOrOpts === 'string' ? opts : (aliasOrOpts ?? opts)
-
-  let prefix = ''
+const idPrefix = (type: IdType): string => {
   switch (type) {
     case 'animation':
-      prefix = 'ANIMATION_'
-      break
+      return 'ANIMATION_'
     case 'brick':
-      prefix = 'BRICK_'
-      break
+      return 'BRICK_'
     case 'dynamic-brick':
-      prefix = 'DYNAMIC_BRICK_'
-      break
+      return 'DYNAMIC_BRICK_'
     case 'canvas':
-      prefix = 'CANVAS_'
-      break
+      return 'CANVAS_'
     case 'generator':
-      prefix = 'GENERATOR_'
-      break
+      return 'GENERATOR_'
     case 'data':
-      prefix = 'PROPERTY_BANK_DATA_NODE_'
-      break
+      return 'PROPERTY_BANK_DATA_NODE_'
     case 'switch':
-      prefix = 'BRICK_STATE_GROUP_'
-      break
+      return 'BRICK_STATE_GROUP_'
     case 'property_bank_command':
-      prefix = 'PROPERTY_BANK_COMMAND_NODE_'
-      break
+      return 'PROPERTY_BANK_COMMAND_NODE_'
     case 'property_bank_calc':
-      prefix = 'PROPERTY_BANK_COMMAND_MAP_'
-      break
+      return 'PROPERTY_BANK_COMMAND_MAP_'
     case 'automation_map':
-      prefix = 'AUTOMATION_MAP_'
-      break
+      return 'AUTOMATION_MAP_'
     case 'test':
-      prefix = 'TEST_'
-      break
+      return 'TEST_'
     case 'test_case':
-      prefix = 'TEST_CASE_'
-      break
+      return 'TEST_CASE_'
     case 'test_var':
-      prefix = 'TEST_VAR_'
-      break
+      return 'TEST_VAR_'
     default:
+      return ''
+  }
+}
+
+// Make stable ids by default; explicit snapshotMode: false preserves the random escape hatch.
+export const makeId = (type: IdType, aliasOrOpts?: string | IdOptions, opts?: IdOptions) => {
+  if (type === 'subspace') {
+    throw new Error('Currently subspace is not supported for ID generation, please use a fixed ID')
   }
 
+  const alias = typeof aliasOrOpts === 'string' ? aliasOrOpts : undefined
+  const options = typeof aliasOrOpts === 'string' ? opts : (aliasOrOpts ?? opts)
+
   const useCountFallback = aliasOrOpts === undefined && opts === undefined
   const id =
     alias !== undefined || options?.snapshotMode || useCountFallback
       ? makeStableUuid(type, alias)
       : uuid()
-  return `${prefix}${id}`
+  return `${idPrefix(type)}${id}`
+}
+
+// Deterministic id derived solely from a caller-supplied seed. Unlike makeId it keeps no
+// global state — no incrementing counter, no alias registry — so the same (type, seed)
+// always maps to the same id on every compile and in any process. Compiled artifacts seed
+// their ids this way (e.g. generateCalulationMap's command nodes, seeded by their calc id +
+// structural role) so unchanged source recompiles byte-identically and editing one calc
+// never shifts another's ids. The seed must be unique within a single config.
+export const makeSeededId = (type: IdType, seed: string) => {
+  if (type === 'subspace') {
+    throw new Error('Currently subspace is not supported for ID generation, please use a fixed ID')
+  }
+  return `${idPrefix(type)}${uuid({ random: hashToRandomBytes([readApplicationId(), type, seed]) })}`
 }