claude-flow-novice 2.2.3 → 2.2.5

package/dist/src/web/frontend/node_modules/.multicast-dns-iKseM9bB/cli.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+var mdns = require('./')()
+var path = require('path')
+var os = require('os')
+
+var announcing = process.argv.indexOf('--announce') > -1
+
+if (process.argv.length < 3) {
+  console.error('Usage: %s <hostname>', path.basename(process.argv[1]))
+  process.exit(1)
+}
+var hostname = process.argv[2]
+
+if (announcing) {
+  var ip = getIp()
+  mdns.on('query', function (query, rinfo) {
+    query.questions.forEach(function (q) {
+      if (q.name === hostname) {
+        console.log('Responding %s -> %s', q.name, ip)
+        mdns.respond({
+          answers: [{
+            type: 'A',
+            name: q.name,
+            data: ip
+          }]
+        }, {port: rinfo.port})
+      }
+    })
+  })
+} else {
+  mdns.on('response', function (response) {
+    response.answers.forEach(function (answer) {
+      if (answer.name === hostname) {
+        console.log(answer.data)
+        process.exit()
+      }
+    })
+  })
+
+  mdns.query(hostname, 'A')
+
+  // Give responses 3 seconds to respond
+  setTimeout(function () {
+    console.error('Hostname not found')
+    process.exit(1)
+  }, 3000)
+}
+
+function getIp () {
+  var networks = os.networkInterfaces()
+  var found = '127.0.0.1'
+
+  Object.keys(networks).forEach(function (k) {
+    var n = networks[k]
+    n.forEach(function (addr) {
+      if (addr.family === 'IPv4' && !addr.internal) {
+        found = addr.address
+      }
+    })
+  })
+
+  return found
+}

package/dist/src/web/frontend/node_modules/.multicast-dns-iKseM9bB/example.js

@@ -0,0 +1,36 @@
+var mdns = require('./')()
+
+mdns.on('warning', function (err) {
+  console.log(err.stack)
+})
+
+mdns.on('response', function (response) {
+  console.log('got a response packet:', response)
+})
+
+mdns.on('query', function (query) {
+  console.log('got a query packet:', query)
+
+  // iterate over all questions to check if we should respond
+  query.questions.forEach(function (q) {
+    if (q.type === 'A' && q.name === 'example.local') {
+      // send an A-record response for example.local
+      mdns.respond({
+        answers: [{
+          name: 'example.local',
+          type: 'A',
+          ttl: 300,
+          data: '192.168.1.5'
+        }]
+      })
+    }
+  })
+})
+
+// lets query for an A-record for example.local
+mdns.query({
+  questions: [{
+    name: 'example.local',
+    type: 'A'
+  }]
+})

package/dist/src/web/frontend/node_modules/.multicast-dns-iKseM9bB/index.js

@@ -0,0 +1,205 @@
+var packet = require('dns-packet')
+var dgram = require('dgram')
+var thunky = require('thunky')
+var events = require('events')
+var os = require('os')
+
+var noop = function () {}
+
+module.exports = function (opts) {
+  if (!opts) opts = {}
+
+  var that = new events.EventEmitter()
+  var port = typeof opts.port === 'number' ? opts.port : 5353
+  var type = opts.type || 'udp4'
+  var ip = opts.ip || opts.host || (type === 'udp4' ? '224.0.0.251' : null)
+  var me = {address: ip, port: port}
+  var memberships = {}
+  var destroyed = false
+  var interval = null
+
+  if (type === 'udp6' && (!ip || !opts.interface)) {
+    throw new Error('For IPv6 multicast you must specify `ip` and `interface`')
+  }
+
+  var socket = opts.socket || dgram.createSocket({
+    type: type,
+    reuseAddr: opts.reuseAddr !== false,
+    toString: function () {
+      return type
+    }
+  })
+
+  socket.on('error', function (err) {
+    if (err.code === 'EACCES' || err.code === 'EADDRINUSE') that.emit('error', err)
+    else that.emit('warning', err)
+  })
+
+  socket.on('message', function (message, rinfo) {
+    try {
+      message = packet.decode(message)
+    } catch (err) {
+      that.emit('warning', err)
+      return
+    }
+
+    that.emit('packet', message, rinfo)
+
+    if (message.type === 'query') that.emit('query', message, rinfo)
+    if (message.type === 'response') that.emit('response', message, rinfo)
+  })
+
+  socket.on('listening', function () {
+    if (!port) port = me.port = socket.address().port
+    if (opts.multicast !== false) {
+      that.update()
+      interval = setInterval(that.update, 5000)
+      socket.setMulticastTTL(opts.ttl || 255)
+      socket.setMulticastLoopback(opts.loopback !== false)
+    }
+  })
+
+  var bind = thunky(function (cb) {
+    if (!port || opts.bind === false) return cb(null)
+    socket.once('error', cb)
+    socket.bind(port, opts.bind || opts.interface, function () {
+      socket.removeListener('error', cb)
+      cb(null)
+    })
+  })
+
+  bind(function (err) {
+    if (err) return that.emit('error', err)
+    that.emit('ready')
+  })
+
+  that.send = function (value, rinfo, cb) {
+    if (typeof rinfo === 'function') return that.send(value, null, rinfo)
+    if (!cb) cb = noop
+    if (!rinfo) rinfo = me
+    else if (!rinfo.host && !rinfo.address) rinfo.address = me.address
+
+    bind(onbind)
+
+    function onbind (err) {
+      if (destroyed) return cb()
+      if (err) return cb(err)
+      var message = packet.encode(value)
+      socket.send(message, 0, message.length, rinfo.port, rinfo.address || rinfo.host, cb)
+    }
+  }
+
+  that.response =
+  that.respond = function (res, rinfo, cb) {
+    if (Array.isArray(res)) res = {answers: res}
+
+    res.type = 'response'
+    res.flags = (res.flags || 0) | packet.AUTHORITATIVE_ANSWER
+    that.send(res, rinfo, cb)
+  }
+
+  that.query = function (q, type, rinfo, cb) {
+    if (typeof type === 'function') return that.query(q, null, null, type)
+    if (typeof type === 'object' && type && type.port) return that.query(q, null, type, rinfo)
+    if (typeof rinfo === 'function') return that.query(q, type, null, rinfo)
+    if (!cb) cb = noop
+
+    if (typeof q === 'string') q = [{name: q, type: type || 'ANY'}]
+    if (Array.isArray(q)) q = {type: 'query', questions: q}
+
+    q.type = 'query'
+    that.send(q, rinfo, cb)
+  }
+
+  that.destroy = function (cb) {
+    if (!cb) cb = noop
+    if (destroyed) return process.nextTick(cb)
+    destroyed = true
+    clearInterval(interval)
+
+    // Need to drop memberships by hand and ignore errors.
+    // socket.close() does not cope with errors.
+    for (var iface in memberships) {
+      try {
+        socket.dropMembership(ip, iface)
+      } catch (e) {
+        // eat it
+      }
+    }
+    memberships = {}
+    socket.close(cb)
+  }
+
+  that.update = function () {
+    var ifaces = opts.interface ? [].concat(opts.interface) : allInterfaces()
+    var updated = false
+
+    for (var i = 0; i < ifaces.length; i++) {
+      var addr = ifaces[i]
+      if (memberships[addr]) continue
+
+      try {
+        socket.addMembership(ip, addr)
+        memberships[addr] = true
+        updated = true
+      } catch (err) {
+        that.emit('warning', err)
+      }
+    }
+
+    if (updated) {
+      if (socket.setMulticastInterface) {
+        try {
+          socket.setMulticastInterface(opts.interface || defaultInterface())
+        } catch (err) {
+          that.emit('warning', err)
+        }
+      }
+      that.emit('networkInterface')
+    }
+  }
+
+  return that
+}
+
+function defaultInterface () {
+  var networks = os.networkInterfaces()
+  var names = Object.keys(networks)
+
+  for (var i = 0; i < names.length; i++) {
+    var net = networks[names[i]]
+    for (var j = 0; j < net.length; j++) {
+      var iface = net[j]
+      if (isIPv4(iface.family) && !iface.internal) {
+        if (os.platform() === 'darwin' && names[i] === 'en0') return iface.address
+        return '0.0.0.0'
+      }
+    }
+  }
+
+  return '127.0.0.1'
+}
+
+function allInterfaces () {
+  var networks = os.networkInterfaces()
+  var names = Object.keys(networks)
+  var res = []
+
+  for (var i = 0; i < names.length; i++) {
+    var net = networks[names[i]]
+    for (var j = 0; j < net.length; j++) {
+      var iface = net[j]
+      if (isIPv4(iface.family)) {
+        res.push(iface.address)
+        // could only addMembership once per interface (https://nodejs.org/api/dgram.html#dgram_socket_addmembership_multicastaddress_multicastinterface)
+        break
+      }
+    }
+  }
+
+  return res
+}
+
+function isIPv4 (family) { // for backwards compat
+  return family === 4 || family === 'IPv4'
+}

package/dist/src/web/frontend/node_modules/.multicast-dns-iKseM9bB/test.js

@@ -0,0 +1,260 @@
+var mdns = require('./')
+var tape = require('tape')
+var dgram = require('dgram')
+
+var port = function (cb) {
+  var s = dgram.createSocket('udp4')
+  s.bind(0, function () {
+    var port = s.address().port
+    s.on('close', function () {
+      cb(port)
+    })
+    s.close()
+  })
+}
+
+var configs = [
+  {ip: '127.0.0.1', multicast: false}
+  // {'interface': '127.0.0.1', multicast: true}
+]
+
+var tests = configs.map(function (config) {
+  return function (name, fn) {
+    tape(name, function (t) {
+      port(function (p) {
+        config.port = p
+        var dns = mdns(config)
+        dns.on('warning', function (e) {
+          t.error(e)
+        })
+        fn(dns, t)
+      })
+    })
+  }
+})
+
+tests.forEach(function (test) {
+  test('works', function (dns, t) {
+    t.plan(3)
+
+    dns.once('query', function (packet) {
+      t.same(packet.type, 'query')
+      dns.destroy(function () {
+        t.ok(true, 'destroys')
+      })
+    })
+
+    dns.query('hello-world', function () {
+      t.ok(true, 'flushed')
+    })
+  })
+
+  test('ANY query', function (dns, t) {
+    dns.once('query', function (packet) {
+      t.same(packet.questions.length, 1, 'one question')
+      t.same(packet.questions[0], {name: 'hello-world', type: 'ANY', class: 'IN'})
+      dns.destroy(function () {
+        t.end()
+      })
+    })
+
+    dns.query('hello-world', 'ANY')
+  })
+
+  test('A record', function (dns, t) {
+    dns.once('query', function (packet) {
+      t.same(packet.questions.length, 1, 'one question')
+      t.same(packet.questions[0], {name: 'hello-world', type: 'A', class: 'IN'})
+      dns.respond([{type: 'A', name: 'hello-world', ttl: 120, data: '127.0.0.1'}])
+    })
+
+    dns.once('response', function (packet) {
+      t.same(packet.answers.length, 1, 'one answer')
+      t.same(packet.answers[0], {type: 'A', name: 'hello-world', ttl: 120, data: '127.0.0.1', class: 'IN', flush: false})
+      dns.destroy(function () {
+        t.end()
+      })
+    })
+
+    dns.query('hello-world', 'A')
+  })
+
+  test('A record (two questions)', function (dns, t) {
+    dns.once('query', function (packet) {
+      t.same(packet.questions.length, 2, 'two questions')
+      t.same(packet.questions[0], {name: 'hello-world', type: 'A', class: 'IN'})
+      t.same(packet.questions[1], {name: 'hej.verden', type: 'A', class: 'IN'})
+      dns.respond([{type: 'A', name: 'hello-world', ttl: 120, data: '127.0.0.1'}, {
+        type: 'A',
+        name: 'hej.verden',
+        ttl: 120,
+        data: '127.0.0.2'
+      }])
+    })
+
+    dns.once('response', function (packet) {
+      t.same(packet.answers.length, 2, 'one answers')
+      t.same(packet.answers[0], {type: 'A', name: 'hello-world', ttl: 120, data: '127.0.0.1', class: 'IN', flush: false})
+      t.same(packet.answers[1], {type: 'A', name: 'hej.verden', ttl: 120, data: '127.0.0.2', class: 'IN', flush: false})
+      dns.destroy(function () {
+        t.end()
+      })
+    })
+
+    dns.query([{name: 'hello-world', type: 'A'}, {name: 'hej.verden', type: 'A'}])
+  })
+
+  test('AAAA record', function (dns, t) {
+    dns.once('query', function (packet) {
+      t.same(packet.questions.length, 1, 'one question')
+      t.same(packet.questions[0], {name: 'hello-world', type: 'AAAA', class: 'IN'})
+      dns.respond([{type: 'AAAA', name: 'hello-world', ttl: 120, data: 'fe80::5ef9:38ff:fe8c:ceaa'}])
+    })
+
+    dns.once('response', function (packet) {
+      t.same(packet.answers.length, 1, 'one answer')
+      t.same(packet.answers[0], {
+        type: 'AAAA',
+        name: 'hello-world',
+        ttl: 120,
+        data: 'fe80::5ef9:38ff:fe8c:ceaa',
+        class: 'IN',
+        flush: false
+      })
+      dns.destroy(function () {
+        t.end()
+      })
+    })
+
+    dns.query('hello-world', 'AAAA')
+  })
+
+  test('SRV record', function (dns, t) {
+    dns.once('query', function (packet) {
+      t.same(packet.questions.length, 1, 'one question')
+      t.same(packet.questions[0], {name: 'hello-world', type: 'SRV', class: 'IN'})
+      dns.respond([{
+        type: 'SRV',
+        name: 'hello-world',
+        ttl: 120,
+        data: {port: 11111, target: 'hello.world.com', priority: 10, weight: 12}
+      }])
+    })
+
+    dns.once('response', function (packet) {
+      t.same(packet.answers.length, 1, 'one answer')
+      t.same(packet.answers[0], {
+        type: 'SRV',
+        name: 'hello-world',
+        ttl: 120,
+        data: {port: 11111, target: 'hello.world.com', priority: 10, weight: 12},
+        class: 'IN',
+        flush: false
+      })
+      dns.destroy(function () {
+        t.end()
+      })
+    })
+
+    dns.query('hello-world', 'SRV')
+  })
+
+  test('TXT record', function (dns, t) {
+    var data = [Buffer.from('black box')]
+
+    dns.once('query', function (packet) {
+      t.same(packet.questions.length, 1, 'one question')
+      t.same(packet.questions[0], {name: 'hello-world', type: 'TXT', class: 'IN'})
+      dns.respond([{type: 'TXT', name: 'hello-world', ttl: 120, data: data}])
+    })
+
+    dns.once('response', function (packet) {
+      t.same(packet.answers.length, 1, 'one answer')
+      t.same(packet.answers[0], {type: 'TXT', name: 'hello-world', ttl: 120, data: data, class: 'IN', flush: false})
+      dns.destroy(function () {
+        t.end()
+      })
+    })
+
+    dns.query('hello-world', 'TXT')
+  })
+
+  test('TXT array record', function (dns, t) {
+    var data = ['black', 'box']
+
+    dns.once('query', function (packet) {
+      t.same(packet.questions.length, 1, 'one question')
+      t.same(packet.questions[0], {name: 'hello-world', type: 'TXT', class: 'IN'})
+      dns.respond([{type: 'TXT', name: 'hello-world', ttl: 120, data: data}])
+    })
+
+    dns.once('response', function (packet) {
+      t.same(packet.answers.length, 1, 'one answer')
+      t.same(packet.answers[0], {type: 'TXT', name: 'hello-world', ttl: 120, data: data, class: 'IN', flush: false})
+      dns.destroy(function () {
+        t.end()
+      })
+    })
+
+    dns.query('hello-world', 'TXT')
+  })
+
+  test('QU question bit', function (dns, t) {
+    dns.once('query', function (packet) {
+      t.same(packet.questions, [
+        {type: 'A', name: 'foo', class: 'IN'},
+        {type: 'A', name: 'bar', class: 'IN'}
+      ])
+      dns.destroy(function () {
+        t.end()
+      })
+    })
+
+    dns.query([
+      {type: 'A', name: 'foo', class: 'IN'},
+      {type: 'A', name: 'bar', class: 'IN'}
+    ])
+  })
+
+  test('cache flush bit', function (dns, t) {
+    dns.once('query', function (packet) {
+      dns.respond({
+        answers: [
+          {type: 'A', name: 'foo', ttl: 120, data: '127.0.0.1', class: 'IN', flush: true},
+          {type: 'A', name: 'foo', ttl: 120, data: '127.0.0.2', class: 'IN', flush: false}
+        ],
+        additionals: [
+          {type: 'A', name: 'foo', ttl: 120, data: '127.0.0.3', class: 'IN', flush: true}
+        ]
+      })
+    })
+
+    dns.once('response', function (packet) {
+      t.same(packet.answers, [
+        {type: 'A', name: 'foo', ttl: 120, data: '127.0.0.1', class: 'IN', flush: true},
+        {type: 'A', name: 'foo', ttl: 120, data: '127.0.0.2', class: 'IN', flush: false}
+      ])
+      t.same(packet.additionals[0], {type: 'A', name: 'foo', ttl: 120, data: '127.0.0.3', class: 'IN', flush: true})
+      dns.destroy(function () {
+        t.end()
+      })
+    })
+
+    dns.query('foo', 'A')
+  })
+
+  test('Authoritive Answer bit', function (dns, t) {
+    dns.once('query', function (packet) {
+      dns.respond([])
+    })
+
+    dns.once('response', function (packet) {
+      t.ok(packet.flag_aa, 'should be set')
+      dns.destroy(function () {
+        t.end()
+      })
+    })
+
+    dns.query('foo', 'A')
+  })
+})

package/dist/src/web/frontend/node_modules/.nanoid-PAMEV9Hd/async/index.browser.js

@@ -0,0 +1,34 @@
+let random = async bytes => crypto.getRandomValues(new Uint8Array(bytes))
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
+  let step = -~((1.6 * mask * defaultSize) / alphabet.length)
+  return async (size = defaultSize) => {
+    let id = ''
+    while (true) {
+      let bytes = crypto.getRandomValues(new Uint8Array(step))
+      let i = step | 0
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length === size) return id
+      }
+    }
+  }
+}
+let nanoid = async (size = 21) => {
+  let id = ''
+  let bytes = crypto.getRandomValues(new Uint8Array((size |= 0)))
+  while (size--) {
+    let byte = bytes[size] & 63
+    if (byte < 36) {
+      id += byte.toString(36)
+    } else if (byte < 62) {
+      id += (byte - 26).toString(36).toUpperCase()
+    } else if (byte < 63) {
+      id += '_'
+    } else {
+      id += '-'
+    }
+  }
+  return id
+}
+export { nanoid, customAlphabet, random }

package/dist/src/web/frontend/node_modules/.nanoid-PAMEV9Hd/async/index.js

@@ -0,0 +1,35 @@
+import crypto from 'crypto'
+import { urlAlphabet } from '../url-alphabet/index.js'
+let random = bytes =>
+  new Promise((resolve, reject) => {
+    crypto.randomFill(Buffer.allocUnsafe(bytes), (err, buf) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve(buf)
+      }
+    })
+  })
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+  let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+  let tick = (id, size = defaultSize) =>
+    random(step).then(bytes => {
+      let i = step
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length >= size) return id
+      }
+      return tick(id, size)
+    })
+  return size => tick('', size)
+}
+let nanoid = (size = 21) =>
+  random((size |= 0)).then(bytes => {
+    let id = ''
+    while (size--) {
+      id += urlAlphabet[bytes[size] & 63]
+    }
+    return id
+  })
+export { nanoid, customAlphabet, random }

package/dist/src/web/frontend/node_modules/.nanoid-PAMEV9Hd/async/index.native.js

@@ -0,0 +1,26 @@
+import { getRandomBytesAsync } from 'expo-random'
+import { urlAlphabet } from '../url-alphabet/index.js'
+let random = getRandomBytesAsync
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+  let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+  let tick = (id, size = defaultSize) =>
+    random(step).then(bytes => {
+      let i = step
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length >= size) return id
+      }
+      return tick(id, size)
+    })
+  return size => tick('', size)
+}
+let nanoid = (size = 21) =>
+  random((size |= 0)).then(bytes => {
+    let id = ''
+    while (size--) {
+      id += urlAlphabet[bytes[size] & 63]
+    }
+    return id
+  })
+export { nanoid, customAlphabet, random }

package/dist/src/web/frontend/node_modules/.nanoid-PAMEV9Hd/index.browser.js

@@ -0,0 +1,34 @@
+import { urlAlphabet } from './url-alphabet/index.js'
+let random = bytes => crypto.getRandomValues(new Uint8Array(bytes))
+let customRandom = (alphabet, defaultSize, getRandom) => {
+  let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
+  let step = -~((1.6 * mask * defaultSize) / alphabet.length)
+  return (size = defaultSize) => {
+    let id = ''
+    while (true) {
+      let bytes = getRandom(step)
+      let j = step | 0
+      while (j--) {
+        id += alphabet[bytes[j] & mask] || ''
+        if (id.length === size) return id
+      }
+    }
+  }
+}
+let customAlphabet = (alphabet, size = 21) =>
+  customRandom(alphabet, size, random)
+let nanoid = (size = 21) =>
+  crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {
+    byte &= 63
+    if (byte < 36) {
+      id += byte.toString(36)
+    } else if (byte < 62) {
+      id += (byte - 26).toString(36).toUpperCase()
+    } else if (byte > 62) {
+      id += '-'
+    } else {
+      id += '_'
+    }
+    return id
+  }, '')
+export { nanoid, customAlphabet, customRandom, urlAlphabet, random }