0x0-cli 1.0.0

package/src/web/api.js

@@ -0,0 +1,375 @@
+import { randomUUID } from 'crypto'
+import Hyperswarm from 'hyperswarm'
+import { channelSecret } from '../core/channel.js'
+import { createMessage, createFileMessage, parseMessage } from '../core/message.js'
+import { generatePin } from '../core/pin.js'
+import * as identityStore from '../storage/identity.js'
+import * as pinsStore from '../storage/pins.js'
+import * as messagesStore from '../storage/messages.js'
+import * as contactsStore from '../storage/contacts.js'
+
+export function createApiHandler(ws) {
+  const connections = new Map()        // pinId → { swarm, conn }
+  const contactConnections = new Map() // contactId → { swarm, conn }
+  const messageQueue = new Map()       // pinId → [{ id, content, timestamp }]
+
+  function sendEvent(event, payload = {}) {
+    if (ws.readyState !== ws.OPEN) return
+    ws.send(JSON.stringify({ event, ...payload }))
+  }
+
+  // 接続確立時に初期データを送信
+  const identity = identityStore.load()
+  if (identity) {
+    sendEvent('init', { data: {
+      number: identity.number,
+      inbox: buildInbox(),
+      contacts: buildContacts(),
+      prefs: { theme: 'dark' }
+    }})
+  }
+
+  ws.on('message', async (raw) => {
+    let msg
+    try { msg = JSON.parse(raw.toString()) } catch { return }
+    await dispatch(msg)
+  })
+
+  ws.on('close', async () => {
+    for (const { swarm } of connections.values()) {
+      await swarm.destroy().catch(() => {})
+    }
+    for (const { swarm } of contactConnections.values()) {
+      await swarm.destroy().catch(() => {})
+    }
+    connections.clear()
+    contactConnections.clear()
+  })
+
+  async function dispatch(msg) {
+    const { cmd, pinId, content, label, expiry, key, value } = msg
+
+    switch (cmd) {
+      case 'inbox.list':
+        sendEvent('inbox.list', { data: buildInbox() })
+        break
+
+      case 'messages.list': {
+        const pin = pinsStore.findById(pinId)
+        if (!pin) return
+        const msgs = messagesStore.list(pin.value)
+        sendEvent('messages.list', { pinId, data: msgs })
+        // まだ接続していなければ開始
+        if (!connections.has(pinId)) await openConnection(pin)
+        break
+      }
+
+      case 'message.send': {
+        const pin = pinsStore.findById(pinId)
+        if (!pin) return
+        const localId = msg.localId || randomUUID()
+        const entry = connections.get(pinId)
+        if (!entry?.conn) {
+          const pending = messageQueue.get(pinId) || []
+          pending.push({ id: localId, content, timestamp: Date.now() })
+          messageQueue.set(pinId, pending)
+          sendEvent('message.queued', { pinId, localId })
+          break
+        }
+        entry.conn.write(createMessage(content))
+        const senderIdentity = identityStore.load()
+        messagesStore.append(pin.value, { from: senderIdentity.number, content, isMine: true })
+        sendEvent('message.sent', { pinId, localId, data: { content, isMine: true, timestamp: Date.now(), status: 'delivered' } })
+        break
+      }
+
+      case 'pin.create': {
+        const { expiry: exp = 'none', expiresAt = null } = parseExpiry(expiry)
+        const value = generatePin()
+        const pin = pinsStore.create({ value, label: label || '', expiry: exp, expiresAt })
+        sendEvent('pin.created', { data: pin })
+        sendEvent('inbox.list', { data: buildInbox() })
+        break
+      }
+
+      case 'pin.rotate': {
+        const pin = pinsStore.findById(pinId)
+        if (!pin) return
+        pinsStore.rotate(pin.id, generatePin())
+        await destroyConnection(pinId)
+        sendEvent('pin.rotated', { pinId, data: pinsStore.findById(pinId) })
+        sendEvent('inbox.list', { data: buildInbox() })
+        break
+      }
+
+      case 'pin.revoke': {
+        const pin = pinsStore.findById(pinId)
+        if (!pin) return
+        pinsStore.revoke(pin.id)
+        await destroyConnection(pinId)
+        sendEvent('pin.revoked', { pinId })
+        sendEvent('inbox.list', { data: buildInbox() })
+        break
+      }
+
+      case 'number.renew': {
+        const identity = identityStore.load()
+        if (!identity) return
+        const pins = pinsStore.getActive()
+        for (const p of pins) pinsStore.revoke(p.id)
+        for (const { swarm } of connections.values()) await swarm.destroy().catch(() => {})
+        connections.clear()
+        const { generateNumber } = await import('../core/identity.js')
+        const newNumber = generateNumber()
+        identityStore.save({ ...identity, number: newNumber, renewedAt: Date.now() })
+        sendEvent('number.renewed', { data: { number: newNumber } })
+        break
+      }
+
+      case 'prefs.set':
+        // 将来: プリファレンス保存
+        break
+
+      case 'notify.register': {
+        const { token, platform } = msg
+        if (!token || !platform) break
+        const notifyIdentity = identityStore.load()
+        if (!notifyIdentity) break
+        await fetch('https://0x0-notification.tiidatech.workers.dev/register', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ number: notifyIdentity.number, token, platform })
+        }).catch(() => {})
+        sendEvent('notify.registered', {})
+        break
+      }
+
+      case 'notify.unregister': {
+        const unregIdentity = identityStore.load()
+        if (!unregIdentity) break
+        await fetch('https://0x0-notification.tiidatech.workers.dev/register', {
+          method: 'DELETE',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ number: unregIdentity.number })
+        }).catch(() => {})
+        sendEvent('notify.unregistered', {})
+        break
+      }
+
+      case 'file.send': {
+        const { filename, mimeType, dataBase64 } = msg
+        const filePin = pinsStore.findById(pinId)
+        if (!filePin) break
+        const fileEntry = connections.get(pinId)
+        if (!fileEntry?.conn) break
+        fileEntry.conn.write(createFileMessage(filename, mimeType, dataBase64))
+        const fileIdentity = identityStore.load()
+        messagesStore.append(filePin.value, {
+          from: fileIdentity.number, type: 'file', filename, mimeType, isMine: true
+        })
+        sendEvent('file.sent', { pinId, data: { filename, mimeType, isMine: true, timestamp: Date.now() } })
+        break
+      }
+
+      case 'chat.start': {
+        const { theirNumber, theirPin, label: cLabel } = msg
+        if (!theirNumber || !theirPin) return
+        const contact = contactsStore.create({ theirNumber, theirPin, label: cLabel || '' })
+        sendEvent('chat.started', { contactId: contact.id, data: contact })
+        sendEvent('contacts.list', { data: buildContacts() })
+        const cMsgs = messagesStore.list(contact.theirPin)
+        sendEvent('contact.messages.list', { contactId: contact.id, data: cMsgs })
+        if (!contactConnections.has(contact.id)) await openContactConnection(contact)
+        break
+      }
+
+      case 'contact.message.send': {
+        const { contactId, content: cContent } = msg
+        const contact = contactsStore.findById(contactId)
+        if (!contact) return
+        const cEntry = contactConnections.get(contactId)
+        if (!cEntry?.conn) return
+        cEntry.conn.write(createMessage(cContent))
+        const me = identityStore.load()
+        messagesStore.append(contact.theirPin, { from: me.number, content: cContent, isMine: true })
+        sendEvent('contact.message.sent', { contactId, data: { content: cContent, isMine: true, timestamp: Date.now() } })
+        // 相手に通知を送る（バックグラウンド、失敗は無視）
+        fetch('https://0x0-notification.tiidatech.workers.dev/notify', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ recipientNumber: contact.theirNumber })
+        }).catch(() => {})
+        break
+      }
+
+      case 'contacts.list':
+        sendEvent('contacts.list', { data: buildContacts() })
+        break
+
+      case 'contact.label': {
+        const { contactId, label: newLabel } = msg
+        contactsStore.updateLabel(contactId, newLabel || '')
+        sendEvent('contacts.list', { data: buildContacts() })
+        break
+      }
+
+      case 'contact.remove': {
+        const { contactId: removeId } = msg
+        if (contactConnections.has(removeId)) {
+          const { swarm } = contactConnections.get(removeId)
+          await swarm.destroy().catch(() => {})
+          contactConnections.delete(removeId)
+        }
+        contactsStore.remove(removeId)
+        sendEvent('contact.removed', { contactId: removeId })
+        sendEvent('contacts.list', { data: buildContacts() })
+        break
+      }
+    }
+  }
+
+  async function openConnection(pin) {
+    const identity = identityStore.load()
+    if (!identity) return
+
+    const swarm = new Hyperswarm()
+    const topic = channelSecret(identity.number, pin.value)
+    connections.set(pin.id, { swarm, conn: null })
+
+    sendEvent('peer.status', { pinId: pin.id, status: 'connecting' })
+
+    swarm.join(topic, { server: true, client: true })
+
+    swarm.on('connection', (conn) => {
+      const entry = connections.get(pin.id)
+      if (entry) entry.conn = conn
+
+      sendEvent('peer.status', { pinId: pin.id, status: 'connected' })
+      flushMessageQueue(pin, conn)
+
+      conn.on('data', (data) => {
+        const msg = parseMessage(data)
+        if (!msg) return
+
+        if (msg.type === 'message') {
+          messagesStore.append(pin.value, {
+            from: 'peer', content: msg.content, isMine: false
+          })
+          sendEvent('message.received', {
+            pinId: pin.id,
+            data: { content: msg.content, isMine: false, timestamp: Date.now() }
+          })
+        } else if (msg.type === 'file') {
+          messagesStore.append(pin.value, {
+            from: 'peer', type: 'file', filename: msg.filename, mimeType: msg.mimeType, isMine: false
+          })
+          sendEvent('file.received', {
+            pinId: pin.id,
+            data: {
+              filename: msg.filename,
+              mimeType: msg.mimeType,
+              dataBase64: msg.data,
+              isMine: false,
+              timestamp: Date.now()
+            }
+          })
+        }
+      })
+
+      conn.on('close', () => {
+        const entry = connections.get(pin.id)
+        if (entry) entry.conn = null
+        sendEvent('peer.status', { pinId: pin.id, status: 'disconnected' })
+      })
+    })
+  }
+
+  async function destroyConnection(pinId) {
+    if (!connections.has(pinId)) return
+    const { swarm } = connections.get(pinId)
+    await swarm.destroy().catch(() => {})
+    connections.delete(pinId)
+  }
+
+  function flushMessageQueue(pin, conn) {
+    const pending = messageQueue.get(pin.id)
+    if (!pending || pending.length === 0) return
+    const senderIdentity = identityStore.load()
+    for (const queued of pending) {
+      conn.write(createMessage(queued.content))
+      if (senderIdentity) messagesStore.append(pin.value, { from: senderIdentity.number, content: queued.content, isMine: true })
+      sendEvent('message.delivered', { pinId: pin.id, localId: queued.id })
+    }
+    messageQueue.delete(pin.id)
+  }
+
+  function buildInbox() {
+    const pins = pinsStore.getActive()
+    return pins.map(pin => {
+      const msgs = messagesStore.list(pin.value)
+      const latest = msgs[msgs.length - 1] || null
+      const unread = msgs.filter(m => !m.isMine).length
+      return { ...pin, messageCount: msgs.length, unread, latest }
+    })
+  }
+
+  function buildContacts() {
+    return contactsStore.loadAll().map(c => {
+      const msgs = messagesStore.list(c.theirPin)
+      const latest = msgs[msgs.length - 1] || null
+      const unread = msgs.filter(m => !m.isMine).length
+      return { ...c, messageCount: msgs.length, unread, latest }
+    })
+  }
+
+  async function openContactConnection(contact) {
+    const swarm = new Hyperswarm()
+    const topic = channelSecret(contact.theirNumber, contact.theirPin)
+    contactConnections.set(contact.id, { swarm, conn: null })
+
+    sendEvent('peer.status', { contactId: contact.id, status: 'connecting' })
+
+    swarm.join(topic, { server: false, client: true })
+
+    swarm.on('connection', (conn) => {
+      const entry = contactConnections.get(contact.id)
+      if (entry) entry.conn = conn
+
+      sendEvent('peer.status', { contactId: contact.id, status: 'connected' })
+
+      conn.on('data', (data) => {
+        const msg = parseMessage(data)
+        if (!msg || msg.type !== 'message') return
+
+        messagesStore.append(contact.theirPin, {
+          from: contact.theirNumber, content: msg.content, isMine: false
+        })
+
+        sendEvent('contact.message.received', {
+          contactId: contact.id,
+          data: { content: msg.content, isMine: false, timestamp: Date.now() }
+        })
+      })
+
+      conn.on('error', () => {})
+
+      conn.on('close', () => {
+        const entry = contactConnections.get(contact.id)
+        if (entry) entry.conn = null
+        sendEvent('peer.status', { contactId: contact.id, status: 'disconnected' })
+      })
+    })
+  }
+}
+
+function parseExpiry(expires) {
+  if (!expires || expires === 'none') return { expiry: 'none', expiresAt: null }
+  const match = expires.match(/^(\d+)(h|d|w)$/)
+  if (!match) return { expiry: expires, expiresAt: null }
+  const num = parseInt(match[1])
+  const unit = match[2]
+  const ms = unit === 'h' ? num * 3_600_000
+           : unit === 'd' ? num * 86_400_000
+           : num * 7 * 86_400_000
+  return { expiry: expires, expiresAt: Date.now() + ms }
+}

package/src/web/server.js

@@ -0,0 +1,52 @@
+import http from 'http'
+import os from 'os'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import express from 'express'
+import { WebSocketServer } from 'ws'
+import { createApiHandler } from './api.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const DIST = path.resolve(__dirname, '../../dist/web')
+
+export async function startWebServer(port = 3000) {
+  const app = express()
+
+  // ビルド済みフロントエンド配信
+  app.use(express.static(DIST))
+  app.get('*', (_req, res) => res.sendFile(path.join(DIST, 'index.html')))
+
+  const server = http.createServer(app)
+
+  // WebSocket: LAN 全体から受け付ける
+  const wss = new WebSocketServer({ server })
+  wss.on('connection', (ws) => {
+    createApiHandler(ws)
+  })
+
+  return new Promise((resolve, reject) => {
+    server.listen(port, '0.0.0.0', () => {
+      resolve({ server, wss, port })
+    })
+    server.on('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        resolve(startWebServer(port + 1))
+      } else {
+        reject(err)
+      }
+    })
+  })
+}
+
+export function getLanIps() {
+  const interfaces = os.networkInterfaces()
+  const ips = []
+  for (const iface of Object.values(interfaces)) {
+    for (const entry of iface ?? []) {
+      if (entry.family === 'IPv4' && !entry.internal) {
+        ips.push(entry.address)
+      }
+    }
+  }
+  return ips
+}