heyquilt 0.3.122 → 0.3.140

package/bin/quilt.js

@@ -28,7 +28,7 @@ Usage:
   quilt sync [--dir <folder>]                         Agents in a sandbox: sync this folder with the session once and exit
                                                       (needs QUILT_AGENT_KEY; run it at the start and end of every turn).
                                                       With the key, status, messages, say, tasks, task, history, claim,
-                                                      release, focus, commits, commit-request, tool and mcp work too
+                                                      release, focus, tool and mcp work too
   quilt setup                                         Connect Claude Code / Cursor / others via MCP
   quilt status                                        Show collaborators, claims, activity, chat
   quilt history [path] [--by name] [--since 2h] [--task id] [--diff] [-n 30]
@@ -46,16 +46,12 @@ Usage:
   quilt run -- <command> [args...]                    Run a command with the session's secrets: it gets NAME=quilt and
                                                       NAME's base URL (STRIPE_BASE_URL), and its requests go through
                                                       Quilt's vault; it never sees a value
-  quilt commit-request <message> [--files a,b] [--task id]
-                                                      Ask a person to commit for you (when agents may not push here)
-  quilt commits                                       Open commit requests and recent commits
-  quilt github                                        Whether agents can push here through GitHub, and the link that connects it
+  quilt commit <message>                              In a session that is a quilt: commit the square this folder follows
   quilt focus <what you're doing>                     Tell collaborators what you're working on
   quilt claim <path|glob> [reason]                    Mark files as yours for now
   quilt release <path|glob|*>                         Release a claim
   quilt chat-link [name] [--minutes N]                Owner: a link for a chat-only AI (ChatGPT, claude.ai, Grok); 10 minutes
   quilt chat-link extend <name> <minutes>             Owner: keep a chat link working for that long from now
-  quilt github-token [--clear]                        Owner: a read-only GitHub token (read from stdin) so the relay brings in commits while everyone's offline
   quilt invite                                        Print this session's invite code
   quilt workspace list|files|get|put|write|mkdir|mv|rm  The workspace library (quilt workspace for help)
   quilt stop                                          Shut down everything quilt is running (relay, app, syncs)
@@ -108,13 +104,8 @@ async function main () {
     case 'webhook': return webhookCmd()
     case 'wake': return wakeCmd()
     case 'get': return getFile()
-    case 'commit-request': return commitRequest()
-    case 'commits': return commits()
-    case 'github': return githubStatusCmd()
-    case 'git-token': return gitToken()
+    case 'commit': if (!argv.join(' ').trim()) fail('Usage: quilt commit <message>'); return simple('/square-commit', { message: argv.join(' ') }, (r) => r.text)
     case 'run': return runCmd()
-    case 'git-credential': return gitCredential()
-    case 'git-pre-push': return gitPrePush()
     case 'chat': return chat()
     case 'focus': return simple('/focus', { text: argv.join(' ') }, () => 'focus updated')
     case 'claim': return simple('/claim', { pattern: argv[0], note: argv.slice(1).join(' ') }, (r) =>
@@ -130,20 +121,6 @@ async function main () {
       const name = argv.filter((a, k) => !(i >= 0 && (k === i || k === i + 1))).join(' ')
       return simple('/chat-link', { name, minutes }, (r) => `Chat link for ${r.name}, until ${new Date(r.expiresAt).toLocaleTimeString()}:\n\n  ${r.url}\n\nPaste it into ChatGPT, claude.ai or Grok with "Open this link and follow it to join our Quilt session."\nAnyone with it can act as ${r.name}. Extend it with \`quilt chat-link extend ${r.name} <minutes>\`; once it runs out, make a new one.`)
     }
-    case 'github-token': {
-      // Read from stdin, never the command line (where shell history and ps would keep it).
-      if (argv[0] === '--clear') return simple('/github-token', { token: '' }, () => 'The relay no longer has a GitHub token for this session.')
-      if (argv.length) fail('usage: quilt github-token [--clear]   (the token is read from stdin: pbpaste | quilt github-token)')
-      if (process.stdin.isTTY) process.stderr.write('Paste a read-only GitHub token (contents: read) and press Enter: ')
-      const token = await new Promise((resolve) => {
-        let buf = ''
-        process.stdin.setEncoding('utf8')
-        process.stdin.on('data', (d) => { buf += d; if (process.stdin.isTTY && buf.includes('\n')) { process.stdin.pause(); resolve(buf) } })
-        process.stdin.on('end', () => resolve(buf))
-      })
-      if (!token.trim()) fail('no token given')
-      return simple('/github-token', { token: token.trim() }, () => 'The relay has the token: it brings in commits from your private repository while nobody\'s folder is online.')
-    }
     case 'session': return sessionCmd()
     case 'invite': return invite()
     case 'workspace': case 'workspaces': return workspaceCmd()
@@ -234,6 +211,8 @@ async function apiCmd () {
     siteUrl: env.QUILT_SITE_URL || 'http://localhost:3000',
     trustProxy: /^(1|true|yes)$/i.test(env.QUILT_TRUST_PROXY || ''), log: console.log,
     workspaces: env.QUILT_WORKSPACES === '1' || env.QUILT_WORKSPACES === 'true',
+    // New sessions are quilts from the start (Seam's plans/quilt-source-control/16, flags order 8): apps read it from /v1/features.
+    quiltSourceDefault: env.QUILT_SOURCE_DEFAULT === '1' || env.QUILT_SOURCE_DEFAULT === 'true',
     // Secrets: the vault (quilt-vault) and the secret it calls this API with; off when not set.
     vaultSecret: env.QUILT_VAULT_SECRET || '',
     vaultUrl: env.QUILT_VAULT_URL || 'https://vault.heyquilt.com',
@@ -242,7 +221,7 @@ async function apiCmd () {
     // Its own machines through Fly's Machines API (QUILT_API_FLY_TOKEN): more as load climbs, fewer as it drops (src/api/scaler.js).
     apiFly: (await import('../src/api/api-machines.js')).apiFlyFromEnv(env),
     ...(env.QUILT_API_MAX_MACHINES ? { maxMachines: Number(env.QUILT_API_MAX_MACHINES) } : {}),
-    // Seam is its own service (docs/seam-service.md): its old routes here go on to it.
+    // Seam is its own service (Seam's docs/seam-service.md): its old routes here go on to it.
     ...(env.QUILT_SEAM_URL !== undefined ? { seamUrl: env.QUILT_SEAM_URL } : {}),
     ...(env.QUILT_SEAM_CLIENT_ID ? { seamClientId: env.QUILT_SEAM_CLIENT_ID } : {}),
     ...(env.QUILT_SEAM_SITE_URL ? { seamSiteUrl: env.QUILT_SEAM_SITE_URL } : {}),
@@ -355,6 +334,7 @@ async function join () {
 
   const { unsupportedRelay } = await import('../src/settings.js')
   let conn
+  let fresh = false // a session this command starts: a quilt from the start when the API says so (src/quilt-default.js)
   if (positionals[0]) {
     try { conn = decodeInvite(positionals[0]) } catch (err) { fail(err.message) }
   } else if (values.room) {
@@ -366,6 +346,7 @@ async function join () {
   } else {
     if (saved.server) console.log("This folder's last session ran on your computer's own relay, which Quilt no longer supports. Starting a new session.")
     conn = newConn()
+    fresh = true
     console.log('starting a new session')
   }
 
@@ -407,6 +388,7 @@ async function join () {
       apiAuth: auth.apiAuth,
       identity: auth.identity,
       inviteServer: saved.room === conn.room ? saved.inviteServer : undefined,
+      newSession: fresh,
       onLog: (m) => console.log(`[${stamp()}] ${m}`),
       onDebug: process.env.QUILT_DEBUG ? (m) => console.log(`[${stamp()}] debug: ${m}`) : undefined,
       onFatal: (err) => fail(whyStopped(err))
@@ -471,6 +453,12 @@ async function withAgentKey () {
   return true
 }
 
+/** All of stdin, for `quilt tool <name> -` (the tool's arguments as JSON). */
+const readStdin = () => new Promise((resolve) => {
+  let s = ''
+  process.stdin.setEncoding('utf8'); process.stdin.on('data', (c) => { s += c }); process.stdin.on('end', () => resolve(s)); process.stdin.on('error', () => resolve(s))
+})
+
 /** The sandbox's QUILT_AGENT_KEY (src/ui/agent-env-key.js), or null; a malformed one stops here. */
 async function envKey () {
   const { agentEnvKeyFromEnv } = await import('../src/ui/agent-env-key.js')
@@ -582,7 +570,7 @@ async function doSetup () {
   console.log('\nAn AI tool that was already open picks up the "quilt" MCP server when it restarts.')
 }
 
-// `quilt session migrate [--dry-run]` (plans/quilt-source-control/16): what making this folder's
+// `quilt session migrate [--dry-run]` (Seam's plans/quilt-source-control/16): what making this folder's
 // session a quilt (Seam) would do, read only, or, without --dry-run, the move itself. The relay
 // does both, behind QUILT_SOURCE_URL there, and only for the session's owner. --switch then moves
 // the session's files into its squares (layout 3); --back returns it to its branches. `follow <folder>`
@@ -592,11 +580,45 @@ async function sessionCmd () {
     if (!argv[1]) fail('Usage: quilt session follow <folder>')
     return simple('/quilt-follow', { dir: path.resolve(argv[1]) }, (r) => r.text)
   }
-  if (argv[0] !== 'migrate') fail('Usage: quilt session migrate [--dry-run | --switch | --back] | quilt session follow <folder>')
+  if (argv[0] !== 'migrate') fail('Usage: quilt session migrate [--dry-run | --link-only | --switch | --back [--carried <square,...>] | --shadow <quilt> | --unshadow] | quilt session follow <folder>')
   if (argv.includes('--dry-run')) return simple('/quilt-plan', {}, (r) => r.text)
-  if (argv.includes('--switch')) return simple('/quilt-switch', {}, (r) => r.text)
-  if (argv.includes('--back')) return simple('/quilt-unswitch', {}, (r) => r.text)
-  return simple('/quilt-migrate', {}, (r) => r.text)
+  if (argv.includes('--shadow')) {
+    const q = argv[argv.indexOf('--shadow') + 1]
+    if (!q || q.startsWith('-')) fail('Usage: quilt session migrate --shadow <quilt> (the quilt an import of this session\'s git remote fills)')
+    return simple('/quilt-shadow', { quilt: q }, (r) => r.text)
+  }
+  if (argv.includes('--unshadow')) return simple('/quilt-shadow', { quilt: null }, (r) => r.text)
+  if (argv.includes('--switch')) return sessionMove('/quilt-switch', {}, 'into its squares')
+  if (argv.includes('--back')) {
+    // --carried <id,id>: open squares whose work was carried over by hand (seam diff <square> | git apply).
+    const i = argv.indexOf('--carried')
+    const carried = i >= 0 && argv[i + 1] ? argv[i + 1].split(',').map((x) => x.trim().replace(/^sq:/, '')).filter(Boolean) : []
+    return sessionMove('/quilt-unswitch', { carried }, 'back to its branches')
+  }
+  // "Make this a quilt": made a quilt and moved into its squares in one go (16 flag 9); --link-only stops after the first.
+  if (argv.includes('--link-only')) return sessionMove('/quilt-migrate', {}, 'into Seam')
+  return sessionMove('/quilt-make', {}, 'into Seam')
+}
+
+/**
+ * A move of the session (into Seam, or back), through this folder's app. The relay does it; on a large
+ * session that takes minutes, so it says so first. An app that can't follow a square (older than
+ * 0.3.127) is sent away by the relay at the end of the move, and this command's answer is lost with it:
+ * refused here before anything moves. If the app stops answering meanwhile, the relay still finishes
+ * (or undoes) the move on its own: said, with how to see which.
+ */
+async function sessionMove (route, body, where) {
+  const { d, call } = await daemonOrFail()
+  let info = null
+  try { info = await call(d, 'GET', '/info') } catch (err) { fail(err.message) }
+  const { moveRefusal } = await import('../src/control.js')
+  const refused = moveRefusal(info, (await import('../src/releases.js')).currentVersion())
+  if (refused) fail(refused)
+  console.error(`Moving the session ${where}. The relay does it; a large session takes a few minutes. Keep Quilt open until this answers.`)
+  try { console.log((await call(d, 'POST', route, body)).text) } catch (err) {
+    if (err.cut) fail(`Quilt's app for ${d.dir} stopped answering while the relay moved the session (${err.code || 'the connection closed'}), so this command never heard how it went. The relay finishes the move, or undoes it, on its own. Open the session in Quilt again (if it says the session needs a newer version of Quilt, update Quilt first); then quilt status says whether this folder follows its square.`)
+    fail(err.message)
+  }
 }
 
 async function daemonOrFail () {
@@ -614,12 +636,16 @@ async function status () {
 async function history () {
   const { values, positionals } = parseArgs({ args: argv, allowPositionals: true, options: { by: { type: 'string' }, since: { type: 'string' }, task: { type: 'string' }, diff: { type: 'boolean' }, n: { type: 'string', short: 'n' } } })
   const { formatHistory } = await import('../src/history.js')
-  await simple('/history', { path: positionals[0], by: values.by, since: values.since, task: values.task, limit: Number(values.n || 30) }, (r) => formatHistory(r.entries, { withDiff: !!values.diff }))
+  await simple('/history', { path: positionals[0], by: values.by, since: values.since, task: values.task, limit: Number(values.n || 30), with_diff: !!values.diff }, (r) => `${formatHistory(r.entries, { withDiff: !!values.diff })}${r.note ? `\n\n${r.note}` : ''}`)
 }
 
 async function simple (route, body, format, method = 'POST') {
   const { d, call } = await daemonOrFail()
-  try { console.log(format(await call(d, method, route, body))) } catch (err) { fail(err.message) }
+  try { console.log(format(await call(d, method, route, body))) } catch (err) {
+    // The app doesn't know the route: it runs an older Quilt than this command.
+    if (err.status === 404 && err.message === 'not found') fail(`Quilt's app for ${d.dir} runs an older Quilt that doesn't have this yet. Update Quilt (or restart it on the new version), then try again.`)
+    fail(err.message)
+  }
 }
 
 /** Splits "@bob rest of message" into { to: 'bob', rest: [...] }. */
@@ -734,99 +760,6 @@ async function wakeCmd () {
   return simple('/wake', { args }, (r) => r.text)
 }
 
-async function commitRequest () {
-  const { values, positionals } = parseArgs({ args: argv, allowPositionals: true, options: { files: { type: 'string' }, task: { type: 'string' } } })
-  const files = values.files ? values.files.split(',').map((f) => f.trim()).filter(Boolean) : undefined
-  await simple('/commit-request', { message: positionals.join(' '), files, task: values.task }, (r) =>
-    `asked for a commit [${r.id}] of ${r.files.length} file${r.files.length === 1 ? '' : 's'}: ${r.files.slice(0, 12).join(', ')}${r.files.length > 12 ? ', …' : ''}\n${r.committer}`)
-}
-
-// git in an agent's folder runs these (installGitHelpers, gitstate.js); `--dir` is the folder, whose
-// running session answers. They never print anything but what git expects, and never fail a git
-// command when Quilt isn't running: git then behaves as it would without Quilt. Nor do they make git
-// wait: a session that doesn't answer within HELPER_WAIT is taken as no session, and the whole helper
-// exits by HELPER_LIMIT whatever is still pending (the env overrides are for tests).
-const HELPER_WAIT = Number(process.env.QUILT_HELPER_WAIT_MS) || 4000
-const HELPER_LIMIT = Number(process.env.QUILT_HELPER_LIMIT_MS) || 10000
-function helperDeadline () { setTimeout(() => process.exit(0), HELPER_LIMIT).unref() }
-function helperDir () {
-  const i = argv.indexOf('--dir')
-  const dir = i >= 0 ? argv[i + 1] : process.cwd()
-  if (i >= 0) argv.splice(i, 2)
-  return dir
-}
-async function helperDaemon (dir) {
-  const { findDaemon, call } = await import('../src/control.js')
-  const d = findDaemon(dir)
-  return d ? { d, call } : null
-}
-// git closes stdin after what it sends; one that stays open is read for HELPER_WAIT at most.
-const readStdin = () => new Promise((resolve) => {
-  let s = ''
-  const done = () => { clearTimeout(t); process.stdin.pause(); resolve(s) }
-  const t = setTimeout(done, HELPER_WAIT)
-  process.stdin.setEncoding('utf8'); process.stdin.on('data', (c) => { s += c }); process.stdin.on('end', done); process.stdin.on('error', done)
-})
-
-/**
- * git's credential helper protocol: `get` answers with the session's token for the host; store and erase
- * are nothing to do. `--fallback` (a person's folder, git for everyone): when no Quilt session answers
- * (the app is closed) or it has no token, the person's own helpers are asked instead, as git would have
- * without Quilt: `git credential fill` from outside the folder, so only their global and system config count.
- */
-async function gitCredential () {
-  const dir = helperDir()
-  const fallback = argv.includes('--fallback')
-  if (fallback) argv.splice(argv.indexOf('--fallback'), 1)
-  if (argv[0] !== 'get') return
-  helperDeadline()
-  const input = await readStdin()
-  const fields = Object.fromEntries(input.split('\n').filter((l) => l.includes('=')).map((l) => { const i = l.indexOf('='); return [l.slice(0, i), l.slice(i + 1)] }))
-  try {
-    const h = await helperDaemon(dir)
-    if (h) {
-      const r = await h.call(h.d, 'POST', '/git/credential', { host: fields.host || '', protocol: fields.protocol || '' }, { timeoutMs: HELPER_WAIT })
-      if (r && r.username && r.password) return process.stdout.write(`username=${r.username}\npassword=${r.password}\n`)
-    }
-  } catch {}
-  if (fallback) await ownCredential(input)
-}
-
-/** The person's own credentials for what git asked (`input`, git's credential fields), or nothing: never a prompt. */
-async function ownCredential (input) {
-  const os = await import('node:os')
-  const { execFile } = await import('node:child_process')
-  const away = os.tmpdir()
-  const out = await new Promise((resolve) => {
-    const c = execFile('git', ['credential', 'fill'], { cwd: away, encoding: 'utf8', timeout: Math.max(1000, HELPER_LIMIT - HELPER_WAIT - 1000), killSignal: 'SIGKILL', env: { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_ASKPASS: '', SSH_ASKPASS: '', GIT_CEILING_DIRECTORIES: path.dirname(away) } }, (err, stdout) => resolve(err ? '' : stdout))
-    c.stdin.end(input.endsWith('\n\n') ? input : `${input.replace(/\n*$/, '')}\n\n`)
-  })
-  const lines = out.split('\n').filter((l) => /^(username|password)=/.test(l))
-  if (lines.length === 2) process.stdout.write(`${lines.join('\n')}\n`)
-}
-
-/** The pre-push hook: refs on stdin (local ref, local sha, remote ref, remote sha), the remote's name and URL as arguments. Exits 1 with the reason when the push may not go. */
-async function gitPrePush () {
-  const dir = helperDir()
-  const [remote = 'origin'] = argv
-  helperDeadline()
-  const input = await readStdin()
-  const refs = input.split('\n').filter(Boolean).map((l) => { const [localRef, localSha, remoteRef, remoteSha] = l.trim().split(/\s+/); return { localRef, localSha, remoteRef, remoteSha } })
-  try {
-    const h = await helperDaemon(dir)
-    if (!h) return
-    const r = await h.call(h.d, 'POST', '/git/push-check', { remote, refs }, { timeoutMs: HELPER_WAIT })
-    if (r && r.ok === false) { process.stderr.write(`Quilt: ${r.why || 'this push is not allowed here'}\n`); process.exitCode = 1 }
-  } catch {}
-}
-
-/** A short-lived token for this folder's repository (agents), for gh or GitHub's API. */
-/** `quilt git-token` no longer prints a token (a value in a terminal is a value in an AI's context). */
-async function gitToken () {
-  const { GIT_TOKEN_GONE } = await import('../src/secret-run.js')
-  fail(GIT_TOKEN_GONE)
-}
-
 /** `quilt run -- <command>`: the command gets its secrets' stand-ins and gateways (src/secret-run.js). */
 async function runCmd () {
   const { RUN_USAGE, runSource, runWithSecrets } = await import('../src/secret-run.js')
@@ -840,30 +773,6 @@ async function runCmd () {
   try { process.exitCode = await runWithSecrets({ command, source }) } catch (err) { fail(err.message) }
 }
 
-async function githubStatusCmd () {
-  const { d, call } = await daemonOrFail()
-  const st = await call(d, 'GET', '/status')
-  const mine = (st.branches || []).find((b) => st.git && b.name === st.git.key) || (st.branches || []).find((b) => b.default)
-  const g = mine && mine.relay && mine.relay.github
-  const repo = mine && mine.relay && mine.relay.repo
-  if (!repo) return console.log('This session does not follow a GitHub repository (no member\'s folder is a clone of one), so there is nothing to connect.')
-  const words = { ok: `Git is on for everyone here, through @${g && g.login}'s connection: people and agents push with git, nothing to set up`, 'not-connected': 'not connected: nobody in the session has connected GitHub yet', 'not-installed': 'Quilt is not installed on this repository on GitHub yet', 'no-access': `no connected GitHub account (@${g && g.login}) may write to it`, 'not-github': 'not on GitHub' }
-  console.log(`${repo}: ${g ? words[g.state] || g.state : 'not checked yet'}`)
-  if (g && g.state === 'ok') return
-  const { readAccount } = await import('../src/account.js')
-  const token = readAccount()?.token
-  if (!token) return console.log('Sign in (quilt login), then run this again for the link that connects GitHub.')
-  const { githubConnectUrl } = await import('../src/account.js')
-  try { console.log(`Connect it (one click, once, by someone whose GitHub account can write to the repository):\n  ${await githubConnectUrl({ token, repo })}`) } catch (err) { console.log(`Could not get the link: ${err.message}`) }
-}
-
-async function commits () {
-  const { d, call } = await daemonOrFail()
-  const { describeCommitRequests } = await import('../src/commit.js')
-  const c = await call(d, 'GET', '/commits')
-  console.log(plain(describeCommitRequests(c, { canCommit: !!c.canCommit })))
-}
-
 async function getFile () {
   if (!argv[0]) fail('usage: quilt get <message-id> [dest]')
   await simple('/get', { id: argv[0], dest: argv[1] ? path.resolve(argv[1]) : undefined }, (r) => `saved to ${r.path}`)
@@ -982,4 +891,5 @@ function fail (msg) {
   process.exit(1)
 }
 
-main().catch((err) => fail(err.stack || err.message))
+// An app that can't be reached is said in words (control.js unreachable), not as a stack.
+main().catch((err) => fail(err.unreachable ? err.message : err.stack || err.message))

package/desktop/main.js

@@ -2,7 +2,7 @@
 // keep syncing from the menu bar when the window is closed, and invite links
 // (quilt://join?invite=…) open straight into the join screen.
 import '../src/quiet-warnings.js'
-import { app, BrowserWindow, Tray, Menu, shell, dialog, ipcMain, nativeTheme, systemPreferences } from 'electron'
+import { app, BrowserWindow, Tray, Menu, shell, dialog, ipcMain, nativeTheme, systemPreferences, desktopCapturer } from 'electron'
 import { execFile } from 'node:child_process'
 import fs from 'node:fs'
 import os from 'node:os'
@@ -18,6 +18,7 @@ import { registerOnStart } from '../src/integrations.js'
 import { adoptLoginShellPath } from '../src/shell-path.js'
 import { getSettings } from '../src/settings.js'
 import { allowPermission, checkPermission } from './media-permission.js'
+import { shareHandler } from './screen-share.js'
 
 adoptLegacyEnv()
 // Chromium's own error log goes to the terminal the app runs in. In a voice call it reports every
@@ -40,6 +41,7 @@ let tray = null
 let quitting = false
 let pendingInvite = null
 let rendererReady = false
+let shareWired = false // the screen share handler (and its answer channel), set up with the first window
 
 /** The invite link inside a quilt:// URL, or null. */
 function inviteFrom (url) {
@@ -206,10 +208,22 @@ function createWindow () {
   const ses = win.webContents.session
   ses.setPermissionRequestHandler((wc, permission, done, details) => {
     if (!allowPermission(permission, details, origin)) return done(false)
-    if (permission === 'media' && process.platform === 'darwin') return systemPreferences.askForMediaAccess('microphone').then(done, () => done(false))
+    if (permission === 'media' && process.platform === 'darwin' && details.mediaTypes?.includes('audio')) return systemPreferences.askForMediaAccess('microphone').then(done, () => done(false))
     done(true)
   })
   ses.setPermissionCheckHandler((wc, permission, requestingOrigin, details) => checkPermission(permission, requestingOrigin, details, origin))
+  // Sharing a screen in a call: the Mac's own picker where there is one (macOS 15+), otherwise the
+  // page shows what can be shared (screen-share.js).
+  if (!shareWired) {
+    shareWired = true
+    ses.setDisplayMediaRequestHandler(shareHandler({
+      win: () => win,
+      appOrigin: origin,
+      capturer: desktopCapturer,
+      ipcMain,
+      screenAccess: () => process.platform === 'darwin' ? systemPreferences.getMediaAccessStatus('screen') : 'granted'
+    }), { useSystemPicker: true })
+  }
   win.webContents.setWindowOpenHandler(({ url }) => {
     if (/^https?:/.test(url) && !url.startsWith(origin)) shell.openExternal(url)
     return { action: 'deny' }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heyquilt",
-  "version": "0.3.122",
+  "version": "0.3.140",
   "description": "Real-time, tool-agnostic pair vibe coding: sync a project folder live between collaborators using any AI coding tool.",
   "author": {
     "name": "Daniel Carmichael",
@@ -37,7 +37,7 @@
   "dependencies": {
     "@fontsource/ibm-plex-mono": "^5.3.0",
     "@fontsource/poppins": "^5.3.0",
-    "@heyquilt/seam": "^0.17.0",
+    "@heyquilt/seam": "0.237.313",
     "@modelcontextprotocol/sdk": "^1.30.1",
     "@noble/hashes": "^2.4.0",
     "@supabase/supabase-js": "^2.117.2",
@@ -84,6 +84,7 @@
       "desktop/preload.cjs",
       "desktop/updater.js",
       "desktop/media-permission.js",
+      "desktop/screen-share.js",
       "desktop/icons/*.png",
       "desktop/icons/*.ico",
       "package.json",

package/src/account.js

@@ -224,35 +224,6 @@ export async function removeSandboxKey ({ token, id, keyId, api = apiUrl(), fetc
   return call(fetchImpl, api, 'DELETE', sandbox$(id, `/${encodeURIComponent(keyId)}`), null, token)
 }
 
-/** This account's GitHub connection (Quilt's GitHub App): { available, connected, login? }. */
-export async function githubStatus ({ token, api = apiUrl(), fetch: fetchImpl = globalThis.fetch }) {
-  return call(fetchImpl, api, 'GET', '/v1/me/github', null, token)
-}
-
-/** Where to send this person to connect GitHub (install Quilt's app on their repositories). */
-export async function githubConnectUrl ({ token, repo = '', scope = '', id = '', api = apiUrl(), fetch: fetchImpl = globalThis.fetch }) {
-  const r = await call(fetchImpl, api, 'POST', '/v1/github/connect', { ...(repo ? { repo } : {}), ...(scope ? { scope, id } : {}) }, token)
-  if (!r.url) throw new Error(BAD_REPLY)
-  return r.url
-}
-
-/** A workspace's GitHub (plan §2): its connections, access mode and repositories, and its org's switch. */
-export async function workspaceGithub ({ token, id, api = apiUrl(), fetch: fetchImpl = globalThis.fetch }) {
-  return call(fetchImpl, api, 'GET', `/v1/workspaces/${encodeURIComponent(id)}/github`, null, token)
-}
-export async function setWorkspaceGithub ({ token, id, access, repos, agentCommits, api = apiUrl(), fetch: fetchImpl = globalThis.fetch }) {
-  // Only what is given changes: the access mode (with its repositories) and/or what agents may commit ('' for each session).
-  const body = { ...(access !== undefined ? { access, repos } : {}), ...(agentCommits !== undefined ? { agentCommits } : {}) }
-  return call(fetchImpl, api, 'PUT', `/v1/workspaces/${encodeURIComponent(id)}/github`, body, token)
-}
-export async function removeWorkspaceGithub ({ token, id, connectedBy = '', api = apiUrl(), fetch: fetchImpl = globalThis.fetch }) {
-  return call(fetchImpl, api, 'DELETE', `/v1/workspaces/${encodeURIComponent(id)}/github/connection`, connectedBy ? { connectedBy } : {}, token)
-}
-export async function setOrgGithub ({ token, slug, requireGithub, agentCommits, api = apiUrl(), fetch: fetchImpl = globalThis.fetch }) {
-  const body = { ...(requireGithub !== undefined ? { requireGithub: !!requireGithub } : {}), ...(agentCommits !== undefined ? { agentCommits } : {}) }
-  return call(fetchImpl, api, 'PUT', `/v1/orgs/${encodeURIComponent(slug)}/github`, body, token)
-}
-
 // Access types, grants and session invites, as this computer's account (see
 // docs/superpowers/specs/2026-10-02-access-types-and-invites-design.md). Each throws with
 // .status when the API says no (401 once the token is revoked).

package/src/agent-task-workflow.js

@@ -98,7 +98,7 @@ function agoText (ts, now) {
  * @param {string} [o.me]
  * @param {number} [o.now]
  */
-export function pickupBrief ({ task, history = [], claims = [], checklist = '', me = '', now = Date.now() }) {
+export function pickupBrief ({ task, history = [], claims = [], checklist = '', me = '', now = Date.now(), workflow = TASK_WORKFLOW }) {
   const files = task?.files || []
   const lines = [`Picked up "${task?.title || 'this ticket'}" [${task?.id || ''}].`]
   lines.push(files.length ? `Files: ${files.join(', ')}` : 'Files: none listed. Add them with quilt_assign_task once you know which you will touch.')
@@ -124,7 +124,7 @@ export function pickupBrief ({ task, history = [], claims = [], checklist = '',
     lines.push('', 'Claims to respect (ask for the file with quilt_request_file instead of editing it):')
     for (const c of others) lines.push(`- ${c.pattern} by ${c.by}${c.note ? ` (${c.note})` : ''}`)
   }
-  lines.push('', TASK_WORKFLOW, '', checklistBlock(checklist))
+  lines.push('', workflow, '', checklistBlock(checklist))
   return lines.join('\n')
 }
 

package/src/agents/common.js

@@ -19,3 +19,16 @@ export function toolLabel (client) {
   if (/gemini/i.test(n)) return 'Other'
   return n || 'AI agent'
 }
+
+// The tools a person can be shown as using.
+export const KNOWN_TOOLS = new Set(['Claude Code', 'Cursor', 'Codex', 'xAI', 'Windsurf', 'Zed'])
+
+/**
+ * The tool to show for a person: the one they set, unless the AIs connected through their app
+ * (MCP client names) are all another tool. A set tool can be a stale guess (Brandon showed as
+ * Windsurf while his Claude Code was connected); the AI that connects is what they really use.
+ */
+export function toolInUse (tool, agents = []) {
+  const used = [...agents].map(toolLabel).filter((t) => KNOWN_TOOLS.has(t))
+  return used.length && !used.includes(tool) ? used[used.length - 1] : tool
+}

package/src/ai-vm.js

@@ -526,9 +526,17 @@ export class AiVm {
       kind: 'agent',
       passes: auth.passes,
       identity: auth.identity,
+      // The accounts API (and Seam, through it) as this cloud AI, with its own key (seam-access.js).
+      apiAuth: auth.apiAuth,
       agentFeed: false,
       onLog: (line) => this.log(`[${room}] ${line}`),
-      onFatal: (err) => { this.log(`[${room}] stopped: ${err.message}`); this.runs.delete(room) }
+      // Stopped, not only forgotten: a session left running keeps its timers and the whole room in memory.
+      onFatal: (err) => {
+        this.log(`[${room}] stopped: ${err.message}`)
+        const r = this.runs.get(room)
+        this.runs.delete(room)
+        if (r) r.run.stop().catch(() => {})
+      }
     })
     this.runs.set(room, { run, link })
     // What reaches it in the session counts as activity: the machine stays up while there is work,

package/src/api/activity.js

@@ -136,6 +136,9 @@ export function summarize ({ me, sessions, visits, now, tz = 'UTC' }) {
     people.sort((a, b) => b.togetherMs - a.togetherMs || a.name.localeCompare(b.name))
     const ownerRows = s.ownerAccount ? inRoom.filter((v) => v.account === s.ownerAccount) : []
     const open = inRoom.some((v) => v.endedAt == null)
+    // Who is in it right now, among me and the people listed (an open visit).
+    const listed = new Set([me, ...people.map((p) => p.account)])
+    const here = [...new Set(inRoom.filter((v) => v.endedAt == null && listed.has(v.account)).map((v) => v.account))]
     rows.push({
       room: s.room,
       name: s.name || '',
@@ -143,6 +146,8 @@ export function summarize ({ me, sessions, visits, now, tz = 'UTC' }) {
       mine: !!s.ownerAccount && s.ownerAccount === me,
       createdAt: s.createdAt,
       lastActiveAt: open ? now : s.lastActiveAt,
+      live: open,
+      here,
       myTotalMs: total(mine),
       people
     })

package/src/api/memory-store.js

@@ -30,7 +30,8 @@ export function createMemoryStore ({ now = Date.now } = {}) {
   const orgGithub = new Map() // org id -> { requireGithub, updatedAt }
   const teamGithub = new Map() // team id -> { agentCommits, updatedAt }
   const settings = new Map() // the API's own settings (a webhook secret it made), key -> value
-  const leases = new Map() // "repo\0branch" -> { room, holder, generation, heartbeatAt } (git_sync_leases)
+  const leases = new Map() // key -> { room, holder, generation, heartbeatAt } (relay_leases)
+  const authSessions = new Map()
   const users = new Map(); const orgs = new Map(); const roles = new Map(); const members = new Map()
   const teams = new Map(); const teamMembers = new Map(); const invites = new Map(); const requests = new Map()
   const agentInvites = new Map(); const keyRows = new Map(); const appKeys = new Map()
@@ -389,41 +390,19 @@ export function createMemoryStore ({ now = Date.now } = {}) {
     },
 
     // The address a person signs in with, and whether they've confirmed it.
-    async userEmail (userId) { const u = users.get(userId); return u ? { ...u } : null },
-    async githubLink (userId) { const g = githubLinks.get(userId); return g ? { ...g } : null },
-    async setGithubLink (userId, { githubId, login }) { githubLinks.set(userId, { githubId, login, linkedAt: now() }) },
-    async deleteGithubLink (userId) { githubLinks.delete(userId) },
-    // GitHub connected for a scope (github_connections): an org, a workspace or a person; newest first.
-    async githubConnections ({ scope, scopeId }) { return all(githubConnections, (c) => c.scope === scope && c.scopeId === scopeId).sort((a, b) => b.createdAt - a.createdAt).map(copy) },
-    async addGithubConnection ({ scope, scopeId, connectedBy, installationId = null }) { githubConnections.set(`${scope}\0${scopeId}\0${connectedBy}`, { scope, scopeId, connectedBy, installationId, createdAt: now() }) },
-    async removeGithubConnection ({ scope, scopeId, connectedBy }) { githubConnections.delete(`${scope}\0${scopeId}\0${connectedBy}`) },
-    // A workspace's access mode (workspace_github): 'open', or 'repos' with the repositories it allows.
-    async workspaceGithub (workspaceId) { const w = workspaceGithub.get(workspaceId); return w ? { access: w.access, repos: [...w.repos], agentCommits: w.agentCommits || '' } : { access: 'open', repos: [], agentCommits: '' } },
-    // Only what is given changes: { access, repos } and/or { agentCommits } ('' for each session to decide).
-    async setWorkspaceGithub (workspaceId, { access, repos, agentCommits }) {
-      const w = workspaceGithub.get(workspaceId) || { access: 'open', repos: [], agentCommits: '' }
-      workspaceGithub.set(workspaceId, { access: access ?? w.access, repos: repos ? [...repos] : w.repos, agentCommits: agentCommits ?? w.agentCommits ?? '', updatedAt: now() })
-    },
-    // An org's GitHub switch (org_github): whether it requires GitHub.
-    async teamGithub (teamId) { const r = teamGithub.get(teamId); return { agentCommits: (r && r.agentCommits) || '' } },
-    async setTeamGithub (teamId, { agentCommits }) { teamGithub.set(teamId, { agentCommits: agentCommits || '', updatedAt: now() }) },
-    // The rules of the teams `memberId` is on: [{ teamId, name, agentCommits }], only those that set one.
-    async teamGitRules (memberId) {
-      return all(teamMembers, (tm) => tm.memberId === memberId)
-        .map((tm) => ({ team: teams.get(tm.teamId), rule: teamGithub.get(tm.teamId) }))
-        .filter((x) => x.team && x.rule && x.rule.agentCommits)
-        .map((x) => ({ teamId: x.team.id, name: x.team.name, agentCommits: x.rule.agentCommits }))
-    },
-    async orgGithub (orgId) { const o = orgGithub.get(orgId); return { requireGithub: !!(o && o.requireGithub), agentCommits: (o && o.agentCommits) || '' } },
-    async setOrgGithub (orgId, { requireGithub, agentCommits }) {
-      const o = orgGithub.get(orgId) || { requireGithub: false, agentCommits: '' }
-      orgGithub.set(orgId, { requireGithub: requireGithub ?? o.requireGithub, agentCommits: agentCommits ?? o.agentCommits ?? '', updatedAt: now() })
-    },
+    async userEmail (userId) { const u = users.get(userId); return u ? { email: u.email, confirmed: u.confirmed } : null },
+    // Email notices (notify.js): what each person turned on, and what was already sent (kept on the account).
+    setNotify (userId, notify) { const u = users.get(userId); if (u) u.notify = { ...notify } },
+    async notifyUsers () { return all(users, (u) => u.confirmed && u.notify).map((u) => ({ userId: [...users].find(([, x]) => x === u)[0], email: u.email, notify: { ...u.notify }, sent: { ...(u.notifySent || {}) } })) },
+    async setNotifySent (userId, sent) { const u = users.get(userId); if (u) u.notifySent = { ...sent } },
+    // A person's browser sign-ins (supabase-store.js: auth.sessions), for signing out one at a time.
+    addAuthSession (userId, s) { authSessions.set(s.id, { userId, createdAt: now(), lastActiveAt: now(), userAgent: '', ip: '', ...s }) },
+    async authSessions (userId) { return all(authSessions, (s) => s.userId === userId).sort((a, b) => b.lastActiveAt - a.lastActiveAt).map(({ userId: _, ...s }) => ({ ...s })) },
+    async endAuthSession (userId, id) { const s = authSessions.get(id); if (!s || s.userId !== userId) return false; authSessions.delete(id); return true },
     // The API's own settings (app_settings): a value it keeps across starts.
     async getSetting (key) { return settings.has(key) ? settings.get(key) : null },
-    // One live session per repository and branch (git_sync_leases; mirrors the SQL functions).
-    async takeLease ({ repo, branch, room, holder = '', ttlMs }) {
-      const k = `${repo}\0${branch}`
+    // Relay leases (relay_leases; mirrors the SQL functions). `key`: the relay's name for what it holds.
+    async takeLease ({ key: k, room, holder = '', ttlMs }) {
       const cur = leases.get(k)
       const t = now()
       if (!cur) { leases.set(k, { room, holder, generation: 1, heartbeatAt: t }); return { ok: true, generation: 1, room } }
@@ -433,15 +412,14 @@ export function createMemoryStore ({ now = Date.now } = {}) {
       leases.set(k, { room, holder, generation: cur.generation + 1, heartbeatAt: t })
       return { ok: true, generation: cur.generation + 1, room }
     },
-    async heartbeatLease ({ repo, branch, room, generation, ttlMs }) {
-      const cur = leases.get(`${repo}\0${branch}`)
+    async heartbeatLease ({ key: k, room, generation, ttlMs }) {
+      const cur = leases.get(k)
       if (!cur || cur.room !== room || cur.generation !== generation) return { ok: false, lost: true, room: cur ? cur.room : '' }
       if (cur.heartbeatAt < now() - ttlMs) return { ok: false, expired: true }
       cur.heartbeatAt = now()
       return { ok: true, generation }
     },
-    async releaseLease ({ repo, branch, room, generation }) {
-      const k = `${repo}\0${branch}`
+    async releaseLease ({ key: k, room, generation }) {
       const cur = leases.get(k)
       if (cur && cur.room === room && cur.generation === generation) leases.delete(k)
       return { ok: true }