braid-text 0.2.77 → 0.2.79

package/index.js

@@ -17,25 +17,37 @@ function create_braid_text() {
     let max_encoded_key_size = 240
 
     braid_text.sync = async (a, b, options = {}) => {
-        var unsync_cbs = []
-        options.my_unsync = () => unsync_cbs.forEach(cb => cb())
-
         if (!options.merge_type) options.merge_type = 'dt'
 
         if ((a instanceof URL) === (b instanceof URL)) {
+            // Both are URLs or both are local keys
+            var a_first_put, b_first_put
+            var a_first_put_promise = new Promise(done => a_first_put = done)
+            var b_first_put_promise = new Promise(done => b_first_put = done)
+
             var a_ops = {
-                subscribe: update => braid_text.put(b, update),
+                signal: options.signal,
+                subscribe: update => {
+                    update.signal = options.signal
+                    braid_text.put(b, update).then(a_first_put)
+                },
                 merge_type: options.merge_type,
             }
-            braid_text.get(a, a_ops)
-            unsync_cbs.push(() => braid_text.forget(a, a_ops))
+            braid_text.get(a, a_ops).then(x =>
+                x || b_first_put_promise.then(() =>
+                    braid_text.get(a, a_ops)))
 
             var b_ops = {
-                subscribe: update => braid_text.put(a, update),
+                signal: options.signal,
+                subscribe: update => {
+                    update.signal = options.signal
+                    braid_text.put(a, update).then(b_first_put)
+                },
                 merge_type: options.merge_type,
             }
-            braid_text.get(b, b_ops)
-            unsync_cbs.push(() => braid_text.forget(b, b_ops))
+            braid_text.get(b, b_ops).then(x =>
+                x || a_first_put_promise.then(() =>
+                    braid_text.get(b, b_ops)))
         } else {
             // make a=local and b=remote (swap if not)
             if (a instanceof URL) { let swap = a; a = b; b = swap }
@@ -78,12 +90,22 @@ function create_braid_text() {
             }
 
             var closed
-            var disconnect
-            unsync_cbs.push(() => {
+            var disconnect = () => {}
+            options.signal?.addEventListener('abort', () => {
                 closed = true
                 disconnect()
             })
 
+            var local_first_put
+            var local_first_put_promise = new Promise(done => local_first_put = done)
+
+            function handle_error(_e) {
+                if (closed) return
+                disconnect()
+                console.log(`disconnected, retrying in 1 second`)
+                setTimeout(connect, 1000)
+            }
+
             connect()
             async function connect() {
                 if (options.on_connect) options.on_connect()
@@ -91,9 +113,7 @@ function create_braid_text() {
                 if (closed) return
 
                 var ac = new AbortController()
-                var disconnect_cbs = [() => ac.abort()]
-
-                disconnect = () => disconnect_cbs.forEach(cb => cb())
+                disconnect = () => ac.abort()
 
                 try {
                     // fork-point
@@ -142,9 +162,11 @@ function create_braid_text() {
 
                     // local -> remote
                     var a_ops = {
+                        signal: ac.signal,
                         subscribe: update => {
                             update.signal = ac.signal
                             braid_text.put(b, update).then((x) => {
+                                local_first_put()
                                 extend_fork_point(update)
                             }).catch(e => {
                                 if (e.name === 'AbortError') {
@@ -155,28 +177,31 @@ function create_braid_text() {
                     }
                     if (resource.meta.fork_point)
                         a_ops.parents = resource.meta.fork_point
-                    disconnect_cbs.push(() => braid_text.forget(a, a_ops))
                     braid_text.get(a, a_ops)
 
                     // remote -> local
                     var b_ops = {
+                        signal: ac.signal,
                         dont_retry: true,
                         subscribe: async update => {
                             await braid_text.put(a, update)
                             extend_fork_point(update)
                         },
+                        on_error: handle_error
+                    }
+                    // Handle case where remote doesn't exist yet - wait for local to create it
+                    var remote_result = await braid_text.get(b, b_ops)
+                    if (remote_result === null) {
+                        // Remote doesn't exist yet, wait for local to put something
+                        await local_first_put_promise
+                        disconnect()
+                        connect()
                     }
-                    disconnect_cbs.push(() => braid_text.forget(b, b_ops))
-                    // NOTE: this should not return, but it might throw
-                    await braid_text.get(b, b_ops)
+                    // on_error will call handle_error when connection drops
                 } catch (e) {
-                    if (closed) return
-
-                    disconnect()
-                    console.log(`disconnected, retrying in 1 second`)
-                    setTimeout(connect, 1000)
+                    handle_error(e)
                 }
-            }            
+            }
         }
     }
 
@@ -468,15 +493,9 @@ function create_braid_text() {
 
         // Handle URL - make a DELETE request
         if (key instanceof URL) {
-            options.my_abort = new AbortController()
-            if (options.signal)
-                options.signal.addEventListener('abort', () =>
-                    options.my_abort.abort())
-
             var params = {
                 method: 'DELETE',
-                signal: options.my_abort.signal,
-                retry: () => true,
+                signal: options.signal,
             }
             for (var x of ['headers', 'peer'])
                 if (options[x] != null) params[x] = options[x]
@@ -502,33 +521,29 @@ function create_braid_text() {
         if (key instanceof URL) {
             if (!options) options = {}
 
-            options.my_abort = new AbortController()
-
             var params = {
-                signal: options.my_abort.signal,
+                signal: options.signal,
                 subscribe: !!options.subscribe,
                 heartbeats: 120,
             }
-            if (!options.dont_retry) params.retry = () => true
+            if (!options.dont_retry) {
+                params.retry = (res) => res.status !== 404
+            }
             for (var x of ['headers', 'parents', 'version', 'peer'])
                 if (options[x] != null) params[x] = options[x]
 
             var res = await braid_fetch(key.href, params)
 
-            if (options.subscribe) {
-                if (options.dont_retry) {
-                    var error_happened
-                    var error_promise = new Promise((_, fail) => error_happened = fail)
-                }
+            if (res.status === 404) return null
 
+            if (options.subscribe) {
                 res.subscribe(async update => {
                     update.body = update.body_text
                     if (update.patches)
                         for (var p of update.patches) p.content = p.content_text
                     await options.subscribe(update)
-                }, e => options.dont_retry && error_happened(e))
+                }, e => options.on_error?.(e))
 
-                if (options.dont_retry) return await error_promise
                 return res
             } else return await res.text()
         }
@@ -603,6 +618,8 @@ function create_braid_text() {
 
                 options.my_last_sent_version = x.version
                 resource.simpleton_clients.add(options)
+                options.signal?.addEventListener('abort', () =>
+                    resource.simpleton_clients.delete(options))
             } else {
 
                 if (options.accept_encoding?.match(/updates\s*\((.*)\)/)?.[1].split(',').map(x=>x.trim()).includes('dt')) {
@@ -650,22 +667,12 @@ function create_braid_text() {
                 }
 
                 resource.clients.add(options)
+                options.signal?.addEventListener('abort', () =>
+                    resource.clients.delete(options))
             }
         }
     }
 
-    braid_text.forget = async (key, options) => {
-        if (!options) throw new Error('options is required')
-
-        if (key instanceof URL) return options.my_abort.abort()
-
-        let resource = (typeof key == 'string') ? await get_resource(key) : key
-
-        if (options.merge_type != "dt")
-            resource.simpleton_clients.delete(options)
-        else resource.clients.delete(options)
-    }
-
     braid_text.put = async (key, options) => {
         if (options.version) {
             validate_version_array(options.version)
@@ -677,14 +684,9 @@ function create_braid_text() {
         }
 
         if (key instanceof URL) {
-            options.my_abort = new AbortController()
-            if (options.signal)
-                options.signal.addEventListener('abort', () =>
-                    options.my_abort.abort())
-
             var params = {
                 method: 'PUT',
-                signal: options.my_abort.signal,
+                signal: options.signal,
                 retry: () => true,
             }
             for (var x of ['headers', 'parents', 'version', 'peer', 'body', 'patches'])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-text",
-  "version": "0.2.77",
+  "version": "0.2.79",
   "description": "Library for collaborative text over http using braid.",
   "author": "Braid Working Group",
   "repository": "braid-org/braid-text",

package/test/fuzz-test.js

@@ -270,16 +270,20 @@ async function main() {
 
             // try getting updates from middle_doc to doc
             if (!v_eq(middle_v, doc_v)) {
-                var o
+                var ac = new AbortController()
                 await new Promise(async done => {
-                    o = {merge_type: 'dt', parents: middle_v, subscribe: async update => {
-                        await braid_text.put('middle_doc', update)
-                        middle_v = (await braid_text.get_resource('middle_doc')).version
-                        if (v_eq(doc_v, middle_v)) done()
-                    }}
-                    braid_text.get('doc', o)
+                    braid_text.get('doc', {
+                        signal: ac.signal,
+                        merge_type: 'dt',
+                        parents: middle_v,
+                        subscribe: async update => {
+                            await braid_text.put('middle_doc', update)
+                            middle_v = (await braid_text.get_resource('middle_doc')).version
+                            if (v_eq(doc_v, middle_v)) done()
+                        }
+                    })
                 })
-                await braid_text.forget('doc', o)
+                ac.abort()
             }
 
             if (await braid_text.get('middle_doc') != await braid_text.get('doc')) throw new Error('bad')

package/test/test.js

@@ -0,0 +1,306 @@
+#!/usr/bin/env node
+
+// Unified test runner - can run in console mode (Node.js) or browser mode (server)
+const http = require('http')
+const {fetch: braid_fetch} = require('braid-http')
+const defineTests = require('./tests.js')
+
+// Parse command line arguments
+const args = process.argv.slice(2)
+const mode = args.includes('--browser') || args.includes('-b') ? 'browser' : 'console'
+const portArg = args.find(arg => arg.startsWith('--port='))?.split('=')[1]
+    || args.find(arg => !arg.startsWith('-') && !isNaN(arg))
+const port = portArg || 8889
+const filterArg = args.find(arg => arg.startsWith('--filter='))?.split('=')[1]
+    || args.find(arg => arg.startsWith('--grep='))?.split('=')[1]
+
+// Show help if requested
+if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+Usage: node test.js [options]
+
+Options:
+  --browser, -b          Start server for browser testing (default: console mode)
+  --port=PORT            Specify port number (default: 8889)
+  PORT                   Port number as positional argument
+  --filter=PATTERN       Only run tests matching pattern (case-insensitive)
+  --grep=PATTERN         Alias for --filter
+  --help, -h             Show this help message
+
+Examples:
+  node test.js                         # Run all tests in console
+  node test.js --filter="sync"         # Run only tests with "sync" in name
+  node test.js --grep="digest"         # Run only tests with "digest" in name
+  node test.js --browser               # Start browser test server
+  node test.js --browser --port=9000
+  node test.js -b 9000                # Short form with port
+`)
+    process.exit(0)
+}
+
+// ============================================================================
+// Shared Server Code
+// ============================================================================
+
+function createTestServer(options = {}) {
+    const {
+        port = 8889,
+        runTests = false,
+        logRequests = false
+    } = options
+
+    const braid_text = require(`${__dirname}/../index.js`)
+    braid_text.db_folder = `${__dirname}/test_db_folder`
+
+    const braid_text2 = braid_text.create_braid_text()
+    braid_text2.db_folder = null
+
+    const server = http.createServer(async (req, res) => {
+        if (logRequests) {
+            console.log(`${req.method} ${req.url}`)
+        }
+
+        // Free the CORS
+        braid_text.free_cors(res)
+        if (req.method === 'OPTIONS') return
+
+        if (req.url.startsWith('/have_error')) {
+            res.statusCode = 569
+            return res.end('error')
+        }
+
+        if (req.url.startsWith('/404')) {
+            res.statusCode = 404
+            return res.end('Not Found')
+        }
+
+        if (req.url.startsWith('/eval')) {
+            var body = await new Promise(done => {
+                var chunks = []
+                req.on('data', chunk => chunks.push(chunk))
+                req.on('end', () => done(Buffer.concat(chunks)))
+            })
+            try {
+                eval('' + body)
+            } catch (error) {
+                res.writeHead(500, { 'Content-Type': 'text/plain' })
+                res.end(`Error: ${error.message}`)
+            }
+            return
+        }
+
+        if (req.url.startsWith('/test.html')) {
+            let parts = req.url.split(/[\?&=]/g)
+
+            if (parts[1] === 'check') {
+                res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-cache" })
+                return res.end(JSON.stringify({
+                    checking: parts[2],
+                    result: (await braid_text.get(parts[2])) != null
+                }))
+            } else if (parts[1] === 'dt_create_bytes_big_name') {
+                try {
+                    braid_text.dt_create_bytes('x'.repeat(1000000) + '-0', [], 0, 0, 'hi')
+                    return res.end(JSON.stringify({ ok: true }))
+                } catch (e) {
+                    return res.end(JSON.stringify({ ok: false, error: '' + e }))
+                }
+            } else if (parts[1] === 'dt_create_bytes_many_names') {
+                try {
+                    braid_text.dt_create_bytes('hi-0', new Array(1000000).fill(0).map((x, i) => `x${i}-0`), 0, 0, 'hi')
+                    return res.end(JSON.stringify({ ok: true }))
+                } catch (e) {
+                    return res.end(JSON.stringify({ ok: false, error: '' + e }))
+                }
+            }
+
+            res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-cache" })
+            require("fs").createReadStream(`${__dirname}/test.html`).pipe(res)
+            return
+        }
+
+        // Serve tests.js file for browser
+        if (req.url.startsWith('/tests.js')) {
+            res.writeHead(200, { "Content-Type": "application/javascript; charset=utf-8", "Cache-Control": "no-cache" })
+            require("fs").createReadStream(`${__dirname}/tests.js`).pipe(res)
+            return
+        }
+
+        // Now serve the collaborative text!
+        braid_text.serve(req, res)
+    })
+
+    return {
+        server,
+        start: () => new Promise((resolve) => {
+            server.listen(port, 'localhost', () => {
+                if (runTests) {
+                    console.log(`Test server running on http://localhost:${port}`)
+                } else {
+                    console.log(`serving: http://localhost:${port}/test.html`)
+                }
+                resolve()
+            })
+        }),
+        port
+    }
+}
+
+// ============================================================================
+// Console Test Mode (Node.js)
+// ============================================================================
+
+async function runConsoleTests() {
+    // Test tracking
+    let totalTests = 0
+    let passedTests = 0
+    let failedTests = 0
+
+    // Handle unhandled rejections during tests (some tests intentionally cause errors)
+    const unhandledRejections = []
+    process.on('unhandledRejection', (reason, promise) => {
+        // Collect but don't crash - some tests intentionally trigger errors
+        unhandledRejections.push({ reason, promise })
+    })
+
+    // Node.js test runner implementation
+    // Store tests to run sequentially instead of in parallel
+    const testsToRun = []
+
+    function runTest(testName, testFunction, expectedResult) {
+        // Apply filter if specified
+        if (filterArg && !testName.toLowerCase().includes(filterArg.toLowerCase())) {
+            return // Skip this test
+        }
+
+        totalTests++
+        testsToRun.push({ testName, testFunction, expectedResult })
+    }
+
+    // Create a braid_fetch wrapper that points to localhost
+    function createBraidFetch(baseUrl) {
+        return async (url, options = {}) => {
+            const fullUrl = url.startsWith('http') ? url : `${baseUrl}${url}`
+            return braid_fetch(fullUrl, options)
+        }
+    }
+
+    console.log('Starting braid-text tests...\n')
+
+    // Create and start the test server
+    const testServer = createTestServer({
+        port,
+        runTests: true,
+        logRequests: false
+    })
+
+    await testServer.start()
+
+    // Create braid_fetch bound to test server
+    const testBraidFetch = createBraidFetch(`http://localhost:${port}`)
+
+    // Load the real diamond-types module for Node.js
+    const { Doc, OpLog } = require('@braid.org/diamond-types-node')
+
+    // Define globals needed for some tests
+    global.Doc = Doc
+    global.OpLog = OpLog
+    global.dt_p = Promise.resolve() // No initialization needed for Node.js version
+    global.fetch = testBraidFetch
+    global.AbortController = AbortController
+    global.crypto = require('crypto').webcrypto
+
+    // Run all tests
+    defineTests(runTest, testBraidFetch)
+
+    // Run tests sequentially (not in parallel) to avoid conflicts
+    for (const { testName, testFunction, expectedResult } of testsToRun) {
+        try {
+            const result = await testFunction()
+            if (result == expectedResult) {
+                passedTests++
+                console.log(`✓ ${testName}`)
+            } else {
+                failedTests++
+                console.log(`✗ ${testName}`)
+                console.log(`  Expected: ${expectedResult}`)
+                console.log(`  Got: ${result}`)
+            }
+        } catch (error) {
+            failedTests++
+            console.log(`✗ ${testName}`)
+            console.log(`  Error: ${error.message || error}`)
+        }
+    }
+
+    // Print summary
+    console.log('\n' + '='.repeat(50))
+    console.log(`Total: ${totalTests} | Passed: ${passedTests} | Failed: ${failedTests}`)
+    console.log('='.repeat(50))
+
+    // Clean up test database folder
+    console.log('Cleaning up test database folder...')
+    const fs = require('fs')
+    const path = require('path')
+    const testDbPath = path.join(__dirname, 'test_db_folder')
+    try {
+        if (fs.existsSync(testDbPath)) {
+            fs.rmSync(testDbPath, { recursive: true, force: true })
+            console.log('Test database folder removed')
+        }
+    } catch (err) {
+        console.log(`Warning: Could not remove test database folder: ${err.message}`)
+    }
+
+    // Force close the server and all connections
+    console.log('Closing server...')
+    testServer.server.close(() => {
+        console.log('Server closed callback - calling process.exit()')
+        process.exit(failedTests > 0 ? 1 : 0)
+    })
+
+    // Also close all active connections if the method exists (Node 18.2+)
+    if (typeof testServer.server.closeAllConnections === 'function') {
+        console.log('Closing all connections...')
+        testServer.server.closeAllConnections()
+    }
+
+    // Fallback: force exit after a short delay even if server hasn't fully closed
+    console.log('Setting 200ms timeout fallback...')
+    setTimeout(() => {
+        console.log('Timeout reached - calling process.exit()')
+        process.exit(failedTests > 0 ? 1 : 0)
+    }, 200)
+}
+
+// ============================================================================
+// Browser Test Mode (Server)
+// ============================================================================
+
+async function runBrowserMode() {
+    const testServer = createTestServer({
+        port,
+        runTests: false,
+        logRequests: true
+    })
+
+    await testServer.start()
+}
+
+// ============================================================================
+// Main Entry Point
+// ============================================================================
+
+async function main() {
+    if (mode === 'browser') {
+        await runBrowserMode()
+    } else {
+        await runConsoleTests()
+    }
+}
+
+// Run the appropriate mode
+main().catch(err => {
+    console.error('Fatal error:', err)
+    process.exit(1)
+})

package/test/tests.js

@@ -14,31 +14,24 @@ runTest(
         })
         if (!r.ok) return 'got: ' + r.status
 
-        var r1p = braid_fetch(`/eval`, {
+        var r1 = await braid_fetch(`/eval`, {
             method: 'PUT',
             body: `void (async () => {
                 var x = await new Promise(done => {
                     braid_text.get(new URL('http://localhost:8889/${key}'), {
                         subscribe: update => {
-                            if (update.body_text === 'yo') done(update.body_text)
+                            if (update.body_text === 'hi') done(update.body_text)
                         }
                     })
                 })
                 res.end(x)
             })()`
         })
-
-        var r2 = await braid_fetch(`/${key}`, {
-            method: 'PUT',
-            body: 'yo'
-        })
-
-        var r1 = await r1p
         if (!r1.ok) return 'got: ' + r.status
 
         return await r1.text()
     },
-    'yo'
+    'hi'
 )
 
 runTest(
@@ -50,13 +43,14 @@ runTest(
             method: 'PUT',
             body: `void (async () => {
                 var count = 0
-                var ops
-                braid_text.sync('/${key}', new URL('http://localhost:8889/have_error'), ops = {
+                var ac = new AbortController()
+                braid_text.sync('/${key}', new URL('http://localhost:8889/have_error'), {
+                    signal: ac.signal,
                     on_connect: () => {
                         count++
                         if (count === 2) {
                             res.end('it reconnected!')
-                            ops.my_unsync()
+                            ac.abort()
                         }
                     }
                 })
@@ -201,13 +195,14 @@ runTest(
             method: 'PUT',
             body: `void (async () => {
                 var count = 0
-                var ops
-                braid_text.sync('/${key_a}', new URL('http://localhost:8889/have_error'), ops = {
+                var ac = new AbortController()
+                braid_text.sync('/${key_a}', new URL('http://localhost:8889/have_error'), {
+                    signal: ac.signal,
                     on_connect: () => {
                         count++
                         if (count === 2) {
                             res.end('it reconnected!')
-                            ops.my_unsync()
+                            ac.abort()
                         }
                     }
                 })
@@ -265,10 +260,10 @@ runTest(
         var r = await braid_fetch(`/eval`, {
             method: 'PUT',
             body: `void (async () => {
-                var ops = {}
-                braid_text.sync('/${key_a}', '/${key_b}', ops)
+                var ac = new AbortController()
+                braid_text.sync('/${key_a}', '/${key_b}', {signal: ac.signal})
                 await new Promise(done => setTimeout(done, 100))
-                ops.my_unsync()
+                ac.abort()
                 res.end('')
             })()`
         })
@@ -283,10 +278,10 @@ runTest(
         var r = await braid_fetch(`/eval`, {
             method: 'PUT',
             body: `void (async () => {
-                var ops = {}
-                braid_text.sync('/${key_a}', new URL('http://localhost:8889/${key_b}'), ops)
+                var ac = new AbortController()
+                braid_text.sync('/${key_a}', new URL('http://localhost:8889/${key_b}'), {signal: ac.signal})
                 await new Promise(done => setTimeout(done, 100))
-                ops.my_unsync()
+                ac.abort()
                 res.end('')
             })()`
         })
@@ -456,14 +451,15 @@ runTest(
             method: 'PUT',
             body: `void (async () => {
                 var url = new URL('http://localhost:8889/${key}')
+                var ac = new AbortController()
                 var update = await new Promise(done => {
-                    var o = {
+                    braid_text.get(url, {
+                        signal: ac.signal,
                         subscribe: update => {
-                            braid_text.forget(url, o)
+                            ac.abort()
                             done(update)
                         }
-                    }
-                    braid_text.get(url, o)
+                    })
                 })
                 res.end(update.body)
             })()`
@@ -1929,6 +1925,62 @@ runTest(
     'got: '
 )
 
+runTest(
+    "test braid_text.get(url) returns null for 404",
+    async () => {
+        // Use the /404 endpoint that always returns 404
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var result = await braid_text.get(new URL('http://localhost:8889/404'))
+                res.end(result === null ? 'null' : 'not null: ' + result)
+            })()`
+        })
+        return await r.text()
+    },
+    'null'
+)
+
+runTest(
+    "test braid_text.sync handles remote not existing yet",
+    async () => {
+        var local_key = 'test-local-' + Math.random().toString(36).slice(2)
+        var remote_key = 'test-remote-' + Math.random().toString(36).slice(2)
+
+        // Start sync between a local key and a remote URL that doesn't exist yet
+        // The sync should wait for local to create something, then push to remote
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var ac = new AbortController()
+
+                // Start sync - remote doesn't exist yet
+                braid_text.sync('/${local_key}', new URL('http://localhost:8889/${remote_key}'), {
+                    signal: ac.signal
+                })
+
+                // Wait a bit then put something locally
+                await new Promise(done => setTimeout(done, 100))
+                await braid_text.put('/${local_key}', { body: 'created locally' })
+
+                // Wait for sync to propagate
+                await new Promise(done => setTimeout(done, 200))
+
+                // Stop sync
+                ac.abort()
+
+                res.end('done')
+            })()`
+        })
+        if (!r.ok) return 'eval failed: ' + r.status
+
+        // Check that remote now has the content
+        var r2 = await braid_fetch(`/${remote_key}`)
+        return await r2.text()
+    },
+    'created locally'
+)
+
 runTest(
     "test getting a binary update from a subscription",
     async () => {

package/.claude/settings.local.json

@@ -1,14 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(node test/test.js:*)",
-      "Bash(node:*)",
-      "Bash(git add:*)",
-      "Bash(git commit -m \"$(cat <<''EOF''\n0.2.74 - updates url-file-db to 0.0.19\n\n🤖 Generated with [Claude Code](https://claude.com/claude-code)\n\nCo-Authored-By: Claude <noreply@anthropic.com>\nEOF\n)\")",
-      "Bash(git push)",
-      "Bash(npm publish:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}