letagents 0.12.18 → 0.12.20

package/shared/workspace-review-worker.mjs

@@ -0,0 +1,47 @@
+import { parentPort } from 'node:worker_threads';
+import { DatabaseSync } from 'node:sqlite';
+import { decodeWorkspaceReview, parseWorkspaceReviewPage } from './workspace-review.mjs';
+import { createWorkspaceDiffIndex, readWorkspaceDiffPage } from './workspace-diff.mjs';
+
+let review = null;
+let pages = [], digest = '', total = 0;
+const indexes = new Map();
+const describe = () => ({ version: 1, workspace: { ...review.workspace, patch: '' }, contribution: { ...review.contribution, patch: '' } });
+parentPort.on('message', ({ id, method, input }) => {
+  try {
+    let result;
+    if (method === 'local') {
+      let db;
+      try {
+        db = new DatabaseSync(input.databasePath, { readOnly: true });
+        const row = db.prepare(`SELECT r.data,r.digest FROM room_workspace_reviews r JOIN room_work_publications p
+          USING(agent_id,room_id,source_message_id) WHERE p.room_id=? AND p.agent_key=? AND p.source_message_id=? AND p.api_origin=? AND p.state='open'`)
+          .get(input.roomId, input.agentKey, input.sourceMessageId, input.apiOrigin);
+        if (row) review = decodeWorkspaceReview(String(row.data), String(row.digest));
+      } catch { review = null; } finally { db?.close(); }
+      result = review ? describe() : null;
+    } else if (method === 'append') {
+      if (!Array.isArray(input) || input.length > 4) throw new Error('Invalid review pages.');
+      if (!pages.length) { review = null; indexes.clear(); }
+      for (const raw of input) {
+        const page = parseWorkspaceReviewPage(raw);
+        if (!page || page.index !== pages.length || (pages.length && (page.digest !== digest || page.total !== total))) throw new Error('Incomplete workspace review.');
+        digest = page.digest; total = page.total; pages.push(page.data);
+      }
+      result = null;
+    } else if (method === 'finish') {
+      if (!total || pages.length !== total) throw new Error('Incomplete workspace review.');
+      const data = pages.join(''); pages = [];
+      review = decodeWorkspaceReview(data, digest);
+      result = describe();
+    } else if (method === 'page') {
+      if (!review || !['workspace', 'contribution'].includes(input.view) || typeof input.path !== 'string') throw new Error('Review is not open.');
+      if (!indexes.has(input.view)) {
+        const snapshot = review[input.view];
+        indexes.set(input.view, createWorkspaceDiffIndex(snapshot.patch, snapshot.files));
+      }
+      result = readWorkspaceDiffPage(indexes.get(input.view), input.path, input);
+    } else throw new Error('Invalid review operation.');
+    parentPort.postMessage({ id, result });
+  } catch (error) { parentPort.postMessage({ id, error: error.message }); }
+});

package/shared/workspace-review.d.mts

@@ -0,0 +1,10 @@
+import type { WorkspaceChangeSummary } from './workspace-change-summary.mjs';
+export const REVIEW_LIMIT: number;
+export const REVIEW_PAGE_SIZE: number;
+export const REVIEW_MAX_PAGES: number;
+export type WorkspaceReview = { version: 1; workspace: WorkspaceChangeSummary; contribution: WorkspaceChangeSummary };
+export type WorkspaceReviewPage = { digest: string; index: number; total: number; data: string };
+export function parseWorkspaceReview(value: unknown): WorkspaceReview | null;
+export function encodeWorkspaceReview(value: WorkspaceReview): { data: string; digest: string };
+export function decodeWorkspaceReview(data: string, digest: string): WorkspaceReview;
+export function parseWorkspaceReviewPage(value: unknown): WorkspaceReviewPage | null;

package/shared/workspace-review.mjs

@@ -0,0 +1,45 @@
+import { createHash } from 'node:crypto';
+import { gzipSync, gunzipSync } from 'node:zlib';
+import { parseWorkspaceChangeSummary } from './workspace-change-summary.mjs';
+
+// Full review bytes travel separately from the bounded room timeline.
+export const REVIEW_LIMIT = 128 * 1024 * 1024;
+export const REVIEW_PAGE_SIZE = 64 * 1024;
+export const REVIEW_MAX_PAGES = REVIEW_LIMIT / REVIEW_PAGE_SIZE;
+export function parseWorkspaceReview(value) {
+  if (!value || value.version !== 1 || Object.keys(value).sort().join(',') !== 'contribution,version,workspace') return null;
+  const workspace = parseWorkspaceChangeSummary(value.workspace, true);
+  const contribution = parseWorkspaceChangeSummary(value.contribution, true);
+  if (!workspace || !contribution) return null;
+  return { version: 1, workspace, contribution };
+}
+export function encodeWorkspaceReview(value) {
+  const parsed = parseWorkspaceReview(value);
+  if (!parsed) throw new Error('Invalid full workspace review.');
+  const json = JSON.stringify(parsed);
+  if (Buffer.byteLength(json) > REVIEW_LIMIT) throw new RangeError('Workspace review exceeds capture capacity.');
+  const data = gzipSync(json).toString('base64');
+  if (data.length > REVIEW_LIMIT) throw new RangeError('Workspace review exceeds transfer capacity.');
+  return { data, digest: createHash('sha256').update(data).digest('hex') };
+}
+export function decodeWorkspaceReview(data, digest) {
+  if (typeof data !== 'string' || data.length > REVIEW_LIMIT || createHash('sha256').update(data).digest('hex') !== digest) throw new Error('Incomplete workspace review.');
+  const compressed = Buffer.from(data, 'base64');
+  // Our single-member gzip records its output size in the trailer. Use it only
+  // as a bounded allocation hint: zlib still verifies CRC/size and enforces the
+  // output limit. One spare byte avoids allocating another full output buffer.
+  const chunkSize = compressed.length < 4 ? 16 * 1024
+    : Math.max(16 * 1024, Math.min(REVIEW_LIMIT + 1, compressed.readUInt32LE(compressed.length - 4) + 1));
+  const value = parseWorkspaceReview(JSON.parse(gunzipSync(compressed, { maxOutputLength: REVIEW_LIMIT, chunkSize }).toString('utf8')));
+  if (!value) throw new Error('Invalid workspace review.');
+  return value;
+}
+export function parseWorkspaceReviewPage(value) {
+  if (!value || Object.keys(value).sort().join(',') !== 'data,digest,index,total'
+    || typeof value.digest !== 'string' || !/^[a-f0-9]{64}$/.test(value.digest)
+    || !Number.isSafeInteger(value.total) || value.total < 1 || value.total > REVIEW_MAX_PAGES
+    || !Number.isSafeInteger(value.index) || value.index < 0 || value.index >= value.total
+    || typeof value.data !== 'string' || !/^[A-Za-z0-9+/]+={0,2}$/.test(value.data)
+    || value.data.length > REVIEW_PAGE_SIZE || (value.index < value.total - 1 && value.data.length !== REVIEW_PAGE_SIZE)) return null;
+  return { digest: value.digest, index: value.index, total: value.total, data: value.data };
+}

package/shared/workspace-turn-capture.d.mts

@@ -0,0 +1,10 @@
+import type { WorkspaceChangeSummary } from './workspace-change-summary.mjs';
+import type { WorkspaceReview } from './workspace-review.mjs';
+export function unavailableWorkspace(): WorkspaceChangeSummary;
+export function captureWorkspaceTree(workspace: string, identity: string): Promise<string | null>;
+export function releaseWorkspaceTree(workspace: string, identity: string): Promise<void>;
+export function captureWorkspacePair(workspace: string, startingRevision: string | null, baseline: string | null, identity: string): Promise<{
+  workspace: WorkspaceChangeSummary;
+  contribution: { changes: WorkspaceChangeSummary; summary: string | null };
+  review: WorkspaceReview;
+}>;

package/shared/workspace-turn-capture.mjs

@@ -0,0 +1,118 @@
+import { execFile } from 'node:child_process';
+import { constants } from 'node:fs';
+import { lstat, mkdtemp, open, readlink, realpath, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, relative } from 'node:path';
+import { createHash } from 'node:crypto';
+import { captureWorkspaceChanges } from './workspace-change-capture.mjs';
+const environment = () => Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith('GIT_')));
+function git(cwd, args, signal, index, input) {
+    return new Promise((resolve, reject) => {
+        const child = execFile('git', ['-c', 'core.hooksPath=/dev/null', '--no-optional-locks', ...args], {
+            cwd, signal, timeout: 5_000, maxBuffer: 4 * 8 * 1024 * 1024, encoding: 'utf8',
+            env: { ...environment(), GIT_TERMINAL_PROMPT: '0', ...(index ? { GIT_INDEX_FILE: index } : {}) },
+        }, (error, stdout) => error ? reject(error) : resolve(stdout));
+        child.stdin?.on('error', () => { });
+        child.stdin?.end(input);
+    });
+}
+export const unavailableWorkspace = () => ({ captured_at: new Date().toISOString(), branch: null,
+    base_revision: null, state: 'unavailable', files: [], additions: 0, deletions: 0, hidden_files: 0, patch: '', patch_truncated: false });
+const reviewRef = (identity) => `refs/letagents/workspace-review/${createHash('sha256').update(identity).digest('hex')}`;
+/** Retained Git tree, with no changes to the user's index, branch, or working files.
+ * Unsupported/oversized observations fail closed; a partial baseline is never a turn diff. */
+export async function captureWorkspaceTree(workspace, identity) {
+    const signal = AbortSignal.timeout(20_000);
+    const scratch = await mkdtemp(join(tmpdir(), 'letagents-workspace-'));
+    const index = join(scratch, 'index');
+    try {
+        const root = await realpath(workspace);
+        const head = (await git(root, ['rev-parse', '--verify', 'HEAD^{tree}'], signal)).trim();
+        await git(root, ['read-tree', head], signal, index);
+        const original = new Map((await git(root, ['ls-tree', '-r', '-z', head], signal)).split('\0').filter(Boolean).map(entry => {
+            const split = entry.indexOf('\t');
+            return [entry.slice(split + 1), entry.slice(0, split).split(' ')];
+        }));
+        const paths = [...new Set([...original.keys(), ...(await git(root, ['ls-files', '--cached', '--others', '--exclude-standard', '-z'], signal)).split('\0').filter(Boolean)])];
+        if (paths.length > 10_000)
+            return null;
+        const entries = [];
+        let bytesRead = 0;
+        for (const path of paths) {
+            // Parent symlinks must not redirect an observation outside the managed workspace.
+            const parent = await realpath(dirname(join(root, path))).catch(() => null);
+            if (parent && (relative(root, parent).startsWith('..') || relative(root, parent).startsWith('/')))
+                return null;
+            if (signal.aborted)
+                return null;
+            const absolute = join(root, path);
+            const stat = await lstat(absolute).catch(error => { if (error.code === 'ENOENT' || error.code === 'ENOTDIR')
+                return null; throw error; });
+            if (original.get(path)?.[1] === 'commit')
+                return null; // Submodules need their own workspace.
+            if (!stat) {
+                entries.push(`0 ${'0'.repeat(head.length)}\t${path}\0`);
+                continue;
+            }
+            let bytes;
+            if (stat.isSymbolicLink())
+                bytes = Buffer.from(await readlink(absolute));
+            else if (stat.isFile() && stat.size <= 8 * 1024 * 1024) {
+                const handle = await open(absolute, constants.O_RDONLY | constants.O_NOFOLLOW);
+                try {
+                    const buffer = Buffer.alloc(8 * 1024 * 1024 + 1);
+                    const read = await handle.read(buffer, 0, buffer.length, 0);
+                    bytes = buffer.subarray(0, read.bytesRead);
+                }
+                finally {
+                    await handle.close();
+                }
+            }
+            else
+                return null; // Includes submodule changes: do not attribute a fabricated text diff.
+            bytesRead += bytes.length;
+            if (bytes.length > 8 * 1024 * 1024 || bytesRead > 64 * 1024 * 1024)
+                return null;
+            const mode = stat.isSymbolicLink() ? '120000' : stat.mode & 0o111 ? '100755' : '100644';
+            const rawOid = createHash(head.length === 64 ? 'sha256' : 'sha1').update(`blob ${bytes.length}\0`).update(bytes).digest('hex');
+            if (original.get(path)?.[0] === mode && original.get(path)?.[2] === rawOid)
+                continue;
+            if (entries.length >= 10_000)
+                return null;
+            const oid = (await git(root, ['hash-object', '-w', '--no-filters', '--stdin'], signal, undefined, bytes)).trim();
+            entries.push(`${mode} ${oid}\t${path}\0`);
+        }
+        if (entries.length)
+            await git(root, ['update-index', '-z', '--index-info'], signal, index, entries.join(''));
+        const tree = (await git(root, ['write-tree'], signal, index)).trim();
+        await git(root, ['update-ref', reviewRef(identity), tree], signal);
+        return tree;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await rm(scratch, { recursive: true, force: true });
+    }
+}
+export async function releaseWorkspaceTree(workspace, identity) {
+    try {
+        await git(workspace, ['update-ref', '-d', reviewRef(identity)], AbortSignal.timeout(5_000));
+    }
+    catch { /* Retain on failure, never jeopardize provider work. */ }
+}
+export async function captureWorkspacePair(workspace, startingRevision, baseline, identity) {
+    const tree = await captureWorkspaceTree(workspace, `${identity}:settled`);
+    try {
+        const full = tree ? await captureWorkspaceChanges(workspace, startingRevision, tree, true) : unavailableWorkspace();
+        const changes = tree && baseline ? await captureWorkspaceChanges(workspace, baseline, tree, true) : unavailableWorkspace();
+        const preview = (snapshot) => ({ ...snapshot,
+            files: snapshot.files.slice(0, 200), hidden_files: snapshot.hidden_files + Math.max(0, snapshot.files.length - 200),
+            patch: snapshot.patch.slice(0, 48 * 1024), patch_truncated: snapshot.patch_truncated || snapshot.patch.length > 48 * 1024 });
+        return { workspace: preview(full), contribution: { changes: preview(changes), summary: null },
+            review: { version: 1, workspace: full, contribution: changes } };
+    }
+    finally {
+        await releaseWorkspaceTree(workspace, `${identity}:settled`);
+    }
+}