heyquilt 0.3.122 → 0.3.140

package/src/control.js

@@ -11,6 +11,14 @@ import { createRun, waitRun, endRun, secretNames, apiCall } from './secrets-clie
 import { runMailTool, MAIL_TOOLS } from './mail-tools.js'
 import { runWakeTool } from './wake-tool.js'
 import { wakeCheck } from './wake.js'
+import { seamAccess, sessionCredential } from './seam-access.js'
+import { runSessionSeamTool } from './session-seam.js'
+import { appSeamUrl } from './seam-url.js'
+import { squareFor } from './session-follow.js'
+import { shareWithPeople } from './session-layout3.js'
+import { QUILT_MOVE_TIMEOUT_MS } from './connection.js'
+import { FEATURES } from './protocol.js'
+import { currentVersion } from './releases.js'
 
 export async function startControl (session, extras = {}) {
   const token = crypto.randomBytes(16).toString('hex')
@@ -22,10 +30,45 @@ export async function startControl (session, extras = {}) {
   // Step 2 of joining (wake.js): an agent that hasn't chosen how Quilt wakes it is reminded with each answer.
   const wake = wakeCheck({
     fetchWake: async () => {
-      if (session.kind !== 'agent' || !extras.apiAuth) return { method: 'n/a' }
+      // A person's cloud AI (aiOf) is woken by its machine (autowork.js), never asked how.
+      if (session.kind !== 'agent' || session.aiOf || !extras.apiAuth) return { method: 'n/a' }
       return (await apiCall(await secretsApi(), 'GET', '/v1/agents/me/wake')).wake
     }
   })
+  // Seam's tools for this folder's AI sessions, in a session that is a quilt (session-seam.js), as
+  // this session's member: its person, or its agent on a cloud machine (seam-access.js).
+  // Kept on the session, so its AI's runs (autowork.js) read Seam as the same member.
+  if (extras.apiAuth && !session.apiAuth) session.apiAuth = extras.apiAuth
+  const seam = session.seamMember ? session.seamMember() : (session.seam || (session.seam = seamAccess({ api: () => appSeamUrl(), credential: sessionCredential({ apiAuth: extras.apiAuth, account: readAccount }) })))
+  const shared = new Set() // squares this person holds and has shared with the session's other people
+  const seamTool = async (b) => {
+    const q = session.quilt
+    if (!q || !q.id) return { content: [{ type: 'text', text: 'This session is not a quilt, so it has no Seam tools.' }], isError: true }
+    const branch = session.squareBranchKey ? session.squareBranchKey() : session.branchKey()
+    const at = squareFor(q, branch)
+    const square = at ? at.square : ((q.squares || {})[branch] || null)
+    const fail = (text) => ({ content: [{ type: 'text', text }], isError: true })
+    // The folder's live block on that square: the folder itself, following it in place, or a
+    // separate one (session-follow.js). Its commit is `quilt commit`'s: what the relay holds.
+    const f = session.squareFollower
+    const here = f && f.here && at && f.here.square === at.square ? f.here : null
+    const sep = f && f.following && at && f.following.square === at.square ? f.following : null
+    const live = (here && here.block) || (sep && sep.block) || null
+    if (here && !here.block && (b.tool === 'seam_commit' || b.tool === 'seam_merge')) return fail(here.problem ? `This folder can't follow its square yet (${here.problem}); Quilt tries again by itself.` : 'This folder is still starting to follow its square; try again in a moment.')
+    let c
+    try { c = await seam.client(q.id, square ? [square] : []) } catch (err) { return fail(err.message) }
+    // The folder's live work is read and committed as this member.
+    if (live) live.client = c.client
+    if (c.person && square && !shared.has(square)) {
+      shared.add(square)
+      // The square's holder shares it with the session's other people, so their AIs (working for them) write there too.
+      shareWithPeople(c.client, q.id, square, session.members || []).catch(() => shared.delete(square))
+    }
+    const next = at ? async () => session.conn.branchRequest({ op: 'quilt-next', token: c.token, branch }, { timeoutMs: QUILT_MOVE_TIMEOUT_MS }) : null
+    return runSessionSeamTool(String(b.tool || ''), b.args || {}, { client: c.client, quilt: q.id, square, live, next, branch })
+  }
+  // The app's square panel (ui-server.js) commits and merges through the same tools, as the same member.
+  session.seamTool = seamTool
   const routes = {
     'GET /status': (b) => {
       // To one of the AI sessions working through this app, "you" is that session (persona.js).
@@ -94,47 +137,33 @@ export async function startControl (session, extras = {}) {
     'POST /chat-link': (b) => session.createChatLink({ name: b.name, minutes: b.minutes }),
     // Owner only: how long a chat link still works. { who: name or key, minutes } -> { name, expiresAt }
     'POST /chat-link/extend': (b) => session.extendChatLink(String(b.who || ''), b.minutes),
-    // Owner only: the relay's read-only GitHub token, for commits while everyone's offline. { token } ('' clears) -> { githubToken }
-    'POST /github-token': (b) => session.setGithubToken(b.token),
     'POST /agent': (b) => { session.addAgent(b.client); return { ok: true } },
     'POST /feed': (b) => ({ entries: session.agentFeedFor(b.who, { limit: Math.min(Number(b.limit) || 40, 300) }) }),
     // The chronology: { path, by, since, task, limit } (see Session.historyQuery).
-    'POST /history': (b) => ({ entries: session.historyQuery(b) }),
+    // In a session linked to a quilt (Seam), the quilt's log too (Session.historyLinked): { entries, note? }.
+    'POST /history': (b) => session.historyLinked(b),
     'GET /tree': () => session.tree(),
     'POST /sharing': (b) => ({ on: session.setAgentSharing(b.on !== false) }),
-    'GET /commits': () => session.commitStatus({ includeMe: false }),
-    'GET /branches': () => ({ branches: session.status().branches, git: session.status().git }),
-    // The relay's own list, with where each branch stands with GitHub (quilt_sync_status).
-    'GET /sync-status': () => ({ branches: session.branchList || [], mine: session.branchKey ? session.branchKey() : '' }),
-    'POST /branches/sync': () => session.syncBranchNow(),
     // `quilt session migrate --dry-run`: what making the session a quilt would do (the relay's dry run).
     'POST /quilt-plan': () => session.quiltPlan(),
     // The quilt this session is (Seam), as the relay last said; null while it is not (session-seam.js).
     'GET /quilt': () => ({ quilt: session.quilt || null }),
+    // One of Seam's tools (session-seam.js SEAM_SESSION_TOOLS), { tool, args }: an MCP tool result.
+    'POST /seam': (b) => seamTool(b),
     // `quilt session migrate`: the relay makes the session a quilt, as its owner (their sign-in).
     'POST /quilt-migrate': () => session.quiltMigrate(process.env.SEAM_TOKEN || (readAccount() || {}).token),
+    // "Make this a quilt" (`quilt session migrate`, the app's button): made a quilt and moved into its squares in one go.
+    'POST /quilt-make': () => session.quiltMake(process.env.SEAM_TOKEN || (readAccount() || {}).token),
     // `quilt session migrate --switch` / `--back`: the session's files into its squares (layout 3), or back.
     'POST /quilt-switch': () => session.quiltSwitch(process.env.SEAM_TOKEN || (readAccount() || {}).token),
-    'POST /quilt-unswitch': () => session.quiltUnswitch(),
+    'POST /quilt-unswitch': (b) => session.quiltUnswitch(process.env.SEAM_TOKEN || (readAccount() || {}).token, Array.isArray(b.carried) ? b.carried : []),
+    // `quilt session migrate --shadow <quilt>`: link the session to the quilt an import of its git remote fills (16 step 1).
+    'POST /quilt-shadow': (b) => session.quiltShadowLink(process.env.SEAM_TOKEN || (readAccount() || {}).token, b.quilt ?? null),
     // `quilt session follow <folder>`: at layout 3, that folder follows this branch's square, live.
-    'POST /quilt-follow': (b) => session.quiltFollow(process.env.SEAM_TOKEN || (readAccount() || {}).token, b.dir),
-    'POST /commit-request': (b) => session.requestCommit(b.message, { files: b.files == null ? null : b.files, description: b.description || '', task: b.task || null, via: b.via ? String(b.via) : null }),
-    // quilt_commit: the relay commits the session's copy of the files to GitHub (relay-commit.js).
-    'POST /agent-commits': (b) => session.setAgentCommits(b.mode),
-    // GitHub as a node: the owner's switch, and a person adopting an agent's branch (relay-outbound.js).
-    'POST /github-sync': async (b) => (await session.setGithubSync(b.on !== false)).githubSync === false ? { githubSync: false } : { githubSync: true },
-    'POST /adopt': (b) => session.adoptBranch(String(b.from || '')),
-    // The branch's pull requests on GitHub, and merging one, through the relay (relay-commit.js).
-    'POST /github/recheck': () => session.githubRecheck(),
-    'POST /unpublished': (b) => session.unpublished({ files: Array.isArray(b.files) ? b.files : null, task: b.task || null, column: b.column || '' }),
-    // git in an agent's folder: what it signs in to GitHub with (`quilt git-credential`), and whether a push may go (`quilt git-pre-push`).
-    'POST /git/credential': (b) => session.gitCredential({ host: b.host || '' }),
-    'POST /git/push-check': (b) => session.pushCheck({ remote: b.remote || 'origin', refs: Array.isArray(b.refs) ? b.refs : [] }),
+    'POST /quilt-follow': (b) => session.quiltFollow(null, b.dir),
+    // `quilt commit <message>`: at layout 3, the square this folder follows is committed, as this person.
+    'POST /square-commit': (b) => session.squareCommit(String(b.message || '')),
 
-    // A commit request committed in this folder, which has git (commit.js).
-    'POST /commit-request/commit': (b) => session.commitRequest(String(b.id || '')),
-    'GET /uncommitted': () => session.uncommittedWork(),
-    'POST /commit-request/done': (b) => ({ done: session.resolveCommitRequests({ ids: b.id ? [String(b.id)] : null }) }),
     'POST /work': (b) => {
       if (b.state === 'working') session.personaSays(b.via, b.note)
       const work = session.setWork(b.state, b.note)
@@ -160,17 +189,13 @@ export async function startControl (session, extras = {}) {
       session.noteTaskChange(null, task, b.via)
       return { task, tasks: session.taskList() }
     },
-    'POST /tasks/update': async (b) => {
+    'POST /tasks/update': (b) => {
       const before = session.taskList().find((t) => t.id === b.id) || null
-      // Done merges the task's pull request first (relay-commit.js): refused with the reason when it can't be.
-      const finished = b.column === 'done' && before && before.column !== 'done' ? await session.finishTask(b.id) : null
       const task = session.updateTask(b)
       session.noteTaskChange(before, task, b.via)
       if (b.column === 'doing' && task) session.personaSays(b.via, task.title) // taking a task can name an AI session
       if (task && (b.column === 'doing' || b.column === 'done')) session.stitchClock(b.via, b.column === 'doing')
-      // An agent taking a task gets a branch of its own for it (session.js branchForTask).
-      const branch = b.column === 'doing' && task && before && before.column !== 'doing' ? await session.branchForTask(task).catch(() => null) : null
-      return { task, tasks: session.taskList(), ...(finished && finished.merged ? { merged: finished.merged } : {}), ...(branch ? { branch } : {}) }
+      return { task, tasks: session.taskList() }
     },
     // What an agent gets when it picks a task up: history for its files, claims, the project's checks.
     'POST /tasks/brief': (b) => session.taskBrief(b.id),
@@ -181,10 +206,6 @@ export async function startControl (session, extras = {}) {
       return r
     },
     'POST /tasks/delete': (b) => { session.deleteTask(b.id); return { tasks: session.taskList() } },
-    // Merges Quilt made on its own (session.js autoSettle), and files waiting for their holder to let go.
-    'GET /merges': () => ({ merges: session.mergeList() }),
-    // quilt_clash: a file held because the session and GitHub changed the same lines (relay-clash.js).
-    'POST /clash': (b) => session.clash({ action: String(b.action || ''), path: String(b.path || ''), content: typeof b.content === 'string' ? b.content : null, checks: b.checks && typeof b.checks === 'object' ? b.checks : null, force: b.force === true }),
     'GET /rules': () => ({ text: session.projectRulesText() }),
     // Secrets (`quilt run`, quilt_secret_names): asked of the API as this session's own identity
     // (its person, or the agent it runs as). Run tokens and names only: never a value.
@@ -221,7 +242,8 @@ export async function startControl (session, extras = {}) {
       const auth = await secretsApi()
       return { text: await runMailTool(b.tool, b.args && typeof b.args === 'object' ? b.args : {}, { call: (method, route, body) => apiCall(auth, method, route, body), room: session.room, me: session.actorName ? session.actorName(b.via) : session.name }) }
     },
-    'GET /info': (b) => ({ room: session.room, dir: session.root, name: session.actorName(b.via), person: session.name, kind: session.kind, invite: extras.invite || null, viewInvite: extras.viewInvite || null, access: session.access, pid: process.pid })
+    // `version` and `features` (what this app tells the relay it can do): the CLI checks them before a move (bin/quilt.js).
+    'GET /info': (b) => ({ room: session.room, dir: session.root, name: session.actorName(b.via), person: session.name, kind: session.kind, invite: extras.invite || null, viewInvite: extras.viewInvite || null, access: session.access, pid: process.pid, version: appVersion(), features: session.features || FEATURES })
   }
   const server = http.createServer(async (req, res) => {
     const reply = (code, body) => {
@@ -299,15 +321,76 @@ export function findDaemon (start = process.env.QUILT_DIR || process.cwd()) {
   }
 }
 
-/** `timeoutMs`: give up (throw) when the session hasn't answered by then (git's helpers: git must never wait on Quilt). */
-export async function call (daemon, method, route, body, { timeoutMs = 0 } = {}) {
-  const res = await fetch(`http://127.0.0.1:${daemon.port}${route}`, {
-    method,
-    headers: { authorization: `Bearer ${daemon.token}`, 'content-type': 'application/json' },
-    body: body ? JSON.stringify(body) : undefined,
-    signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined
+const appVersion = () => { try { return currentVersion() } catch { return '' } }
+
+/**
+ * `timeoutMs`: give up (throw) when the session hasn't answered by then (git's helpers: git must never wait on Quilt).
+ * Without it, it waits as long as the session takes (a move into Seam can take minutes): node:http, not fetch, whose
+ * own limit gave up after 5 minutes with nothing but "fetch failed". A session that can't be reached, or that
+ * stopped while answering, throws with what happened and what to do (`unreachable`).
+ */
+export function call (daemon, method, route, body, { timeoutMs = 0 } = {}) {
+  const data = body ? JSON.stringify(body) : null
+  return new Promise((resolve, reject) => {
+    let timer = null
+    let late = null // the timeout's error, once it fired: whatever the socket says after it
+    const failed = (err) => { clearTimeout(timer); reject(late || (err.name === 'TimeoutError' ? err : unreachable(daemon, err))) }
+    const req = http.request({
+      host: '127.0.0.1',
+      port: daemon.port,
+      path: route,
+      method,
+      // A connection each: a kept-alive one outlives an app that restarted, and the next call would find it cut.
+      agent: false,
+      headers: { authorization: `Bearer ${daemon.token}`, 'content-type': 'application/json', ...(data ? { 'content-length': Buffer.byteLength(data) } : {}) }
+    }, (res) => {
+      let raw = ''
+      res.setEncoding('utf8')
+      res.on('data', (c) => { raw += c })
+      res.on('error', failed)
+      res.on('end', () => {
+        clearTimeout(timer)
+        let json
+        try { json = JSON.parse(raw) } catch { return reject(new Error(`Quilt's app sent something that isn't an answer (HTTP ${res.statusCode})`)) }
+        if (res.statusCode < 200 || res.statusCode >= 300) return reject(Object.assign(new Error(json.error || `HTTP ${res.statusCode}`), { status: res.statusCode }))
+        resolve(json)
+      })
+    })
+    req.on('error', failed)
+    if (timeoutMs) {
+      timer = setTimeout(() => {
+        late = Object.assign(new Error(`The session in ${daemon.dir || 'this folder'} did not answer within ${Math.round(timeoutMs / 1000)} s`), { name: 'TimeoutError' })
+        req.destroy(late)
+      }, timeoutMs)
+    }
+    req.end(data || undefined)
   })
-  const json = await res.json()
-  if (!res.ok) throw new Error(json.error || `HTTP ${res.status}`)
-  return json
+}
+
+/**
+ * The control server couldn't be reached (nothing listens: the app closed this session or restarted), or
+ * it closed the connection before answering (the session stopped meanwhile: left, quit, or sent away by
+ * the relay). `cut` tells the two apart for callers that say more (a move into Seam goes on without the app).
+ */
+export function unreachable (daemon, err) {
+  const code = (err && err.code) || ''
+  const where = daemon && daemon.dir ? ` for ${daemon.dir}` : ''
+  const cut = code !== 'ECONNREFUSED'
+  const msg = cut
+    ? `Quilt's app${where} stopped answering in the middle of this (${code || err.message}): the session there stopped (left, Quilt quit or restarted, or the relay sent this app away to update). Open the session in Quilt again, then check before trying again.`
+    : `Quilt's app${where} isn't answering: the session there is not running any more (Quilt quit, restarted, or left it). Open it in Quilt (or run quilt join here), then try again.`
+  return Object.assign(new Error(msg), { unreachable: true, cut, code })
+}
+
+/**
+ * Why `quilt session migrate` (or --switch, --back) must not start through this app, from its GET /info,
+ * or null. The move ends by sending away every app that can't follow a square (no `quilt-folders`): the
+ * owner's own app too, cutting this command's answer off mid-way. An app older than this check says
+ * neither its features nor its version; `cliVersion` is the quilt command's own.
+ */
+export function moveRefusal (info, cliVersion = '') {
+  const features = info && typeof info.features === 'string' ? info.features.split(',') : null
+  if (features && features.includes('quilt-folders')) return null
+  const was = info && info.version ? ` (${info.version})` : ''
+  return `Quilt's app for this folder${was} is older than this quilt command${cliVersion ? ` (${cliVersion})` : ''}: the move sends it away to update at the end, and this command would lose its answer. Update Quilt, or restart it so it runs the new version, then run this again.`
 }

package/src/duties.js

@@ -15,7 +15,7 @@
 //
 // Messages are chat entries ({ id, by, to, text, ts }) the reader can see.
 import { mentionsMe, mentioned, ALL_AGENTS } from './inbox.js'
-import { RELAY_BY } from './branches.js'
+import { RELAY_NAME as RELAY_BY } from './ui/chat.js'
 import { RELAY_OLD_NAMES } from './ui/chat.js'
 
 

package/src/force-date.js

@@ -0,0 +1,27 @@
+// The forced date (Seam's plans/quilt-source-control/16, flag 9): QUILT_SOURCE_FORCE_AT=<date> on the
+// relay. Unset (or not a date), nothing happens. From the date on, a session still in git mode is
+// moved on without anyone losing work: one with no git remote becomes a quilt without history on its
+// owner's next open; one with a git remote that has not cut over keeps chat, tasks, the agent feed and
+// the audit trail, and its live file sync stops for good (git, its remote, clones and CI untouched).
+// Pure: no I/O (test/unit/force-date.test.js). The words are in ui/force-words.js, which the app loads too.
+export { syncStoppedWords, forceAheadWords } from './ui/force-words.js'
+
+/** The date as ms, or null when unset or not a date. */
+export function forceAtMs (env = process.env) {
+  const v = String(env.QUILT_SOURCE_FORCE_AT || '').trim()
+  if (!v) return null
+  const ms = Date.parse(v)
+  return Number.isFinite(ms) ? ms : null
+}
+
+/**
+ * What the date means for a session now: null (no date, not yet, or already a quilt in its squares),
+ * 'stop' (a git remote, not cut over: live sync stops), or 'migrate' (no git remote: its owner's next
+ * open makes it a quilt without history).
+ */
+export function forcedAction ({ at, now = Date.now(), layout = 2, remote = false, stopped = false }) {
+  if (stopped) return 'stop'
+  if (at == null || now < at || layout === 3) return null
+  return remote ? 'stop' : 'migrate'
+}
+

package/src/fsutil.js

@@ -1,7 +1,8 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import crypto from 'node:crypto'
-import { makeIgnore, isIgnored, scopeIgnore, IGNORE_FILES } from './pathrules.js'
+import { isUtf8 } from 'node:buffer'
+import { makeIgnore, isIgnored, scopeIgnore, submodulePathsIn, IGNORE_FILES } from './pathrules.js'
 
 export { IGNORE_FILES } from './pathrules.js'
 export { MAX_TEXT_BYTES, MAX_BINARY_BYTES, LARGE_FILE_BYTES, MAX_STORED_BINARY_BYTES, CHAT_FILES, isIgnored, isSafeRelPath, globMatcher, patternsOverlap } from './pathrules.js'
@@ -27,6 +28,9 @@ export function closeWatcher (w) {
  */
 export function loadIgnore (root) {
   const ig = makeIgnore()
+  // A submodule (.gitmodules) is a repository of its own that git keeps as one commit id: its files
+  // are its own git's, never the session's (nor a Seam square's, which holds it as a gitlink).
+  for (const p of submodulePaths(root)) ig.add(`/${p}`)
   const visit = (dirRel) => {
     const dir = path.join(root, dirRel)
     for (const file of IGNORE_FILES) {
@@ -44,6 +48,11 @@ export function loadIgnore (root) {
   return ig
 }
 
+/** The folders .gitmodules names as submodules (`path = …`), as safe relative paths. */
+export function submodulePaths (root) {
+  try { return submodulePathsIn(fs.readFileSync(path.join(root, '.gitmodules'), 'utf8')) } catch { return [] }
+}
+
 /**
  * Resolves a relative path to an absolute one inside root, making sure no
  * symlinked parent directory points outside of it (or nowhere: a dangling
@@ -71,8 +80,9 @@ export function resolveInside (root, rel) {
 export function looksBinary (buf) {
   const n = Math.min(buf.length, 8000)
   for (let i = 0; i < n; i++) if (buf[i] === 0) return true
-  // Invalid UTF-8 is treated as binary so it round-trips byte for byte.
-  return !Buffer.from(buf.toString('utf8'), 'utf8').equals(buf)
+  // Invalid UTF-8 is treated as binary so it round-trips byte for byte. Checked in place: decoding
+  // and encoding every file again to compare made two copies of each one.
+  return !isUtf8(buf)
 }
 
 export function sha1 (buf) {