copilot-operator 0.1.38 → 0.1.40

package/dist/src/api/server.js

@@ -22,6 +22,7 @@ import { pruneRuns } from '../session/retention.js';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { installLayout } from '../config/layout.js';
+import { captureTerminal } from '../log/terminal.js';
 /**
  * A settings file, or a policy lock, that cannot be used, answered the same way on every route: 409,
  * with the message that names the file and says what to do (see `SettingsUnusableError` and
@@ -50,6 +51,11 @@ export async function startApi(opts = {}) {
     const PORT = opts.port ?? Number(process.env.COP_API_PORT ?? 4000);
     const WEB_ORIGIN = opts.webOrigin ?? process.env.COP_WEB_ORIGIN ?? 'http://localhost:3210';
     const log = opts.quiet ? () => undefined : (line) => console.log(line);
+    /*
+     * What the console shows from here on is copied for the page to offer as a file (see
+     * `log/terminal.ts`): kept in memory now, written to the data folder once its permissions are set.
+     */
+    captureTerminal();
     const app = await NestFactory.create(AppModule, { logger: opts.quiet ? ['error', 'warn'] : ['error', 'warn', 'log'] });
     // A plan pasted from a chat carries every task's text at once, which the 100 KB default
     // refuses with a message about entity size that says nothing about plans.
@@ -96,6 +102,7 @@ export async function startApi(opts = {}) {
     const acl = secureDataDir(dataDir);
     if (!acl.ok)
         throw new Error(`copilot-operator api will not start: ${acl.reason}`);
+    captureTerminal(join(dataDir, 'logs'));
     const token = await ensureApiToken(dataDir);
     // The dev UI's origin, and this process's own for the interface it serves itself.
     const allowedOrigins = [WEB_ORIGIN, WEB_ORIGIN.replace('localhost', '127.0.0.1'), `http://127.0.0.1:${PORT}`, `http://localhost:${PORT}`];

package/dist/src/log/terminal.js

@@ -0,0 +1,145 @@
+/**
+ * What the bot's terminal showed, kept so it can be downloaded from the page.
+ *
+ * Asked for on 2026-10-13: when a run does not start at all, the operator wants to see the error, and
+ * a place to download what happened in the terminal. The terminal is the console the API runs in —
+ * `npm start` or `cop start` — and what it printed was on that screen only: a stack trace from
+ * Playwright about the browser profile, a refusal from git, scrolled away or closed with the window.
+ *
+ * Everything this process writes to stdout and stderr is copied, line by line with the time it was
+ * written, into a ring of the latest lines in memory and into `<data>/logs/terminal.log` on disk (the
+ * data folder is narrowed to this account; see `api/dataAcl.ts`), which rolls over to `terminal.1.log`
+ * at 5 MB. Writing to the console is not changed in any way: the copy is taken on the side, and a copy
+ * that fails is dropped rather than allowed to break the write it was copying.
+ */
+import { appendFileSync, mkdirSync, renameSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+const MAX_LINES = 5_000;
+const MAX_LINE = 4_000;
+const ROLL_AT = 5 * 1024 * 1024;
+const ring = [];
+const partial = { out: '', err: '' };
+let installed = false;
+let file = null;
+let written = 0;
+// eslint-disable-next-line no-control-regex
+const ANSI = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+/** The file the lines go to, once `captureTerminal` was given a folder. */
+export function terminalLogFile() {
+    return file;
+}
+/**
+ * Starts copying this process's console, once; a later call only points the copy at another folder.
+ * Lines written before a folder is known are kept in memory and written to the file when it is.
+ */
+export function captureTerminal(dir) {
+    if (dir)
+        setFolder(dir);
+    if (installed)
+        return;
+    installed = true;
+    for (const stream of ['out', 'err']) {
+        const target = stream === 'out' ? process.stdout : process.stderr;
+        const original = target.write.bind(target);
+        target.write = ((chunk, ...rest) => {
+            try {
+                take(stream, typeof chunk === 'string' ? chunk : Buffer.isBuffer(chunk) ? chunk.toString('utf8') : chunk instanceof Uint8Array ? Buffer.from(chunk).toString('utf8') : '');
+            }
+            catch {
+                /* the copy is never allowed to break the write */
+            }
+            return original(chunk, ...rest);
+        });
+    }
+}
+function setFolder(dir) {
+    try {
+        mkdirSync(dir, { recursive: true });
+        const next = join(dir, 'terminal.log');
+        if (next === file)
+            return;
+        const first = file === null;
+        file = next;
+        written = sizeOf(next);
+        // What was printed before the folder was known — the start-up — goes in first.
+        if (first && ring.length > 0)
+            append(ring.map(format).join(''));
+    }
+    catch {
+        file = null;
+    }
+}
+function take(stream, text) {
+    if (!text)
+        return;
+    const parts = (partial[stream] + text).split(/\r?\n/);
+    partial[stream] = parts.pop() ?? '';
+    // A line that never ends (a progress bar) is still kept, in pieces.
+    if (partial[stream].length > MAX_LINE) {
+        parts.push(partial[stream]);
+        partial[stream] = '';
+    }
+    const at = new Date().toISOString();
+    const out = [];
+    for (const raw of parts) {
+        const clean = raw.replace(ANSI, '').replace(/\r/g, '');
+        if (!clean.trim())
+            continue;
+        out.push({ at, stream, text: clean.length > MAX_LINE ? `${clean.slice(0, MAX_LINE)} …` : clean });
+    }
+    if (out.length === 0)
+        return;
+    ring.push(...out);
+    if (ring.length > MAX_LINES)
+        ring.splice(0, ring.length - MAX_LINES);
+    if (file)
+        append(out.map(format).join(''));
+}
+function format(l) {
+    return `${l.at} ${l.stream === 'err' ? 'ERR' : 'OUT'} ${l.text}\n`;
+}
+function append(text) {
+    if (!file)
+        return;
+    try {
+        if (written + text.length > ROLL_AT) {
+            try {
+                renameSync(file, file.replace(/\.log$/, '.1.log'));
+            }
+            catch {
+                /* nothing to roll over yet */
+            }
+            written = 0;
+        }
+        appendFileSync(file, text, 'utf8');
+        written += Buffer.byteLength(text);
+    }
+    catch {
+        /* a full disk or a locked file costs the copy, not the console */
+    }
+}
+function sizeOf(path) {
+    try {
+        return statSync(path).size;
+    }
+    catch {
+        return 0;
+    }
+}
+/** The lines kept in memory from `from` to `to` (both inclusive, ISO times), the latest `max` of them. */
+export function terminalLines(opts = {}) {
+    const within = ring.filter((l) => (!opts.from || l.at >= opts.from) && (!opts.to || l.at <= opts.to));
+    return opts.max !== undefined && within.length > opts.max ? within.slice(within.length - opts.max) : within;
+}
+/** The lines as the download shows them: local time, the stream, the text. */
+export function formatTerminal(list) {
+    return list.map((l) => `${localTime(l.at)} ${l.stream === 'err' ? 'ERR' : '   '} ${l.text}`).join('\n');
+}
+/** `2026-10-13 10:22:31.123` in this machine's time zone. */
+export function localTime(iso) {
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime()))
+        return iso;
+    const p = (n, w = 2) => String(n).padStart(w, '0');
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}.${p(d.getMilliseconds(), 3)}`;
+}

package/dist/src/orchestrator/contract.js

@@ -79,11 +79,68 @@ function branchCheckPasses(check, branch) {
     return null;
 }
 /** Each contradiction in the task, as a sentence; empty when it can be satisfied. */
-export async function contractConflicts(task, cwd, repoDir, 
+export async function contractConflicts(task, cwd, repoDir, vcs = {}) {
+    return (await contractConflictsWithFixes(task, cwd, repoDir, vcs)).map((c) => c.text);
+}
+/**
+ * The contract fixes applied to the task as it is now, as the patch an edit or a re-run takes. In the
+ * order given; a fix naming a check the task no longer has changes nothing. Nothing the operator did not
+ * choose is changed: a read-only task keeps its paths unless "drop-scope" was chosen, even though the two
+ * contradict each other, because leaving that contradiction was the operator's choice.
+ */
+export function contractFixPatch(task, fixes) {
+    let readOnly = !!task.readOnly;
+    let scope = [...(task.scope ?? [])];
+    let checks = [...(task.checks ?? [])];
+    for (const fix of fixes) {
+        if (fix.kind === 'add-to-scope') {
+            if (!scope.includes(fix.path))
+                scope.push(fix.path);
+        }
+        else if (fix.kind === 'not-read-only') {
+            readOnly = false;
+            for (const p of fix.scope)
+                if (!scope.includes(p))
+                    scope.push(p);
+        }
+        else if (fix.kind === 'drop-scope') {
+            scope = [];
+        }
+        else if (fix.kind === 'drop-check') {
+            checks = checks.filter((c) => c.name !== fix.check);
+        }
+    }
+    return { readOnly, scope, checks };
+}
+/**
+ * What changed in the contract, read from before and after rather than from the fixes chosen: two fixes
+ * can pull different ways ("drop the paths" for one contradiction, "allow only this file" for another),
+ * and their descriptions side by side read as a contradiction; the result does not. For a log line or
+ * an event.
+ */
+export function describeContractChange(before, after) {
+    const out = [];
+    if (!!before.readOnly !== !!after.readOnly)
+        out.push(after.readOnly ? 'now read-only' : 'no longer read-only');
+    const was = (before.scope ?? []).join(', ');
+    const now = (after.scope ?? []).join(', ');
+    if (was !== now)
+        out.push(now ? `may change only ${now}${was ? ` (was ${was})` : ''}` : `its list of paths removed (was ${was})`);
+    const kept = new Set((after.checks ?? []).map((c) => c.name));
+    for (const c of before.checks ?? [])
+        if (!kept.has(c.name))
+            out.push(`the check "${c.name}" dropped`);
+    return out;
+}
+/** Each contradiction in the task, with the ways out of it; empty when it can be satisfied. */
+export async function contractConflictsWithFixes(task, cwd, repoDir, 
 /** The branch version control put the task on, when it is on; where its file checks are judged (see `ContractTree`). */
 vcs = {}) {
     const out = [];
     const scope = task.scope ?? [];
+    // Only a check the task itself carries can be dropped from it; a review's check is that review's finding.
+    const own = new Set((task.checks ?? []).map((c) => c.name));
+    const dropIfOwn = (check) => (own.has(check.name) ? [{ kind: 'drop-check', check: check.name }] : []);
     /*
      * A check that the task is on a branch the runner did not choose can never pass: the chat may not
      * switch branches. Seen on 2026-09-30, a check still expecting the recovery branch the session had
@@ -95,12 +152,19 @@ vcs = {}) {
         for (const check of all.filter(readsCurrentBranch)) {
             if (branchCheckPasses(check, vcs.branch) !== false)
                 continue;
-            out.push(`The check "${check.name}" expects another branch, but version control put this task on ${vcs.branch}, and the chat may not switch branches. ` +
-                'To check that earlier work is included, check its commit instead: git merge-base --is-ancestor <commit> HEAD.');
+            out.push({
+                text: `The check "${check.name}" expects another branch, but version control put this task on ${vcs.branch}, and the chat may not switch branches. ` +
+                    'To check that earlier work is included, check its commit instead: git merge-base --is-ancestor <commit> HEAD.',
+                fixes: dropIfOwn(check),
+            });
         }
     }
     if (task.readOnly && scope.length > 0) {
-        out.push(`It is read-only, which allows no change, and also scoped to ${scope.join(', ')}, which allows changes there.`);
+        out.push({
+            text: `It is read-only, which allows no change, and also scoped to ${scope.join(', ')}, which allows changes there.`,
+            // Read-only already means "nowhere", so dropping the paths changes nothing the task could do.
+            fixes: [{ kind: 'drop-scope' }, { kind: 'not-read-only', scope: [...scope] }],
+        });
     }
     if (!task.readOnly && scope.length === 0)
         return out;
@@ -125,10 +189,17 @@ vcs = {}) {
         if (inside && (vcs.carried?.length ?? 0) > 0 && inScope(rel, vcs.carried))
             continue;
         if (task.readOnly) {
-            out.push(`The check "${check.name}" fails now and can only pass if ${rel || path} changes, but the task is read-only.`);
+            out.push({
+                text: `The check "${check.name}" fails now and can only pass if ${rel || path} changes, but the task is read-only.`,
+                // Allowed to change that one file and nothing else: the least a read-only task can be loosened.
+                fixes: [...(inside ? [{ kind: 'not-read-only', scope: [rel] }] : []), ...dropIfOwn(check)],
+            });
         }
         else if (inside && !inScope(rel, scope)) {
-            out.push(`The check "${check.name}" fails now and can only pass if ${rel} changes, but the task's scope (${scope.join(', ')}) leaves that file out.`);
+            out.push({
+                text: `The check "${check.name}" fails now and can only pass if ${rel} changes, but the task's scope (${scope.join(', ')}) leaves that file out.`,
+                fixes: [{ kind: 'add-to-scope', path: rel }, ...dropIfOwn(check)],
+            });
         }
     }
     return out;