@fugood/bricks-ctor 2.25.0-beta.10 → 2.25.0-beta.12

package/compile/__tests__/util.test.js

@@ -0,0 +1,278 @@
+import { generateCalulationMap, validateConfig } from '../util'
+
+const baseConfig = (overrides = {}) => ({
+  inputs: {},
+  enable_async: false,
+  disabled_triggers: {},
+  output: null,
+  outputs: {},
+  error: null,
+  code: 'return inputs',
+  ...overrides,
+})
+
+const SANDBOX_PREFIX = 'PROPERTY_BANK_COMMAND_NODE_'
+
+const sandboxNodeIds = (map) =>
+  Object.entries(map)
+    .filter(([id, node]) => id.startsWith(SANDBOX_PREFIX) && node.type === 'command-node-sandbox')
+    .map(([id, node]) => ({ id, command: node.properties.command }))
+
+const findSandboxIds = (map) => {
+  const sandbox = sandboxNodeIds(map)
+  return {
+    run: sandbox.find((s) => s.command === 'SANDBOX_RUN_JAVASCRIPT')?.id,
+    error: sandbox.find((s) => s.command === 'SANDBOX_GET_ERROR')?.id,
+    result: sandbox.find((s) => s.command === 'SANDBOX_GET_RETURN_VALUE')?.id,
+  }
+}
+
+describe('validateConfig', () => {
+  test('returns without throwing for a clean config', () => {
+    expect(() => validateConfig(baseConfig({ inputs: { a: 'foo' } }))).not.toThrow()
+  })
+
+  test('skips overlap checks in manual trigger mode', () => {
+    const config = baseConfig({
+      trigger_mode: 'manual',
+      inputs: { a: 'foo' },
+      output: 'a',
+      error: 'a',
+      outputs: { x: ['a'] },
+    })
+    expect(() => validateConfig(config)).not.toThrow()
+  })
+
+  test('throws when error key collides with an input id', () => {
+    const config = baseConfig({ inputs: { a: 'foo' }, error: 'a' })
+    expect(() => validateConfig(config)).toThrow(/key: error/)
+  })
+
+  test('throws when output key collides with an input id', () => {
+    const config = baseConfig({ inputs: { a: 'foo' }, output: 'a' })
+    expect(() => validateConfig(config)).toThrow(/key: output/)
+  })
+
+  test('throws when any outputs entry references an input id', () => {
+    const config = baseConfig({
+      inputs: { a: 'foo', b: 'bar' },
+      outputs: { x: ['c', 'b'] },
+    })
+    expect(() => validateConfig(config)).toThrow(/key: outputs/)
+  })
+
+  test('does not throw when error/output are falsy and inputs are empty', () => {
+    expect(() => validateConfig(baseConfig())).not.toThrow()
+  })
+})
+
+describe('generateCalulationMap', () => {
+  test('produces only the three sandbox nodes for an empty config', () => {
+    const result = generateCalulationMap(baseConfig())
+
+    expect(Object.keys(result.map)).toHaveLength(3)
+    const { run, error, result: returnValue } = findSandboxIds(result.map)
+
+    expect(result.map[run].in.inputs).toEqual([])
+    expect(result.map[error].out.result).toEqual([])
+    expect(result.map[returnValue].out.result).toEqual([])
+    expect(Object.keys(result.editor_info)).toHaveLength(3)
+  })
+
+  test('chains multiple inputs through OBJECT_SET commands', () => {
+    const result = generateCalulationMap(baseConfig({ inputs: { a: 'foo.bar', b: 'baz' } }))
+
+    const { run } = findSandboxIds(result.map)
+
+    // Each input gets a data-node + an OBJECT_SET command-node.
+    expect(result.map.a.type).toBe('data-node')
+    expect(result.map.b.type).toBe('data-node')
+
+    const aCommandId = result.map.a.out.value[0].id
+    const bCommandId = result.map.b.out.value[0].id
+    expect(aCommandId).not.toBe(bCommandId)
+
+    const aCmd = result.map[aCommandId]
+    const bCmd = result.map[bCommandId]
+    expect(aCmd.properties.command).toBe('OBJECT_SET')
+    expect(aCmd.properties.args.path).toBe('foo.bar')
+    expect(bCmd.properties.command).toBe('OBJECT_SET')
+    expect(bCmd.properties.args.path).toBe('baz')
+
+    // First command has no upstream obj; second command's obj input is the first command.
+    expect(aCmd.in.obj).toBeNull()
+    expect(bCmd.in.obj).toEqual([{ id: aCommandId, port: 'result' }])
+    // First command forwards its result to the second command's `obj` input.
+    expect(aCmd.out.result).toEqual([{ id: bCommandId, port: 'obj' }])
+    // The last command feeds the SANDBOX_RUN_JAVASCRIPT `inputs` port.
+    expect(bCmd.out.result).toEqual([{ id: run, port: 'inputs' }])
+    expect(result.map[run].in.inputs).toEqual([{ id: bCommandId, port: 'result' }])
+  })
+
+  test('builds OBJECT_GET commands and target data-nodes for outputs', () => {
+    const result = generateCalulationMap(baseConfig({ outputs: { resultPath: ['pb1', 'pb2'] } }))
+
+    const { result: returnValue } = findSandboxIds(result.map)
+
+    // Both target property-bank nodes are created as data-nodes.
+    expect(result.map.pb1.type).toBe('data-node')
+    expect(result.map.pb2.type).toBe('data-node')
+
+    // The SANDBOX_GET_RETURN_VALUE forwards to the OBJECT_GET command for the output entry.
+    const objectGetRefs = result.map[returnValue].out.result
+    expect(objectGetRefs).toHaveLength(1)
+    const getCommandId = objectGetRefs[0].id
+    expect(objectGetRefs[0].port).toBe('obj')
+
+    const getCmd = result.map[getCommandId]
+    expect(getCmd.type).toBe('command-node-object')
+    expect(getCmd.properties.command).toBe('OBJECT_GET')
+    expect(getCmd.properties.args.path).toBe('resultPath')
+    expect(getCmd.in.obj).toEqual([{ id: returnValue, port: 'result' }])
+
+    // OBJECT_GET feeds both target data-nodes' `change` ports.
+    expect(getCmd.out.result).toEqual([
+      { id: 'pb1', port: 'change' },
+      { id: 'pb2', port: 'change' },
+    ])
+    // Target data-nodes consume the OBJECT_GET result via their `change` port.
+    expect(result.map.pb1.in.change).toEqual([{ id: getCommandId, port: 'result' }])
+    expect(result.map.pb2.in.change).toEqual([{ id: getCommandId, port: 'result' }])
+
+    // Without input usage their `out.value` defaults to null.
+    expect(result.map.pb1.out.value).toBeNull()
+    expect(result.map.pb2.out.value).toBeNull()
+  })
+
+  // Manual mode is the only mode that lets an output target reuse an input id
+  // (see validateConfig tests). When that happens, generateCalulationMap must
+  // keep the input-side `out.value` so the data-node remains a usable input.
+  test.each([
+    ['outputs', { outputs: { result: ['shared'] } }],
+    ['output', { output: 'shared' }],
+    ['error', { error: 'shared' }],
+  ])('preserves input out.value when %s target reuses an input id', (_, overrides) => {
+    const result = generateCalulationMap(
+      baseConfig({ trigger_mode: 'manual', inputs: { shared: 'foo' }, ...overrides }),
+    )
+    expect(Array.isArray(result.map.shared.out.value)).toBe(true)
+    expect(result.map[result.map.shared.out.value[0].id].properties.command).toBe('OBJECT_SET')
+  })
+
+  test('also rewires in.change to OBJECT_GET when an outputs target reuses an input id', () => {
+    const result = generateCalulationMap(
+      baseConfig({
+        trigger_mode: 'manual',
+        inputs: { shared: 'foo' },
+        outputs: { result: ['shared'] },
+      }),
+    )
+    expect(result.map.shared.in.change).toHaveLength(1)
+    expect(result.map[result.map.shared.in.change[0].id].properties.command).toBe('OBJECT_GET')
+  })
+
+  test('preserves out.value when the same pb appears in multiple outputs entries', () => {
+    // Two outputs entries both target `pb1`. The reduce visits each entry in turn
+    // and must preserve the accumulated `out.value` from the first iteration via
+    // `acc.map[pb]` rather than wiping it on the second.
+    const result = generateCalulationMap(
+      baseConfig({ outputs: { first: ['pb1'], second: ['pb1'] } }),
+    )
+    expect(result.map.pb1.type).toBe('data-node')
+    // Without an input, out.value remains null after both passes.
+    expect(result.map.pb1.out.value).toBeNull()
+    // The latest OBJECT_GET wins as the change source — each iteration overwrites
+    // `in.change`, so we end up pointing at the second outputs entry's command.
+    expect(result.map.pb1.in.change).toHaveLength(1)
+  })
+
+  test('wires the error data-node when error is configured', () => {
+    const result = generateCalulationMap(baseConfig({ error: 'errNode' }))
+
+    const { error } = findSandboxIds(result.map)
+    // SANDBOX_GET_ERROR now broadcasts to the error data-node's `change` port.
+    expect(result.map[error].out.result).toEqual([{ id: 'errNode', port: 'change' }])
+    expect(result.map.errNode.type).toBe('data-node')
+    expect(result.map.errNode.in.change).toEqual([{ id: error, port: 'result' }])
+    // No upstream input → out.value falls back to null.
+    expect(result.map.errNode.out.value).toBeNull()
+    // editor_info contains the new node.
+    expect(result.editor_info.errNode).toBeDefined()
+  })
+
+  test('wires the output data-node when output is configured', () => {
+    const result = generateCalulationMap(baseConfig({ output: 'outNode' }))
+
+    const { result: returnValue } = findSandboxIds(result.map)
+    expect(result.map[returnValue].out.result).toEqual([{ id: 'outNode', port: 'change' }])
+    expect(result.map.outNode.type).toBe('data-node')
+    expect(result.map.outNode.in.change).toEqual([{ id: returnValue, port: 'result' }])
+    expect(result.editor_info.outNode).toBeDefined()
+  })
+
+  test('manual trigger mode sets disable_trigger_command on input value ports', () => {
+    const result = generateCalulationMap(
+      baseConfig({
+        trigger_mode: 'manual',
+        inputs: { a: 'foo', b: 'bar' },
+      }),
+    )
+    const aCmdId = result.map.a.out.value[0].id
+    const bCmdId = result.map.b.out.value[0].id
+    expect(result.map[aCmdId].in.value[0].disable_trigger_command).toBe(true)
+    expect(result.map[bCmdId].in.value[0].disable_trigger_command).toBe(true)
+  })
+
+  test('auto trigger mode honours per-key disabled_triggers', () => {
+    const result = generateCalulationMap(
+      baseConfig({
+        inputs: { a: 'foo', b: 'bar' },
+        disabled_triggers: { a: true, b: false },
+      }),
+    )
+    const aCmdId = result.map.a.out.value[0].id
+    const bCmdId = result.map.b.out.value[0].id
+    expect(result.map[aCmdId].in.value[0].disable_trigger_command).toBe(true)
+    // Falsy disabled_triggers entry → property is not set (or set to undefined).
+    expect(result.map[bCmdId].in.value[0].disable_trigger_command).toBeUndefined()
+  })
+
+  test('auto trigger mode without disabled_triggers leaves disable_trigger_command undefined', () => {
+    const result = generateCalulationMap(baseConfig({ inputs: { a: 'foo' } }))
+    const aCmdId = result.map.a.out.value[0].id
+    expect(result.map[aCmdId].in.value[0].disable_trigger_command).toBeUndefined()
+  })
+
+  test('snapshotMode forwards to makeId so generated ids are sequential', () => {
+    const result = generateCalulationMap(baseConfig({ inputs: { a: 'foo' } }), {
+      snapshotMode: true,
+    })
+    const sandboxIds = sandboxNodeIds(result.map).map((s) => s.id)
+    // Snapshot-mode ids embed a 12-digit counter — stable suffix lets us assert order.
+    sandboxIds.forEach((id) => {
+      expect(id).toMatch(/^PROPERTY_BANK_COMMAND_NODE_00000000-0000-0000-0000-\d{12}$/)
+    })
+  })
+
+  test('validateConfig errors propagate out of generateCalulationMap', () => {
+    expect(() => generateCalulationMap(baseConfig({ inputs: { a: 'foo' }, error: 'a' }))).toThrow(
+      /key: error/,
+    )
+  })
+
+  test('SANDBOX_GET_RETURN_VALUE broadcasts to both output target and outputs commands', () => {
+    const result = generateCalulationMap(
+      baseConfig({
+        output: 'outNode',
+        outputs: { foo: ['pb1'] },
+      }),
+    )
+    const { result: returnValue } = findSandboxIds(result.map)
+    const refs = result.map[returnValue].out.result
+    // First entry is the output data-node's `change` port; remainder are OBJECT_GET ids.
+    expect(refs[0]).toEqual({ id: 'outNode', port: 'change' })
+    expect(refs).toHaveLength(2)
+    expect(refs[1].port).toBe('obj')
+    expect(result.map[refs[1].id].properties.command).toBe('OBJECT_GET')
+  })
+})

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.10",
+  "version": "2.25.0-beta.12",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "build": "bun scripts/build.js"
   },
   "dependencies": {
-    "@fugood/bricks-cli": "^2.25.0-beta.10",
+    "@fugood/bricks-cli": "^2.25.0-beta.12",
     "@huggingface/gguf": "^0.3.2",
     "@iarna/toml": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.15.0",
@@ -25,5 +25,5 @@
   "peerDependencies": {
     "oxfmt": "^0.36.0"
   },
-  "gitHead": "7b909dc28862872743cf0459ff65d16af67721c6"
+  "gitHead": "a732a16341bd23fb7ee8e83dbbe0f0c07bad0eb3"
 }

package/tools/deploy.ts

@@ -141,6 +141,10 @@ 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)
 }

package/tools/update-config.ts

@@ -0,0 +1,110 @@
+import { readFile, writeFile } from 'node:fs/promises'
+import { parseArgs } from 'util'
+import { sh } from './_shell'
+import { buildCommitArgs } from './_git-author'
+
+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/update-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()
+  try {
+    const json = JSON.parse(output)
+    throw new Error(json.error?.message || json.error || 'Update failed')
+  } catch {
+    throw new Error(output || 'Update failed')
+  }
+}
+
+const output = JSON.parse(result.stdout.toString())
+console.log(`${isModule ? 'Module' : 'App'} config updated: ${output.target?.name || app.name}`)