heyquilt 0.0.1 → 0.3.90

package/src/agents/cursor.js

@@ -0,0 +1,404 @@
+// Reads Cursor's AI chat ("composer") history for one project folder. Cursor
+// keeps it in SQLite: the workspace's state.vscdb (and, in newer versions, the
+// global ItemTable or the composerHeaders table) lists the conversations, and
+// the global cursorDiskKV table holds each conversation's message order and
+// each message ("bubble"). Opened read-only.
+//
+// Cursor writes these databases many times a second while it streams a reply,
+// so reads can briefly fail with "database is locked". Those are retried on
+// the next poll; only a storage layout we don't recognize stops the reader.
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { describeAction } from './actions.js'
+import { capText } from './common.js'
+
+const POLL_MS = 1000
+const WORKING_MS = 10000
+const BACKFILL_MS = 60 * 60 * 1000
+const BACKFILL_ENTRIES = 50
+const SETTLE_MS = 2500 // a still-streaming bubble is shared once it stops changing
+const ACTIVE_COUNT = 6 // most recent conversations read on every change
+const HOT_MS = 30 * 60 * 1000 // conversations that changed this recently are always read
+const RESCAN_MS = 30 * 1000 // look for (new) Cursor workspaces for this folder
+const BUSY_TIMEOUT_MS = 200 // node:sqlite is synchronous: never block the process for long
+const BUSY_LOG_AFTER = 30 // consecutive locked polls before saying so
+
+export function cursorUserDir (home = os.homedir()) {
+  if (process.platform === 'darwin') return path.join(home, 'Library', 'Application Support', 'Cursor', 'User')
+  if (process.platform === 'win32') return path.join(process.env.APPDATA || path.join(home, 'AppData', 'Roaming'), 'Cursor', 'User')
+  return path.join(home, '.config', 'Cursor', 'User')
+}
+
+const caseless = process.platform === 'darwin' || process.platform === 'win32'
+function norm (p) {
+  let r = path.resolve(p)
+  try { r = fs.realpathSync.native(r) } catch {}
+  r = r.replace(/[\\/]+$/, '') || r
+  return caseless ? r.toLowerCase() : r
+}
+
+/** Local folder a workspace/URI value points at, or null (remote, multi-root, unparseable). */
+function uriPath (u) {
+  if (!u) return null
+  if (typeof u === 'object') u = u.fsPath || u.external || (u.scheme === 'file' ? u.path : null)
+  if (typeof u !== 'string') return null
+  if (u.startsWith('file:')) { try { return fileURLToPath(u) } catch { return null } }
+  return path.isAbsolute(u) ? u : null
+}
+
+/** Every workspaceStorage folder Cursor uses for `dir`, most recently used first. */
+export function findWorkspaces (userDir, dir) {
+  const root = path.join(userDir, 'workspaceStorage')
+  const want = norm(dir)
+  let names = []
+  try { names = fs.readdirSync(root) } catch { return [] }
+  const found = []
+  for (const n of names) {
+    try {
+      const ws = JSON.parse(fs.readFileSync(path.join(root, n, 'workspace.json'), 'utf8'))
+      const folder = uriPath(ws.folder)
+      if (!folder || norm(folder) !== want) continue
+      const db = path.join(root, n, 'state.vscdb')
+      found.push({ dir: path.join(root, n), mtime: fs.statSync(db).mtimeMs })
+    } catch {}
+  }
+  return found.sort((a, b) => b.mtime - a.mtime).map((f) => f.dir)
+}
+
+/** The workspaceStorage folder Cursor uses for `dir`, or null. */
+export function findWorkspace (userDir, dir) {
+  return findWorkspaces(userDir, dir)[0] || null
+}
+
+export function startCursorReader ({ dir, chatDir, onEntries, onState, onLog = () => {}, userDir, pollMs = POLL_MS, settleMs = SETTLE_MS, now = Date.now }) {
+  dir = path.resolve(dir)
+  const chatRoot = path.resolve(chatDir || dir) // the folder Cursor has open
+  userDir = userDir || cursorUserDir()
+  let stopped = false
+  let timer = null
+  let status = null
+  let DatabaseSync = null
+  let globalDb = null
+  const workspaces = new Map() // workspace folder -> db
+  let lastScan = 0
+  let first = true
+  let lastChangeAt = 0
+  let running = false // a conversation with unfinishedRunAt is still thinking or working
+  let busyCount = 0
+  const versions = new Map() // db -> last PRAGMA data_version
+  // composerId -> { emitted: Set<bubbleId>, pending: Map<bubbleId, { sig, since, entries }>, listTs, seenAt }
+  const composers = new Map()
+
+  const setState = (s, reason) => {
+    if (s === status) return
+    status = s
+    onState({ tool: 'Cursor', status: s, ...(reason ? { reason } : {}) })
+  }
+
+  const fail = (reason) => {
+    setState('unavailable', reason)
+    onLog(`Cursor feed unavailable: ${reason}`)
+    stop()
+  }
+
+  function closeDbs () {
+    for (const db of [globalDb, ...workspaces.values()]) { try { db && db.close() } catch {} }
+    globalDb = null
+    workspaces.clear()
+    versions.clear()
+  }
+
+  function stop () {
+    stopped = true
+    clearTimeout(timer)
+    closeDbs()
+  }
+
+  const openDb = (file) => {
+    const db = new DatabaseSync(file, { readOnly: true })
+    db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`)
+    return db
+  }
+
+  /** Opens any Cursor workspace for this folder not opened yet. False if there is none. */
+  function scan (t) {
+    lastScan = t
+    for (const ws of findWorkspaces(userDir, chatRoot)) {
+      if (!workspaces.has(ws)) workspaces.set(ws, openDb(path.join(ws, 'state.vscdb')))
+    }
+    if (!workspaces.size) return false
+    if (!globalDb) globalDb = openDb(path.join(userDir, 'globalStorage', 'state.vscdb'))
+    return true
+  }
+
+  async function init () {
+    // node:sqlite prints an "experimental" warning on first import; keep the terminal clean.
+    const emit = process.emitWarning
+    process.emitWarning = (w, ...rest) => { if (!/SQLite/.test(String(w && w.message || w))) emit.call(process, w, ...rest) }
+    try {
+      ({ DatabaseSync } = await import('node:sqlite'))
+    } catch {
+      return fail('reading Cursor chats needs Node.js 22.13 or newer')
+    } finally {
+      process.emitWarning = emit
+    }
+    setState('idle')
+    const loop = () => {
+      if (stopped) return
+      const t = now()
+      try {
+        if ((!workspaces.size || t - lastScan > RESCAN_MS) && !scan(t)) {
+          timer = setTimeout(loop, pollMs * 5) // Cursor hasn't opened this folder yet
+          return
+        }
+        poll(t)
+        busyCount = 0
+      } catch (err) {
+        if (!transient(err)) return fail(explain(err))
+        // Cursor is mid-write, or its files moved: try again with fresh handles.
+        closeDbs()
+        if (++busyCount === BUSY_LOG_AFTER) onLog(`Cursor feed: storage has been busy for a while (${err.message}); still trying`)
+      }
+      timer = setTimeout(loop, pollMs)
+    }
+    loop()
+  }
+
+  function readJson (db, table, key) {
+    const row = db.prepare(`SELECT value FROM ${table} WHERE key = ?`).get(key)
+    if (!row || row.value == null) return null
+    const v = row.value
+    return JSON.parse(typeof v === 'string' ? v : Buffer.from(v).toString('utf8'))
+  }
+
+  /** True if another process committed to `db` since the last check. */
+  function changed (db) {
+    const v = db.prepare('PRAGMA data_version').get()
+    const val = v && Object.values(v)[0]
+    const was = versions.get(db)
+    versions.set(db, val)
+    return was !== val
+  }
+
+  /** This folder's conversations: [{ id, ts }], plus the ones open in Cursor right now. */
+  function listComposers () {
+    const out = new Map()
+    const focused = new Set()
+    const add = (c) => {
+      const id = c && c.composerId
+      if (!id || c.isArchived) return
+      const ts = c.lastUpdatedAt || c.createdAt || 0
+      if (!out.has(id) || out.get(id) < ts) out.set(id, ts)
+    }
+    const ids = new Set()
+    for (const [ws, db] of workspaces) {
+      ids.add(path.basename(ws))
+      const list = readJson(db, 'ItemTable', 'composer.composerData')
+      if (!list) continue
+      if (Array.isArray(list.allComposers)) list.allComposers.forEach(add)
+      for (const k of ['selectedComposerIds', 'lastFocusedComposerIds']) {
+        if (Array.isArray(list[k])) for (const id of list[k]) if (typeof id === 'string') focused.add(id)
+      }
+    }
+    // Newer Cursor versions keep the list globally, tagged with the workspace.
+    let headers = null
+    try { headers = readJson(globalDb, 'ItemTable', 'composer.composerHeaders') } catch (err) {
+      if (!/no such table/i.test(err.message)) throw err
+    }
+    if (headers && Array.isArray(headers.allComposers)) {
+      const want = norm(chatRoot)
+      for (const c of headers.allComposers) {
+        const w = c && c.workspaceIdentifier
+        if (!w) continue
+        const folder = uriPath(w.uri) || uriPath(w.folder) || uriPath(w.configPath)
+        if (ids.has(w.id) || (folder && norm(folder) === want)) add(c)
+      }
+    }
+    for (const id of focused) if (!out.has(id)) out.set(id, 0)
+    // Current Cursor keeps the list in composerHeaders. unfinishedRunAt stays
+    // set through a long think, which often writes no new message. Status uses
+    // that flag; the transcript reader still shares the messages.
+    const unfinished = headerRuns(ids)
+    return { list: [...out].map(([id, ts]) => ({ id, ts })), focused, unfinished }
+  }
+
+  function headerRuns (ids) {
+    const unfinished = new Set()
+    if (!ids.size) return unfinished
+    let rows = []
+    try {
+      const marks = [...ids].map(() => '?').join(', ')
+      rows = globalDb.prepare(
+        `SELECT composerId, isArchived, value FROM composerHeaders WHERE workspaceId IN (${marks})`
+      ).all(...ids)
+    } catch (err) {
+      if (/no such table/i.test(err.message)) return unfinished
+      throw err
+    }
+    for (const row of rows) {
+      if (!row || !row.composerId || row.isArchived) continue
+      const meta = headerMeta(row.value)
+      if (meta && meta.unfinishedRunAt) unfinished.add(row.composerId)
+    }
+    return unfinished
+  }
+
+  function poll (t) {
+    let dirty = first
+    for (const db of [globalDb, ...workspaces.values()]) if (changed(db)) dirty = true
+    const out = []
+
+    if (!dirty) {
+      // Nothing was written: only let streaming bubbles that went quiet settle.
+      for (const st of composers.values()) settle(st, t, out)
+    } else {
+      const { list, focused, unfinished } = listComposers()
+      running = unfinished.size > 0
+      for (const { id, ts } of list) {
+        let st = composers.get(id)
+        if (!st) {
+          st = { emitted: new Set(), pending: new Map(), listTs: ts, seenAt: first ? 0 : t, isNew: !first }
+          composers.set(id, st)
+          if (first && t - ts > BACKFILL_MS) {
+            // Old conversation: remember what's there so only new messages are shared.
+            for (const h of headers(readJson(globalDb, 'cursorDiskKV', `composerData:${id}`))) st.emitted.add(h.bubbleId)
+            continue
+          }
+        } else if (ts !== st.listTs) {
+          st.listTs = ts
+          st.seenAt = t
+        }
+      }
+      const rank = (id) => { const st = composers.get(id); return Math.max(st.listTs, st.seenAt) }
+      const recent = list.map((c) => c.id).sort((a, b) => rank(b) - rank(a))
+      const active = new Set(recent.slice(0, ACTIVE_COUNT))
+      for (const id of recent) {
+        const st = composers.get(id)
+        if (focused.has(id) || unfinished.has(id) || st.pending.size || t - rank(id) < HOT_MS || (first && t - st.listTs <= BACKFILL_MS)) active.add(id)
+      }
+      for (const id of active) {
+        const fresh = readComposer(id, composers.get(id), t)
+        out.push(...(first ? fresh.slice(-BACKFILL_ENTRIES) : fresh))
+      }
+    }
+
+    first = false
+    setState(running || t - lastChangeAt < WORKING_MS ? 'working' : 'idle')
+    if (out.length) onEntries(out)
+  }
+
+  /** New entries from one conversation. Bubbles still being written wait until they settle. */
+  function readComposer (id, st, t) {
+    const data = readJson(globalDb, 'cursorDiskKV', `composerData:${id}`)
+    if (!data) return []
+    // The chat's name in Cursor's list: entries carry it, so the Loom and the feed name it the same way.
+    const title = typeof data.name === 'string' ? data.name.replace(/\s+/g, ' ').trim().slice(0, 80) : ''
+    const hs = headers(data)
+    const out = []
+    hs.forEach((h, i) => {
+      if (st.emitted.has(h.bubbleId)) return
+      const bubble = h.inline || readJson(globalDb, 'cursorDiskKV', `bubbleId:${id}:${h.bubbleId}`)
+      if (!bubble) return // listed before it was written; picked up next time
+      const backfill = first
+      const ts = backfill ? (Date.parse(bubble.createdAt) || st.listTs || t) : t
+      const entries = toEntries(id, h.bubbleId, bubble, ts, title)
+      if (backfill || (i < hs.length - 1 && entries.length)) {
+        // Something came after it, so it's finished.
+        if (!backfill && !st.pending.has(h.bubbleId)) touch(st, t)
+        st.pending.delete(h.bubbleId)
+        st.emitted.add(h.bubbleId)
+        out.push(...entries)
+        return
+      }
+      // The newest bubble (or one that's still empty) may still be streaming.
+      const sig = signature(bubble)
+      const p = st.pending.get(h.bubbleId)
+      if (!p || p.sig !== sig) {
+        st.pending.set(h.bubbleId, { sig, since: t, entries, ts })
+        touch(st, t)
+      } else {
+        p.entries = entries
+      }
+    })
+    settle(st, t, out)
+    return out
+  }
+
+  function settle (st, t, out) {
+    for (const [bubbleId, p] of st.pending) {
+      if (t - p.since < settleMs) continue
+      st.pending.delete(bubbleId)
+      st.emitted.add(bubbleId)
+      out.push(...p.entries.map((e) => ({ ...e, ts: t })))
+    }
+  }
+
+  function touch (st, t) {
+    st.seenAt = t
+    lastChangeAt = t
+  }
+
+  function toEntries (conv, bubbleId, b, ts, title = '') {
+    const base = { tool: 'Cursor', conv, ts, ...(title ? { title } : {}) }
+    const out = []
+    const text = typeof b.text === 'string' ? b.text.trim() : ''
+    if (b.type === 1 && text) out.push({ ...base, id: bubbleId, kind: 'prompt', text: capText(text) })
+    if (b.type === 2 && text) out.push({ ...base, id: bubbleId, kind: 'reply', text: capText(text) })
+    const tool = b.toolFormerData
+    if (tool && tool.name) {
+      let args = tool.params || tool.rawArgs || {}
+      if (typeof args === 'string') { try { args = JSON.parse(args) } catch { args = {} } }
+      out.push({ ...base, id: `${bubbleId}:tool`, kind: 'action', text: describeAction(tool.name, args, dir) })
+    }
+    return out
+  }
+
+  init().catch((err) => fail(explain(err)))
+  return { stop }
+}
+
+/** A conversation's bubbles in order: [{ bubbleId, inline? }]. */
+function headers (data) {
+  if (!data) return []
+  if (Array.isArray(data.fullConversationHeadersOnly)) return data.fullConversationHeadersOnly.filter((h) => h && h.bubbleId)
+  // Older Cursor versions kept the bubbles inline.
+  if (Array.isArray(data.conversation)) return data.conversation.filter((b) => b && b.bubbleId).map((b) => ({ bubbleId: b.bubbleId, inline: b }))
+  throw new Error('unexpected composer layout (no fullConversationHeadersOnly)')
+}
+
+function headerMeta (value) {
+  if (value == null) return null
+  try {
+    const s = typeof value === 'string' ? value : Buffer.from(value).toString('utf8')
+    return JSON.parse(s)
+  } catch { return null }
+}
+
+function thinkingText (b) {
+  const t = b && b.thinking
+  if (typeof t === 'string') return t
+  if (t && typeof t.text === 'string') return t.text
+  return ''
+}
+
+function signature (b) {
+  const tool = b.toolFormerData || {}
+  const args = tool.params || tool.rawArgs || ''
+  // Thinking text and tool status change while a reply is still in progress,
+  // before any visible message text is written.
+  return `${b.type}|${(b.text || '').length}|${b.text || ''}|${thinkingText(b).length}|${tool.name || ''}|${tool.status || ''}|${typeof args === 'string' ? args : JSON.stringify(args)}`
+}
+
+function transient (err) {
+  const m = `${err && err.code} ${err && err.message}`
+  return /SQLITE_BUSY|SQLITE_LOCKED|database is locked|database table is locked|SQLITE_IOERR|disk I\/O error|SQLITE_CANTOPEN|unable to open|ENOENT/i.test(m)
+}
+
+function explain (err) {
+  const m = String(err && err.message || err)
+  if (/no such table/i.test(m)) return `Cursor's storage layout isn't recognized (${m})`
+  if (/JSON/i.test(m)) return `Cursor's storage layout isn't recognized (unreadable data)`
+  return m
+}

package/src/agents/index.js

@@ -0,0 +1,69 @@
+// Starts every AI-chat reader for a folder and merges their output. Readers
+// are best-effort: a failure in one never affects syncing or the others.
+import { startClaudeCodeReader } from './claude-code.js'
+import { startCursorReader } from './cursor.js'
+import { startCursorTranscriptReader } from './cursor-transcripts.js'
+
+const READERS = [
+  ['Claude Code', startClaudeCodeReader],
+  ['Cursor', startCursorReader],
+  ['Cursor', startCursorTranscriptReader]
+]
+
+/**
+ * @returns {{ stop(): void }}
+ * onEntries(entries)  entries: { id, tool, conv, kind: 'prompt'|'reply'|'action', text, ts, title? }
+ *                     (title: the tool's own name for the conversation, when it keeps one)
+ * onState(state)      state:   { tool, status: 'working'|'idle'|'unavailable', reason? }
+ *                     (one combined state: the tool that's working, else the last one active)
+ */
+export function startAgentReaders ({ dir, onEntries, onState, onLog = () => {}, readers = READERS, ...opts }) {
+  const states = new Map()
+  let lastActive = null
+  let combined = ''
+
+  const report = () => {
+    const all = [...states.values()]
+    // Until a tool shows activity, don't claim anyone uses it.
+    const pick = all.find((s) => s.status === 'working') ||
+      (lastActive != null && states.get(lastActive)) ||
+      (all.length && all.every((s) => s.status === 'unavailable') ? all[0] : { tool: null, status: 'idle' })
+    const unavailable = all.filter((s) => s.status === 'unavailable')
+    const out = { ...pick }
+    if (pick.status !== 'unavailable' && unavailable.length) out.notes = unavailable.map((s) => `${s.tool}: ${s.reason}`)
+    const key = JSON.stringify(out)
+    if (key === combined) return
+    combined = key
+    onState(out)
+  }
+
+  const handles = []
+  // Two readers can share a tool name (Cursor's composer db and its transcripts).
+  // Keep their states apart so one going idle cannot hide the other still working.
+  readers.forEach(([tool, start], i) => {
+    const guard = (fn) => (...args) => { try { fn(...args) } catch (err) { onLog(`${tool} feed error: ${err.message}`) } }
+    try {
+      handles.push(start({
+        dir,
+        ...opts,
+        onLog,
+        onEntries: guard((entries) => {
+          if (!entries.length) return
+          // Do not pin lastActive from entries alone: Claude Code (and others) backfill
+          // history on start, which used to leave partners seeing "Claude Code idle"
+          // forever even when the person actually uses Cursor / xAI / Grok.
+          onEntries(entries)
+          report()
+        }),
+        onState: guard((s) => {
+          states.set(i, s)
+          if (s.status === 'working') lastActive = i
+          report()
+        })
+      }))
+    } catch (err) {
+      onLog(`${tool} feed could not start: ${err.message}`)
+    }
+  })
+  return { stop () { for (const h of handles) { try { h.stop() } catch {} } } }
+}

package/src/ai-vm-signin.js

@@ -0,0 +1,98 @@
+// Signing a person's AI tool in on their cloud machine (src/ai-vm.js), with the tool's own login:
+// one table for every tool, like autowork-tools.js, so no tool has a code path of its own. Quilt
+// shows the person only what they need: the link to open, a device code to type there, and
+// whether the page gives them a code to paste back. A token a tool prints stays on the machine.
+import fs from 'node:fs'
+import path from 'node:path'
+
+/**
+ * Each tool: the command its login is (`exe`, `args`, `env`), what it prints (`urlHost`, a device
+ * `code`, a `token` it hands over to be kept), whether the person pastes a code back
+ * (`needsCode`), and how to tell it is signed in (`status`).
+ */
+export const SIGN_IN = {
+  'Claude Code': {
+    // setup-token makes a long-lived token for this machine; the page shows a code to paste back.
+    exe: ['claude'],
+    args: ['setup-token'],
+    env: {},
+    urlHost: /^(claude\.ai|console\.anthropic\.com)$/,
+    needsCode: true,
+    token: /sk-ant-oat01-[A-Za-z0-9_-]{20,}/,
+    status: { file: 'claude-token' }
+  },
+  Codex: {
+    exe: ['codex'],
+    args: ['login', '--device-auth'],
+    env: {},
+    urlHost: /^auth\.openai\.com$/,
+    code: /\b([A-Z0-9]{4}-[A-Z0-9]{4,6})\b/,
+    needsCode: false,
+    status: { args: ['login', 'status'] }
+  },
+  Cursor: {
+    exe: ['agent', 'cursor-agent'],
+    args: ['login'],
+    env: { NO_OPEN_BROWSER: '1' },
+    urlHost: /^(www\.)?cursor\.com$/,
+    needsCode: false,
+    status: { args: ['status'], ok: /logged in/i, notOk: /not logged in|log in|login required/i }
+  }
+}
+
+// eslint-disable-next-line no-control-regex
+const ANSI = /\u001b\[[0-9;?]*[ -/]*[@-~]|\u001b\][^\u0007]*(\u0007|\u001b\\)|\u001b[()][A-Za-z0-9]|\u001b[=>78]|\r/g
+
+/** Terminal output as plain text. */
+export const plain = (text) => String(text || '').replace(ANSI, '')
+
+/**
+ * What a tool's login printed so far, as the person needs it: { url, code, needsCode } and the
+ * `token` it handed over (kept on the machine, never sent anywhere).
+ */
+export function readSignIn (tool, text) {
+  const t = SIGN_IN[tool]
+  const out = { url: '', code: '', needsCode: false, token: '' }
+  if (!t) return out
+  const s = plain(text)
+  for (const m of s.matchAll(/https:\/\/[^\s"'<>]+/g)) {
+    try {
+      const u = new URL(m[0].replace(/[).,;]+$/, ''))
+      if (t.urlHost.test(u.hostname)) { out.url = u.href; break }
+    } catch {}
+  }
+  if (t.code) {
+    // The code is printed near the link; a URL's own parts don't count.
+    const m = s.replace(/https:\/\/\S+/g, ' ').match(t.code)
+    if (m) out.code = m[1]
+  }
+  out.needsCode = !!(t.needsCode && out.url)
+  if (t.token) { const m = s.match(t.token); if (m) out.token = m[0] }
+  return out
+}
+
+/** Where a tool's token is kept on the machine (only Claude Code hands one over). */
+export const tokenFile = (home, tool) => (SIGN_IN[tool]?.status?.file ? path.join(home, '.quilt', 'ai-vm', SIGN_IN[tool].status.file) : null)
+
+/** Keeps a token on the machine's disk, readable by this user only. */
+export function keepToken (home, tool, token) {
+  const file = tokenFile(home, tool)
+  if (!file || !token) return
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 })
+  fs.writeFileSync(file, token, { mode: 0o600 })
+}
+
+/** The kept token, or ''. */
+export function keptToken (home, tool) {
+  const file = tokenFile(home, tool)
+  try { return file ? fs.readFileSync(file, 'utf8').trim() : '' } catch { return '' }
+}
+
+/** Whether a status command's answer says the tool is signed in. */
+export function statusSaysSignedIn (tool, code, output) {
+  const st = SIGN_IN[tool]?.status
+  if (!st || !st.args) return false
+  const text = plain(output)
+  if (code !== 0 || (st.notOk && st.notOk.test(text))) return false
+  return st.ok ? st.ok.test(text) : true
+}