copilot-operator 0.1.3 → 0.1.4

package/README.md

@@ -132,8 +132,14 @@ Six rules decide what a step may do, and each is recorded with the run that it g
 - **Only the declared toolchain runs.** `execution.allowedPrograms` names the programs a command
   may start — the shells, the JavaScript, .NET, Java, Python, Go and Rust tools, `git`, and a few
   Windows utilities. A command that starts anything else is refused and sent back with the reason.
-  An empty list turns the gate off. This is a floor against the unknown binary, not a boundary:
-  allowing `node` allows `node -e`.
+  The programs are read the way PowerShell reads a line (`src/exec/commandHeads.ts`): strings,
+  operators, array values, method arguments and hashtable keys are not programs, and a command in a
+  script block, a subexpression, a string's `$( )` or after an assignment is still found. A line that
+  cannot be read with certainty — an unclosed quote or bracket, a program called through a variable
+  (`& $exe`) — is refused rather than guessed at. `cmd` steps are read by `cmd`'s own rules. A refused
+  step is reported to the chat as refused and never executed, with no exit code, apart from a
+  command that ran and failed. An empty list turns the gate off. This is a floor against the unknown
+  binary, not a boundary: allowing `node` allows `node -e`.
 - **Autonomy is graded.** An unattended run carries strictly more restrictions than a watched one,
   because the thing that makes a watched run safe is a person reading each line. Unattended
   requires a non-empty allowlist, and refuses an allowed program used to evaluate a string

package/dist/src/api/operator.controller.js

@@ -251,7 +251,12 @@ let OperatorController = class OperatorController {
      */
     async exportBundle(res, body) {
         const pairs = (body?.tasks ?? [])
-            .map((x) => ({ sessionId: (x?.sessionId ?? '').trim(), taskId: (x?.taskId ?? '').trim() }))
+            .map((x) => ({
+            sessionId: (x?.sessionId ?? '').trim(),
+            taskId: (x?.taskId ?? '').trim(),
+            // One attempt of the task rather than the task as it is now; see `exportBundle`.
+            ...(Number.isInteger(x?.attempt) ? { attempt: x.attempt } : {}),
+        }))
             .filter((x) => x.sessionId && x.taskId);
         try {
             const { fileName, content } = await this.ops.exportBundle(pairs);

package/dist/src/api/operator.service.js

@@ -23,7 +23,7 @@ import { newId, tidyVcsPlan } from '../session/model.js';
 import { runSession, openBrowser } from '../orchestrator/taskRunner.js';
 import { buildExport } from '../session/exportRecord.js';
 import { buildDebugExport } from '../session/debugExport.js';
-import { buildPlanExport, buildDomainExport, buildBotExport, buildBundleExport, exportFileName } from '../session/exports.js';
+import { buildPlanExport, buildDomainExport, buildBotExport, buildBundleExport, exportFileName, exportMachine, taskAtAttempt, withTask, writeAttemptRecord } from '../session/exports.js';
 import { suggestRunName } from '../session/runName.js';
 import { mirrorAllProjects, removeProjectMirrors, contextRoot } from '../context/desktopMirror.js';
 import { describeMirror } from '../context/projectMirror.js';
@@ -36,7 +36,7 @@ function sameFolder(a, b) {
     return a.trim() !== '' && norm(a) === norm(b);
 }
 import { importPlan, plannedSessionSignature, taskSignature } from '../plan/importPlan.js';
-import { vcsPreflight, restorePreview, restoreToBase, sessionBranches } from '../vcs/taskVcs.js';
+import { commitInterrupted, vcsPreflight, restorePreview, restoreToBase, sessionBranches } from '../vcs/taskVcs.js';
 import { gitAvailable, repoUnusableReason } from '../vcs/git.js';
 import { makeAuthorizer } from '../exec/authorizer.js';
 import { listSelectableDirs, collectFiles, findSelectionConflicts, describeConflicts, DEFAULT_IGNORE_DIRS } from '../context/projectMirror.js';
@@ -81,6 +81,9 @@ let OperatorService = class OperatorService {
                     level: 'warn',
                     message: `"${r.title}" was left unfinished by an earlier run and has been marked aborted`,
                 });
+                // What it had changed goes onto its branch, and its record into its run folder, as a
+                // finished task's would. See `commitInterrupted` and `writeAttemptRecord`.
+                await this.settleRecovered(r.sessionId, r.taskId).catch((e) => console.warn(`[api] could not settle "${r.title}": ${e.message}`));
             }
             if (recovered.length > 0) {
                 console.log(`[api] closed ${recovered.length} task(s) left unfinished by an earlier run`);
@@ -88,6 +91,31 @@ let OperatorService = class OperatorService {
         })();
         return this.ready;
     }
+    /**
+     * Closes the loose ends of one task the previous process left unfinished: commits its work on its
+     * branch, says so on the task, and writes the attempt's plan, work and runner into its run folder.
+     */
+    async settleRecovered(sessionId, taskId) {
+        const session = await this.store.getSession(sessionId);
+        const task = session?.tasks.find((t) => t.id === taskId);
+        if (!session || !task)
+            return;
+        const vcs = await commitInterrupted(session, task, task.reason ?? 'interrupted', this.bus);
+        const settled = vcs?.commit
+            ? await this.store.updateSession(sessionId, (s) => {
+                const t = s.tasks.find((x) => x.id === taskId);
+                if (!t)
+                    return;
+                t.vcs = vcs;
+                t.reason = `${t.reason ?? ''} What it had changed is committed on ${vcs.branch} as ${vcs.commit?.slice(0, 8)}.`.trim();
+            })
+            : session;
+        const ended = settled.tasks.find((t) => t.id === taskId);
+        if (!ended)
+            return;
+        const cfg = await this.settings.load();
+        await writeAttemptRecord(settled, ended, cfg.resolved.runsDir, exportMachine(cfg));
+    }
     /** Runs the startup work now, so it does not wait for the first request. */
     bootstrap() {
         return this.init();
@@ -498,12 +526,7 @@ let OperatorService = class OperatorService {
             ? buildPlanExport(scope)
             : kind === 'domain'
                 ? await buildDomainExport(scope, cfg.resolved.runsDir)
-                : await buildBotExport(scope, cfg.resolved.runsDir, {
-                    node: process.versions.node,
-                    platform: process.platform,
-                    cwd: cfg.resolved.cwd,
-                    limits: { ...cfg.limits, execution: { commandTimeoutSec: cfg.execution.commandTimeoutSec, idleTimeoutSec: cfg.execution.idleTimeoutSec, mode: cfg.execution.mode } },
-                });
+                : await buildBotExport(scope, cfg.resolved.runsDir, exportMachine(cfg));
         return { fileName: exportFileName(kind, scope.label), content: JSON.stringify(document, null, 2) };
     }
     /**
@@ -525,29 +548,39 @@ let OperatorService = class OperatorService {
             set.add(taskId);
             wanted.set(sessionId, set);
         }
+        /*
+         * A pair may name one attempt of its task — the button beside an earlier attempt does. That
+         * task is then exported as it stood for that attempt (`taskAtAttempt`): its text, its outcome,
+         * its run folder, and only the attempts before it.
+         */
         const sessions = [];
         for (const sessionId of wanted.keys()) {
-            const session = await this.store.getSession(sessionId);
-            if (session)
-                sessions.push(session);
+            let session = await this.store.getSession(sessionId);
+            if (!session)
+                continue;
+            for (const pair of pairs.filter((x) => x.sessionId === sessionId && x.attempt !== undefined)) {
+                const task = session.tasks.find((t) => t.id === pair.taskId);
+                const asItWas = task ? taskAtAttempt(task, pair.attempt) : null;
+                if (task && !asItWas)
+                    throw new Error(`"${task.title}" has no attempt ${pair.attempt}.`);
+                if (asItWas)
+                    session = withTask(session, asItWas);
+            }
+            sessions.push(session);
         }
         const found = sessions.flatMap((s) => s.tasks.filter((t) => wanted.get(s.id)?.has(t.id)));
         if (found.length === 0)
             throw new Error('None of the chosen tasks still exists.');
         // Named after what was chosen rather than after a run, because a selection is not a run: it
         // may be one task of one, or a task from each of three.
+        const one = pairs.length === 1 ? pairs[0] : undefined;
         const label = found.length === 1 && sessions.length === 1
-            ? `${sessions[0].name}-${found[0].title}`
+            ? `${sessions[0].name}-${found[0].title}${one?.attempt !== undefined ? `-attempt-${one.attempt}` : ''}`
             : sessions.length === 1
                 ? `${sessions[0].name}-${found.length}-tasks`
                 : `${found.length}-tasks-${sessions.length}-sessions`;
         const cfg = await this.settings.load();
-        const document = await buildBundleExport({ sessions, taskFilter: (s, t) => !!wanted.get(s.id)?.has(t.id), label }, cfg.resolved.runsDir, {
-            node: process.versions.node,
-            platform: process.platform,
-            cwd: cfg.resolved.cwd,
-            limits: { ...cfg.limits, execution: { commandTimeoutSec: cfg.execution.commandTimeoutSec, idleTimeoutSec: cfg.execution.idleTimeoutSec, mode: cfg.execution.mode } },
-        });
+        const document = await buildBundleExport({ sessions, taskFilter: (s, t) => !!wanted.get(s.id)?.has(t.id), label }, cfg.resolved.runsDir, exportMachine(cfg));
         return { fileName: exportFileName('bundle', label), content: JSON.stringify(document, null, 2) };
     }
     // --- running --------------------------------------------------------------------------
@@ -718,7 +751,7 @@ let OperatorService = class OperatorService {
         r.controller.abort();
         for (const [id, w] of this.waiting) {
             if (w.approval.sessionId === sessionId) {
-                w.resolve({ action: 'abort', reason: 'stopped by the operator' });
+                w.resolve({ action: 'abort', reason: 'stopped by the operator', by: 'operator' });
                 this.waiting.delete(id);
             }
         }
@@ -1275,8 +1308,8 @@ let OperatorService = class OperatorService {
         const decision = action === 'run' || action === 'run-all'
             ? { action: 'run' }
             : action === 'skip'
-                ? { action: 'skip', reason: 'skipped by the operator' }
-                : { action: 'abort', reason: 'aborted by the operator' };
+                ? { action: 'skip', reason: 'skipped by the operator', by: 'operator' }
+                : { action: 'abort', reason: 'aborted by the operator', by: 'operator' };
         w.resolve(decision);
         this.bus.publish({ sessionId: w.approval.sessionId, taskId: w.approval.taskId, type: 'approval-decided', level: 'info',
             message: `step ${w.approval.stepId}: ${action}`, data: { approvalId, action } });
@@ -1359,7 +1392,7 @@ let OperatorService = class OperatorService {
                 ...(held ? { network: held.network } : {}),
             };
             if (signal.aborted) {
-                resolvePromise({ action: 'abort', reason: 'stopped by the operator' });
+                resolvePromise({ action: 'abort', reason: 'stopped by the operator', by: 'operator' });
                 return;
             }
             this.waiting.set(approval.id, { approval, resolve: resolvePromise });

package/dist/src/exec/authorizer.js

@@ -47,9 +47,9 @@ export function terminalAuthorizer(cfg, print) {
         try {
             const answer = (await rl.question('  [Enter] run  [s] skip  [q] abort > ')).trim().toLowerCase();
             if (answer === 'q')
-                return { action: 'abort', reason: 'aborted by the operator' };
+                return { action: 'abort', reason: 'aborted by the operator', by: 'operator' };
             if (answer === 's')
-                return { action: 'skip', reason: 'skipped by the operator' };
+                return { action: 'skip', reason: 'skipped by the operator', by: 'operator' };
             return { action: 'run' };
         }
         finally {