heyquilt 0.0.1 → 0.3.90

package/src/relay-webhooks.js

@@ -0,0 +1,111 @@
+// Webhooks for hosted agents, delivered by the relay: it holds every hosted agent's one
+// subscription (in hosted-agents.json, beside the sessions the agent is in), watches each
+// room's chat and task board, and POSTs to the agent when it is mentioned, sent a direct
+// message or handed a task in any of them (see webhooks.js); each POST says which session
+// and workspace it is from. Delivery from the relay works even when the agent itself is
+// asleep, which is the point: its webhook wakes it.
+//
+// The subscription keeps its own inbox state per session (what it has already been told),
+// separate from quilt_inbox's, so a POSTed event still shows there when the agent asks.
+import { scanInbox } from './inbox.js'
+import { hostedIn, newHosted } from './hosted-agents.js'
+import { readTasks } from './tasks.js'
+import { deliverEvents, makeSubscription } from './webhooks.js'
+import { withContext } from './conversation.js'
+
+/** The chat `me` can see: public messages, and direct ones to or from them. */
+const chatFor = (doc, me) => doc.getArray('chat').toArray().filter((m) => m && m.id && (!m.to || m.to === me || m.by === me))
+
+/** Each event with the conversation before it, from the room's kept chat (chat-archive.js) when it has one. */
+const inContext = (room, me, events) => {
+  const all = room.chatArchive ? room.chatArchive.with(room.doc.getArray('chat').toArray()) : room.doc.getArray('chat').toArray()
+  return withContext(events, all.filter((m) => m && m.id && (!m.to || m.to === me || m.by === me)), { names: [me], agent: true })
+}
+
+const scan = (doc, name, state) => scanInbox({ messages: chatFor(doc, name), tasks: readTasks(doc.getMap('tasks')), reader: { name, asAi: false, agent: true } }, state)
+
+/**
+ * `hosted` is the relay's map of hosted agents (account id -> { room, ..., webhook? });
+ * `saveHosted` writes it. `fetch` and `delays` are for tests.
+ */
+export function hostedWebhooks ({ hosted, saveHosted, log = () => {}, fetch, delays } = {}) {
+  const sending = new Map() // account -> the delivery in flight, so one agent's POSTs keep their order
+  const watched = new WeakSet()
+  const opts = { log, ...(fetch ? { fetch } : {}), ...(delays ? { delays } : {}) }
+
+  /** Looks for new events in `room` for every subscribed hosted agent in it, and POSTs them. */
+  const check = (room) => {
+    let changed = false
+    for (const [account, h] of hosted) {
+      const sub = h && h.webhook
+      const r = sub && hostedIn(h, room.name)
+      if (!r) continue
+      // Only a member gets told: an agent still waiting to be let in sees nothing yet.
+      if (room.controlled && !room.meta.members[account]) continue
+      // A session the subscription has not taken stock of yet (joined while the room was not loaded,
+      // or an entry from before this relay): what is already there is not news.
+      if (r.webhookState === undefined) { r.webhookState = scan(room.doc, sub.name, null).state; changed = true; continue }
+      const got = scan(room.doc, sub.name, r.webhookState)
+      r.webhookState = got.state
+      changed = true
+      if (!got.events.length) continue
+      const events = inContext(room, sub.name, got.events)
+      const prev = sending.get(account) || Promise.resolve()
+      const next = prev.then(() => deliverEvents(sub, events, { room: room.name, to: sub.name, workspace: room.meta.workspace || '' }, opts)).catch(() => {})
+      sending.set(account, next)
+      next.then(() => { if (sending.get(account) === next) sending.delete(account) })
+    }
+    if (changed) saveHosted()
+  }
+
+  /** Watches a room's chat and board; safe to call more than once for the same room. */
+  const watch = (room) => {
+    if (watched.has(room)) return
+    watched.add(room)
+    const run = () => { try { check(room) } catch (err) { log(`[${room.name}] webhooks: ${err.message}`) } }
+    room.doc.getArray('chat').observe(run)
+    room.doc.getMap('tasks').observeDeep(run)
+  }
+
+  /**
+   * Makes `account` (named `name`) its one subscription from what the agent gave, taking stock
+   * of every session it is in (`rooms`: the loaded ones) so nothing already there is POSTed.
+   * Returns it.
+   */
+  const subscribe = (account, { name, rooms = [] }, given) => {
+    // Set before any session too (a workspace agent waits for session.started): the entry starts here.
+    let h = hosted.get(account)
+    if (!h) { h = newHosted(); hosted.set(account, h) }
+    const sub = makeSubscription(given)
+    h.webhook = { url: sub.url, secret: sub.secret, events: sub.events, since: sub.since, name, ...(sub.bearer ? { bearer: sub.bearer } : {}) }
+    for (const r of Object.values(h.rooms || {})) delete r.webhookState
+    for (const room of rooms) takeStock(account, room)
+    saveHosted()
+    return { ...h.webhook, made: sub.made }
+  }
+
+  /** The agent joined `room` (again): what is there already is not news to its webhook. */
+  const takeStock = (account, room) => {
+    const h = hosted.get(account)
+    const r = h && h.webhook && hostedIn(h, room.name)
+    if (!r) return
+    r.webhookState = scan(room.doc, h.webhook.name, null).state
+    saveHosted()
+  }
+
+  const unsubscribe = (account) => {
+    const h = hosted.get(account)
+    const had = !!(h && h.webhook)
+    if (had) {
+      delete h.webhook
+      for (const r of Object.values(h.rooms || {})) delete r.webhookState
+      saveHosted()
+    }
+    return had
+  }
+
+  /** Waits for every POST in flight (tests, shutdown). */
+  const idle = () => Promise.all([...sending.values()])
+
+  return { check, watch, subscribe, takeStock, unsubscribe, idle }
+}

package/src/releases.js

@@ -0,0 +1,131 @@
+// Release notes and the update check. RELEASES.md (shipped with the app) says what changed
+// in each version; GitHub's latest release says whether a newer build exists.
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { getSettings, saveSettings } from './settings.js'
+
+export const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+export const REPO = 'DanielCarmichaelGit/heyquilt'
+const LATEST_API = `https://api.github.com/repos/${REPO}/releases/latest`
+const RELEASES_PAGE = `https://github.com/${REPO}/releases`
+const CACHE_MS = 10 * 60 * 1000
+
+/** The version this app is, from package.json. */
+export function currentVersion () {
+  return JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf8')).version
+}
+
+/**
+ * The sections of a RELEASES.md: [{ version, date, summary, items }], in file order.
+ * A section starts at `## <version> — <date>`; its first plain line is the summary and
+ * its `- ` lines are the items. Anything before the first section is ignored.
+ */
+export function parseReleases (md) {
+  const out = []
+  let cur = null
+  for (const raw of String(md).split(/\r?\n/)) {
+    const line = raw.trimEnd()
+    const head = line.match(/^## +v?(\d+\.\d+\.\d+)\s*(?:[—–-]+\s*(\d{4}-\d{2}-\d{2}))?\s*$/)
+    if (head) { cur = { version: head[1], date: head[2] || '', summary: '', items: [] }; out.push(cur); continue }
+    if (!cur) continue
+    const item = line.match(/^[-*] +(.*)$/)
+    if (item) cur.items.push(item[1].trim())
+    else if (line.trim() && !cur.items.length && !cur.summary && !/^#/.test(line)) cur.summary = line.trim()
+  }
+  return out
+}
+
+let local = null
+/** The releases listed in this app's RELEASES.md, newest first. */
+export function localReleases () {
+  if (local) return local
+  let md = ''
+  try { md = fs.readFileSync(path.join(ROOT, 'RELEASES.md'), 'utf8') } catch {}
+  local = parseReleases(md).sort((a, b) => compareVersions(b.version, a.version))
+  return local
+}
+
+/** Semver order: negative when a < b, 0 when equal, positive when a > b. Unparseable versions sort lowest. */
+export function compareVersions (a, b) {
+  const num = (v) => { const m = String(v || '').match(/(\d+)\.(\d+)\.(\d+)/); return m ? m.slice(1, 4).map(Number) : null }
+  const x = num(a); const y = num(b)
+  if (!x && !y) return 0
+  if (!x) return -1
+  if (!y) return 1
+  for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i] - y[i]
+  return 0
+}
+
+/** Where to get the newest build for this computer. */
+export function downloadUrl (platform = process.platform, arch = process.arch) {
+  const file = platform === 'darwin' ? `quilt-mac-${arch === 'arm64' ? 'arm64' : 'x64'}.dmg`
+    : platform === 'win32' ? 'quilt-windows-x64.exe'
+      : platform === 'linux' ? `quilt-linux-${arch === 'arm64' ? 'arm64' : 'x86_64'}.AppImage`
+        : null
+  return file ? `${RELEASES_PAGE}/latest/download/${file}` : `${RELEASES_PAGE}/latest`
+}
+
+/** The notes inside a GitHub release body written by releaseNotesBody (or by hand in that shape). */
+function parseGitHubBody (body) {
+  const text = String(body || '').split(/\n\*\*Downloads\*\*/)[0].replace(/^\*\*What's new in [^*]*\*\*\s*/i, '')
+  const r = parseReleases(`## 0.0.0\n${text}`)[0] || { summary: '', items: [] }
+  return { summary: r.summary, items: r.items }
+}
+
+const cache = new Map() // url -> { at, release }
+/**
+ * The newest release on GitHub: { version, url, date, summary, items }, or null when it can't be
+ * reached and nothing is cached. Asks at most every ten minutes; a failed refresh keeps the last answer.
+ */
+export async function latestRelease ({ url = process.env.QUILT_RELEASES_URL || LATEST_API, now = Date.now, timeoutMs = 6000 } = {}) {
+  const hit = cache.get(url)
+  if (hit && now() - hit.at < CACHE_MS) return hit.release
+  try {
+    const res = await fetch(url, { headers: { accept: 'application/vnd.github+json', 'user-agent': `quilt/${currentVersion()}` }, signal: AbortSignal.timeout(timeoutMs) })
+    if (!res.ok) throw new Error(`GitHub answered ${res.status}`)
+    const r = await res.json()
+    const version = String(r.tag_name || '').replace(/^v/, '')
+    if (!/^\d+\.\d+\.\d+$/.test(version)) throw new Error('no version in the release')
+    const release = { version, url: r.html_url || `${RELEASES_PAGE}/tag/v${version}`, date: String(r.published_at || '').slice(0, 10), ...parseGitHubBody(r.body) }
+    cache.set(url, { at: now(), release })
+    return release
+  } catch {
+    if (hit) { hit.at = now(); return hit.release } // try again in ten minutes
+    return null
+  }
+}
+
+/** The last version whose notes this computer has seen. */
+export function seenVersion () { return String(getSettings().seenRelease || '') }
+export function markSeen (version) { saveSettings({ seenRelease: String(version || '') }) }
+
+// "Don't show this again" on the update bar: the newer release it was said for. Kept in the
+// settings file, not the page's storage (the app's address changes every launch), and only
+// for that release: a newer one shows the bar again.
+export function hiddenUpdate () { return String(getSettings().hiddenUpdate || '') }
+export function hideUpdate (version) {
+  const v = String(version || '')
+  if (!/^\d+\.\d+\.\d+$/.test(v)) throw new Error('that is not a version')
+  saveSettings({ hiddenUpdate: v })
+}
+
+/** The GitHub release body for a RELEASES.md section: the notes, then where to download. */
+export function releaseNotesBody (release) {
+  const lines = [`**What's new in ${release.version}**`, '']
+  if (release.summary) lines.push(release.summary, '')
+  for (const it of release.items) lines.push(`- ${it}`)
+  lines.push('', '**Downloads**',
+    '- Mac (Apple silicon): quilt-mac-arm64.dmg',
+    '- Mac (Intel): quilt-mac-x64.dmg',
+    '- Windows: quilt-windows-x64.exe',
+    '- Linux desktop: quilt-linux-x86_64.AppImage (Intel/AMD), quilt-linux-arm64.AppImage (ARM)',
+    `- Linux servers and cloud machines (no desktop): \`curl -fsSL ${RELEASES_PAGE}/latest/download/install.sh | sh\``,
+    '',
+    '**Note on signing:** these builds are unsigned (no Apple Developer ID / notarization, no Windows code-signing certificate configured). Windows SmartScreen or macOS Gatekeeper may warn on first launch.',
+    '',
+    '- **macOS:** if you see "Apple could not verify Quilt is free of malware," click **Done**, then open **System Settings → Privacy & Security**, scroll down and click **Open Anyway** next to Quilt. You only need to do this once. (On older macOS you can instead right-click the app and choose **Open**.)',
+    '- **Windows:** if SmartScreen shows "Windows protected your PC," click **More info**, then **Run anyway**.',
+    '- **Linux:** make the AppImage runnable (`chmod +x quilt-linux-*.AppImage`) and open it. If it says FUSE is missing, install `libfuse2` (or run it with `--appimage-extract-and-run`).')
+  return lines.join('\n') + '\n'
+}

package/src/report.js

@@ -0,0 +1,129 @@
+// src/report.js
+// Tells Quilt what went wrong in the app (and how long actions took) so problems can be
+// found without anyone filing them. Batches reports to the accounts API, scrubs anything
+// personal first, and never gets in the way: it drops rather than retries, and never throws.
+import { apiUrl } from './account.js'
+import { currentVersion } from './releases.js'
+
+// A path on this computer says who you are and how your disk is laid out; its last part
+// (the project folder, the app) is all a report needs. A directory segment may be a few
+// space-joined words of its own ("Program Files (x86)"), so each segment allows up to four.
+// A UNC path (\\server\share\...) is a root of its own kind, same treatment.
+const PATH = /(?:~|[A-Za-z]:|\/(?:Users|home|private|tmp|var|opt|Applications|Volumes|root|mnt|srv|data|workspace)|\\\\[^\s\\]+)(?:[\\/][^\s'"`:,\\/]+(?: [^\s'"`:,\\/]+){0,3})*/g
+// Every token prefix Quilt mints: qd_ (device), qa_/qr_ (agent access/refresh), dc_ (device
+// code), qi_ (org invite), qj_ (agent join). No \b: `_` is a word character, so `\b` would miss
+// a token straight after an underscore (`_qd_...`); instead, the character right before the
+// prefix (if any) just has to not be alphanumeric, and that character is kept in the output.
+const TOKEN = /(?:^|[^A-Za-z0-9])((?:qd|qa|qr|dc|qi|qj)_[A-Za-z0-9_-]+)/g
+// join.heyquilt.com and quilt:// links; also the older/relay form of an invite link, any host,
+// where the secret lives after a `#` on a `/join/...` path.
+const INVITE = /(?:https?:\/\/join\.heyquilt\.com\/[^\s'"`]+|quilt:\/\/[^\s'"`]+|\/join\/[^\s#'"`]+#\S+)/g
+// A username:password (or token) embedded in a URL, e.g. https://x-access-token:ghp_x@github.com/.
+const CREDS = /:\/\/[^/\s:@]+:[^@\s]+@/g
+// GitHub tokens (classic and fine-grained) and JWTs (a Bearer token, including Supabase's).
+const SECRET = /\b(?:gh[pousr]_|github_pat_)\w+|eyJ[\w-]+\.[\w-]+\.[\w-]+/g
+
+/** `text` with paths cut to their last part, and tokens, credentials and invite links hidden. */
+export function scrub (text) {
+  return String(text ?? '')
+    .replace(INVITE, '[invite]')
+    .replace(CREDS, '://[secret]@')
+    .replace(SECRET, '[secret]')
+    .replace(TOKEN, (m, token) => m.slice(0, m.length - token.length) + '[secret]')
+    // PATH can absorb a few words of trailing prose past the path's last separator (nothing
+    // stops it there) — that's harmless: .pop() returns whatever follows the last separator
+    // verbatim, spaces and all, so absorbed prose comes back unchanged. The safety invariant
+    // lives here, in the replacement, not in how precisely the regex draws the line.
+    .replace(PATH, (m) => m.split(/[\\/]/).filter(Boolean).pop() || '[path]')
+}
+
+const scrubContext = (c) => Object.fromEntries(Object.entries(c && typeof c === 'object' ? c : {}).map(([k, v]) => [k, typeof v === 'string' ? scrub(v) : v]))
+
+export function createReporter ({
+  token = () => null, enabled = () => true, fetch = globalThis.fetch, api = apiUrl(), version = currentVersion(), platform = process.platform,
+  now = Date.now, setTimer = setTimeout, clearTimer = clearTimeout,
+  batchSize = 20, delayMs = 10_000, maxWaiting = 50, backoffMs = 60_000, log = () => {}
+} = {}) {
+  let waiting = []
+  let timer = null
+  let pausedUntil = 0
+  let inflight = null
+  let closed = false
+
+  function record (event) {
+    try {
+      if (closed || !enabled()) return
+      const { kind, name, outcome = 'ok', status, durationMs, message = '', context = {} } = event || {}
+      waiting.push({ kind, name: String(name || '').slice(0, 80), outcome, status, durationMs, message: scrub(message).slice(0, 500), context: scrubContext(context), occurredAt: now() })
+      if (waiting.length > maxWaiting) waiting.splice(0, waiting.length - maxWaiting)
+      if (waiting.length >= batchSize) send()
+      else schedule()
+    } catch {}
+  }
+
+  function schedule () {
+    if (closed || timer || !waiting.length) return
+    const delay = Math.max(delayMs, pausedUntil - now())
+    timer = setTimer(() => { timer = null; send() }, delay)
+  }
+
+  // Dropped, not retried: a report is never worth a retry storm. One quiet line.
+  function fail (err) {
+    pausedUntil = now() + backoffMs
+    log(`issue report not sent: ${err?.message || err}`)
+  }
+
+  function send () {
+    if (inflight || !waiting.length) return
+    if (now() < pausedUntil) return schedule()
+    if (timer) { clearTimer(timer); timer = null }
+    const events = waiting.splice(0, batchSize)
+    try {
+      const t = token()
+      inflight = Promise.resolve().then(() => fetch(`${api}/v1/issues`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', ...(t ? { authorization: `Bearer ${t}` } : {}) },
+        body: JSON.stringify({ surface: 'app', appVersion: version, platform, events })
+      })).then((res) => {
+        if (!res || !res.ok) throw new Error(`Quilt answered ${res && res.status}`)
+      }).catch(fail).finally(() => {
+        inflight = null
+        if (waiting.length) schedule()
+      })
+      return inflight
+    } catch (err) {
+      // token() (or anything else synchronous above) threw before any request went out:
+      // the batch taken off `waiting` is still dropped, same as a failed send.
+      fail(err)
+      if (waiting.length) schedule()
+    }
+  }
+
+  /**
+   * Sends what is waiting now, batch after batch, until nothing is left or `timeoutMs` runs
+   * out. If a send has nothing to wait on — paused by backoff, or nothing left to send — it
+   * stops right there rather than spin: at shutdown a failed batch is dropped, not retried,
+   * same as any other time.
+   */
+  async function flush ({ timeoutMs = 2000 } = {}) {
+    const deadline = Date.now() + timeoutMs
+    pausedUntil = 0
+    while ((waiting.length || inflight) && Date.now() < deadline) {
+      const step = inflight || send()
+      if (!step) break
+      let timeoutId
+      const timeout = new Promise((res) => { timeoutId = setTimeout(res, Math.max(0, deadline - Date.now())) })
+      await Promise.race([step, timeout]).catch(() => {})
+      clearTimeout(timeoutId)
+    }
+  }
+
+  /** Stops any future scheduling and flushes what is left, so shutdown never leaves a timer armed. */
+  function close () {
+    closed = true
+    if (timer) { clearTimer(timer); timer = null }
+    return flush()
+  }
+
+  return { record, flush, close, waiting: () => waiting.length }
+}