heyquilt 0.0.1 → 0.3.90

package/src/largefiles.js

@@ -0,0 +1,91 @@
+// Encryption for large files stored outside the session document. Each session
+// has file keys; a file key is stored in the document only wrapped (encrypted)
+// with keys derived from the session's secrets, so only members can open it.
+import crypto from 'node:crypto'
+
+const MAGIC = Buffer.from('QF1')
+const NONCE = 12
+const TAG = 16
+
+/** The key that wraps file keys for whoever holds `secret` in `room`. */
+export function deriveWrapKey (secret, room) {
+  return Buffer.from(crypto.hkdfSync('sha256', String(secret), String(room), 'quilt-file-key-wrap-v1', 32))
+}
+
+export function newFileKey () {
+  return crypto.randomBytes(32)
+}
+
+function seal (plain, key) {
+  const nonce = crypto.randomBytes(NONCE)
+  const c = crypto.createCipheriv('aes-256-gcm', key, nonce)
+  const body = Buffer.concat([c.update(plain), c.final()])
+  return Buffer.concat([nonce, body, c.getAuthTag()])
+}
+
+function open (sealed, key) {
+  if (sealed.length < NONCE + TAG) throw new Error('too short')
+  const d = crypto.createDecipheriv('aes-256-gcm', key, sealed.subarray(0, NONCE))
+  d.setAuthTag(sealed.subarray(sealed.length - TAG))
+  return Buffer.concat([d.update(sealed.subarray(NONCE, sealed.length - TAG)), d.final()])
+}
+
+export function wrapKey (fileKey, wrap) {
+  return seal(fileKey, wrap).toString('base64url')
+}
+
+/** The file key, or null if this wrap key doesn't open it. */
+export function unwrapKey (wrapped, wrap) {
+  try {
+    const key = open(Buffer.from(String(wrapped), 'base64url'), wrap)
+    return key.length === 32 ? key : null
+  } catch {
+    return null
+  }
+}
+
+export function encryptBlob (plain, fileKey) {
+  return Buffer.concat([MAGIC, seal(plain, fileKey)])
+}
+
+export function decryptBlob (sealed, fileKey) {
+  try {
+    if (!sealed.subarray(0, MAGIC.length).equals(MAGIC)) throw new Error('not a quilt file')
+    return open(sealed.subarray(MAGIC.length), fileKey)
+  } catch {
+    throw new Error('this file could not be decrypted')
+  }
+}
+
+/** Where a file is stored: the same for the same key and content, meaningless to anyone else. */
+export function blobId (fileKey, sha1Hex) {
+  return crypto.createHmac('sha256', fileKey).update(`id:${sha1Hex}`).digest('hex').slice(0, 32)
+}
+
+// GitHub as a node (plan §10): on a branch that syncs with GitHub, once the session owner agrees,
+// each app also wraps that branch's file keys for the relay's own key (X25519), so the relay can read
+// large files to commit them. Branches that don't sync with GitHub stay end-to-end encrypted.
+
+/** A short id for a relay's public key (spki DER, base64url), so a wrap says which key it is for. */
+export const relayKeyId = (relayPub) => crypto.createHash('sha256').update(String(relayPub)).digest('hex').slice(0, 16)
+
+const relayWrapKey = (shared, epk) => Buffer.from(crypto.hkdfSync('sha256', shared, Buffer.from(String(epk)), 'quilt-file-key-relay-v1', 32))
+
+/** `fileKey` wrapped for the relay's X25519 public key `relayPub`: { to, epk, wrapped }. */
+export function wrapForRelay (fileKey, relayPub) {
+  const pub = crypto.createPublicKey({ key: Buffer.from(String(relayPub), 'base64url'), format: 'der', type: 'spki' })
+  const eph = crypto.generateKeyPairSync('x25519')
+  const epk = eph.publicKey.export({ format: 'der', type: 'spki' }).toString('base64url')
+  const shared = crypto.diffieHellman({ privateKey: eph.privateKey, publicKey: pub })
+  return { to: relayKeyId(relayPub), epk, wrapped: wrapKey(fileKey, relayWrapKey(shared, epk)) }
+}
+
+/** The file key in a wrap made by wrapForRelay, with the relay's private key; null if it isn't for this key. */
+export function unwrapAsRelay (entry, privateKey) {
+  try {
+    if (!entry || typeof entry.epk !== 'string' || typeof entry.wrapped !== 'string') return null
+    const epk = crypto.createPublicKey({ key: Buffer.from(entry.epk, 'base64url'), format: 'der', type: 'spki' })
+    const shared = crypto.diffieHellman({ privateKey, publicKey: epk })
+    return unwrapKey(entry.wrapped, relayWrapKey(shared, entry.epk))
+  } catch { return null }
+}

package/src/legacy.js

@@ -0,0 +1,25 @@
+// Quilt was called cowove until 2026-09-28. Existing installs keep working:
+// ~/.cowove and a project's .cowove folder are moved to .quilt the first time
+// they're needed, and COWOVE_* settings count as QUILT_* ones.
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+/** Moves <parent>/.cowove to <parent>/.quilt if only the old one exists. */
+export function migrateDir (parent) {
+  const cur = path.join(parent, '.quilt')
+  const old = path.join(parent, '.cowove')
+  try { if (!fs.existsSync(cur) && fs.existsSync(old)) fs.renameSync(old, cur) } catch {}
+  return cur
+}
+
+/** ~/.quilt: settings, identity, recent sessions, running processes. */
+export const quiltHome = () => migrateDir(os.homedir())
+
+/** Copies COWOVE_* variables to their QUILT_* names unless those are set. */
+export function adoptLegacyEnv (env = process.env) {
+  for (const [k, v] of Object.entries(env)) {
+    if (k.startsWith('COWOVE_') && env[`QUILT_${k.slice(7)}`] === undefined) env[`QUILT_${k.slice(7)}`] = v
+  }
+  return env
+}

package/src/mcp-proxy.js

@@ -0,0 +1,40 @@
+// `quilt mcp` in a sandbox with a QUILT_AGENT_KEY and no `quilt join` running: a stdio MCP server
+// that hands each request to the hosted MCP (the accounts API's /mcp) as the key's agent, with the
+// key's session filled in. Any AI tool that runs stdio MCP servers gets the same quilt_* tools as
+// everywhere else, with nothing installed but `npx heyquilt mcp`.
+import { Server } from '@modelcontextprotocol/sdk/server/index.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js'
+import { hostedClient } from './hosted-client.js'
+
+const NOTE = (room) => `\n\nYou reach Quilt with this sandbox's QUILT_AGENT_KEY: every tool is about session ${room}, filled in for you. ` +
+  'Your folder is synced by `npx heyquilt sync`: run it at the start of every turn (it brings in what changed and says what waits for you) and again at the end (it sends what you changed).'
+
+/** The tools as the hosted MCP lists them, without `session` (the proxy fills it in). */
+export function withoutSession (tools) {
+  return (tools || []).map((t) => {
+    const schema = t.inputSchema && t.inputSchema.properties && t.inputSchema.properties.session
+      ? { ...t.inputSchema, properties: Object.fromEntries(Object.entries(t.inputSchema.properties).filter(([k]) => k !== 'session')), ...(Array.isArray(t.inputSchema.required) ? { required: t.inputSchema.required.filter((k) => k !== 'session') } : {}) }
+      : t.inputSchema
+    return { ...t, inputSchema: schema }
+  })
+}
+
+export async function runMcpProxy ({ key, client = hostedClient({ key }), transport = new StdioServerTransport() }) {
+  let instructions = ''
+  try {
+    const init = await client.rpc('initialize', { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'quilt-mcp-proxy', version: '1' } })
+    instructions = (init && init.instructions) || ''
+  } catch {} // the first tool call says what is wrong (a revoked key, no network)
+  const server = new Server({ name: 'quilt', version: '0.2.0' }, { capabilities: { tools: {} }, instructions: instructions + NOTE(key.room) })
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: withoutSession((await client.rpc('tools/list', {})).tools) }))
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    try {
+      return await client.callRaw(req.params.name, req.params.arguments || {})
+    } catch (e) {
+      return { content: [{ type: 'text', text: e.message }], isError: true }
+    }
+  })
+  await server.connect(transport)
+  return server
+}

package/src/mcp-room.js

@@ -0,0 +1,32 @@
+// Which room a hosted agent's MCP request (a JSON-RPC body) is about: the invite a
+// quilt_join_session call joins, or the `session` a tool call names. The accounts API uses it to
+// mint the pass for that room (src/api/server.js); the relay, to send the request to the machine
+// that holds the room (src/relay-cluster.js).
+import { parseInvite } from './ui/invite.js'
+
+const ROOM = /^[A-Za-z0-9_-]{1,64}$/
+
+/** The room a quilt_join_session call in this MCP request joins, or '' (any other request). */
+export function joiningRoom (body) {
+  if (!body || !body.length) return ''
+  try {
+    const msg = JSON.parse(body.toString('utf8'))
+    for (const m of Array.isArray(msg) ? msg : [msg]) {
+      if (m?.method === 'tools/call' && m.params?.name === 'quilt_join_session') return parseInvite(String(m.params.arguments?.invite || ''), { allowRelay: () => true }).room
+    }
+  } catch {}
+  return ''
+}
+
+/** The `session` a tool call names (an agent in several sessions says which each call is about), or ''. */
+export function sessionArg (body) {
+  if (!body || !body.length) return ''
+  try {
+    const msg = JSON.parse(body.toString('utf8'))
+    for (const m of Array.isArray(msg) ? msg : [msg]) {
+      const s = m?.method === 'tools/call' ? m.params?.arguments?.session : undefined
+      if (typeof s === 'string' && ROOM.test(s.trim())) return s.trim()
+    }
+  } catch {}
+  return ''
+}