mirab 0.0.0-stage → 0.2.0

package/src/channel/wire.ts

@@ -0,0 +1,104 @@
+// How a station channel reaches the agent in its VM: one JSON line each way
+// on the guest pty, the same code on both ends. In: a message from another
+// member. Out: what the agent says, prefixed so nothing else the guest prints
+// can pass for it. The host checks every line it reads; the guest is
+// untrusted, and so is every message.
+import { StringDecoder } from 'node:string_decoder'
+import { z } from 'zod'
+import { MAX_MESSAGE } from './local'
+
+/** What the guest prints before each thing the agent says. */
+export const SAY_LINE = 'mirab-say '
+
+export const toAgent = z.strictObject({
+  id: z.string().min(1).max(64),
+  from: z.string().min(1).max(512),
+  text: z.string(),
+})
+export type ToAgent = z.infer<typeof toAgent>
+
+/** What the guest says, cut to fit a message (with a marker), never dropped. */
+export function fitted(text: string): string {
+  if (Buffer.byteLength(text) <= MAX_MESSAGE) return text
+  const marker = ' [cut: too long for one message]'
+  let cut = Buffer.from(text)
+    .subarray(0, MAX_MESSAGE - marker.length - 4)
+    .toString()
+  cut = cut.replace(/\uFFFD$/, '')
+  return cut + marker
+}
+
+export const fromAgent = z.strictObject({
+  text: z.string().refine((t) => Buffer.byteLength(t) <= MAX_MESSAGE, {
+    message: `a message is at most ${MAX_MESSAGE} bytes`,
+  }),
+  /** Said about the chat, not in it. */
+  note: z.literal(true).optional(),
+  /** The message this finishes: its reply, or why there is none. */
+  answers: z.string().min(1).max(64).optional(),
+})
+export type FromAgent = z.infer<typeof fromAgent>
+
+export const encodeToAgent = (m: ToAgent) => JSON.stringify(m) + '\n'
+export const encodeFromAgent = (m: FromAgent) =>
+  SAY_LINE + JSON.stringify(m) + '\n'
+
+/** A line the guest printed: what the agent said, or undefined for anything else. */
+export function decodeFromAgent(line: string): FromAgent | undefined {
+  if (!line.startsWith(SAY_LINE)) return undefined
+  try {
+    const parsed = fromAgent.safeParse(JSON.parse(line.slice(SAY_LINE.length)))
+    return parsed.success ? parsed.data : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/** A line the host wrote: a message for the agent, or undefined. */
+export function decodeToAgent(line: string): ToAgent | undefined {
+  try {
+    const parsed = toAgent.safeParse(JSON.parse(line))
+    return parsed.success ? parsed.data : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/** A message's text as a terminal may show it: no escape sequences, no
+ *  carriage returns, no control characters but newline and tab, so what
+ *  someone else wrote can't move the cursor, set the title or the clipboard,
+ *  or pass for a line the person typed. */
+export function printable(text: string): string {
+  return (
+    text
+      // Controls, DEL and C1; bidi overrides and isolates, zero-width marks,
+      // line and paragraph separators: anything that hides or reorders text.
+      .replace(
+        /[\u0000-\u0008\u000b-\u001f\u007f-\u009f\u200b-\u200f\u2028-\u202e\u2060-\u2069\ufeff]/g,
+        '�',
+      )
+      // A line it starts is indented, so it can't stand as one of the person's.
+      .replace(/\n/g, '\n  ')
+  )
+}
+
+/** Splits a byte stream into lines (`\r\n` or `\n`), holding the tail. A
+ *  character split across chunks stays whole. The limit allows for JSON's
+ *  escapes (up to 6 characters for one) in a message at its largest. */
+export function lineSplitter(
+  onLine: (line: string) => void,
+  max = 7 * MAX_MESSAGE,
+) {
+  let pending = ''
+  const decoder = new StringDecoder('utf8')
+  return (chunk: Buffer | string) => {
+    pending += typeof chunk === 'string' ? chunk : decoder.write(chunk)
+    let at: number
+    while ((at = pending.indexOf('\n')) >= 0) {
+      onLine(pending.slice(0, at).replace(/\r$/, ''))
+      pending = pending.slice(at + 1)
+    }
+    // A line longer than any message is noise: dropped, never buffered forever.
+    if (pending.length > max) pending = ''
+  }
+}

package/src/dev-sync.ts

@@ -0,0 +1,206 @@
+// Live sync for `mirab dev`: the person's edits on the host reach the agent's
+// VM as they save, and the agent's changes come back when the session ends.
+//
+// Into the VM, per path, against the baseline (the tree as the VM last got
+// it): a change on the host is pushed only while the guest still matches the
+// baseline. If the agent changed that path too, the person's version stays on
+// the host and the agent's comes back as a conflict at the end (sync.ts),
+// never silently overwritten either way. Host Git metadata is never pushed.
+import { watch, type FSWatcher } from 'node:fs'
+import { AnchoredDirectory } from './isolation/anchored-fs'
+import type { Isolation } from './isolation/session'
+import {
+  hostManifest,
+  protectedMetadata,
+  sameEntry,
+  validPath,
+  type Manifest,
+} from './isolation/sync'
+
+/** How long the host's edits settle before they are pushed. */
+const SETTLE_MS = 250
+const GUEST_ROOT = '/workspace'
+
+export interface LiveSync {
+  /** Pushes whatever changed now (also what the watcher calls). */
+  push(): Promise<{ pushed: string[]; kept: string[] }>
+  /** Stops watching and waits for a push under way, so sync-back never
+   *  runs beside one. */
+  stop(): Promise<void>
+}
+
+export function liveSync(o: {
+  project: string
+  iso: Pick<Isolation, 'put' | 'exec' | 'files'>
+  /** The tree as the VM got it; updated as paths are pushed (sync-back reads it). */
+  baseline: Manifest
+  log?: (line: string) => void
+  /** Off: only `push()` pushes (tests drive it by hand). */
+  watch?: boolean
+}): LiveSync {
+  // What the host had when each path was last looked at.
+  const host = new Map(o.baseline)
+  let running: Promise<{ pushed: string[]; kept: string[] }> | undefined
+  let again = false
+  let stopped = false
+  const run = async (argv: string[]) => {
+    const code = await o.iso.exec(argv, {
+      cwd: GUEST_ROOT,
+      env: { PATH: '/usr/bin:/bin' },
+      timeoutMs: 30_000,
+      signal: new AbortController().signal,
+      onLine: async () => {},
+    })
+    if (code !== 0) throw new Error(`${argv[0]} exited ${code}`)
+  }
+  const once = async () => {
+    const pushed: string[] = []
+    const kept: string[] = []
+    if (stopped) return { pushed, kept }
+    const next = await hostManifest(o.project)
+    const changed = [...new Set([...host.keys(), ...next.keys()])].filter(
+      (p) =>
+        !sameEntry(host.get(p), next.get(p)) &&
+        validPath(p) &&
+        !protectedMetadata(p),
+    )
+    if (!changed.length) return { pushed, kept }
+    const guest: Manifest = new Map(
+      (await o.iso.files!.list(GUEST_ROOT)).map((e) => [e.p, e]),
+    )
+    /** The agent changed `p`, or anything under it. */
+    const paths = [...new Set([...guest.keys(), ...o.baseline.keys()])]
+    const agentTouched = (p: string) => {
+      if (!sameEntry(guest.get(p), o.baseline.get(p))) return true
+      // Only a directory has anything under it.
+      if (guest.get(p)?.k !== 'd' && o.baseline.get(p)?.k !== 'd') return false
+      const under = `${p}/`
+      for (const q of paths)
+        if (q.startsWith(under) && !sameEntry(guest.get(q), o.baseline.get(q)))
+          return true
+      return false
+    }
+    // Deletions deepest first, then directories and files parents first.
+    const order = [
+      ...changed
+        .filter((p) => !next.has(p))
+        .sort()
+        .reverse(),
+      ...changed.filter((p) => next.has(p)).sort(),
+    ]
+    const root = AnchoredDirectory.open(o.project)
+    try {
+      for (const p of order) {
+        const now = next.get(p)
+        const before = host.get(p)
+        if (now) host.set(p, now)
+        else host.delete(p)
+        const was = guest.get(p)
+        // Removing a directory, or one of a different kind in the way,
+        // would take whatever the agent made inside it.
+        const removes = !now || (was && was.k !== now.k)
+        if (agentTouched(p) || now?.k === 'l') {
+          // The agent changed it too (the person's version waits on the
+          // host for sync-back), or it is a link, which stays as the VM has
+          // it until then.
+          kept.push(p)
+          continue
+        }
+        const at = `${GUEST_ROOT}/${p}`
+        try {
+          let entry = now
+          if (removes && was) await run(['rm', '-rf', '--', at])
+          if (now?.k === 'd') {
+            await run(['mkdir', '-p', '--', at])
+            await run(['chmod', (now.m & 0o777).toString(8), '--', at])
+          } else if (now?.k === 'f') {
+            // Read through the anchored root (never a link), and record the
+            // bytes that went, not the ones listed a moment before.
+            const parent = root.parent(p)
+            let read
+            try {
+              read = parent.read(p.split('/').at(-1)!, p)
+            } finally {
+              if (parent !== root) parent.close()
+            }
+            if (!read) throw new Error('it changed while it was read')
+            entry = read.entry
+            await o.iso.put(at, read.data, read.entry.m & 0o777)
+            await run(['chmod', (read.entry.m & 0o777).toString(8), '--', at])
+            host.set(p, read.entry)
+          }
+          if (entry) o.baseline.set(p, entry)
+          else o.baseline.delete(p)
+          pushed.push(p)
+        } catch (e) {
+          // One path that can't go doesn't hold up the rest; the next edit
+          // tries again, and sync-back settles it at the end.
+          if (before) host.set(p, before)
+          else host.delete(p)
+          kept.push(p)
+          o.log?.(`live sync: ${p}: ${(e as Error).message}`)
+        }
+      }
+    } finally {
+      root.close()
+    }
+    if (pushed.length) o.log?.(`synced into the VM: ${pushed.join(', ')}`)
+    if (kept.length)
+      o.log?.(`changed in the VM too, kept on this machine: ${kept.join(', ')}`)
+    return { pushed, kept }
+  }
+  // One push at a time; edits during one start another after it, even when
+  // it failed.
+  const push = () => {
+    if (running) {
+      again = true
+      return running
+    }
+    running = (async () => {
+      let result = { pushed: [] as string[], kept: [] as string[] }
+      do {
+        again = false
+        try {
+          result = await once()
+        } catch (e) {
+          if (!again || stopped) throw e
+          o.log?.(`live sync: ${(e as Error).message}`)
+        }
+      } while (again && !stopped)
+      return result
+    })().finally(() => (running = undefined))
+    return running
+  }
+  let timer: ReturnType<typeof setTimeout> | undefined
+  let watcher: FSWatcher | undefined
+  try {
+    if (o.watch !== false)
+      watcher = watch(o.project, { recursive: true }, (_, name) => {
+        if (name && (name === '.git' || String(name).startsWith('.git/')))
+          return
+        clearTimeout(timer)
+        timer = setTimeout(
+          () =>
+            void push().catch((e) =>
+              o.log?.(`live sync: ${(e as Error).message}`),
+            ),
+          SETTLE_MS,
+        )
+      })
+    watcher?.on('error', (e) => {
+      o.log?.(`live sync is off: ${e.message}`)
+      watcher?.close()
+    })
+  } catch (e) {
+    o.log?.(`live sync is off: ${(e as Error).message}`)
+  }
+  return {
+    push,
+    async stop() {
+      stopped = true
+      clearTimeout(timer)
+      watcher?.close()
+      await running?.catch(() => {})
+    },
+  }
+}