copilot-operator 0.1.38 → 0.1.40

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

@@ -55,6 +55,29 @@ function asContextKind(kind) {
     }
     return kind;
 }
+/**
+ * The start window's choices as the service takes them: one per session id, each of a known shape, and
+ * nothing else. A choice of any other shape is dropped, which leaves that session on its settings.
+ */
+function startsFrom(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    const out = {};
+    for (const [id, c] of Object.entries(raw)) {
+        if (!c || typeof c !== 'object')
+            continue;
+        const x = c;
+        const branch = typeof x.branch === 'string' ? x.branch : '';
+        const onBranch = x.onBranch === true ? { onBranch: true } : {};
+        if (x.from === 'previous-session')
+            out[id] = { from: 'previous-session' };
+        else if (x.from === 'local' && branch)
+            out[id] = { from: 'local', branch, ...onBranch };
+        else if (x.from === 'remote' && branch && typeof x.remote === 'string' && x.remote)
+            out[id] = { from: 'remote', remote: x.remote, branch, ...onBranch };
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
 function contentDisposition(fileName) {
     const ascii = fileName.replace(/[^\x20-\x7e]/g, '_').replace(/["\\]/g, '_');
     return `attachment; filename="${ascii}"; filename*=UTF-8''${encodeURIComponent(fileName)}`;
@@ -171,6 +194,16 @@ let OperatorController = class OperatorController {
         const { buildOnFinished, ...patch } = body ?? {};
         return this.ops.rerunTask(id, taskId, patch, { buildOnFinished: buildOnFinished === true }).catch(fail);
     }
+    /** How the task contradicts itself, with the ways out of each contradiction. Changes nothing. */
+    contractCheck(id, taskId) {
+        return this.ops.contractCheck(id, taskId).catch(fail);
+    }
+    /** Applies one chosen fix per contradiction (-1 = none) and queues the task; starts nothing. */
+    applyContractFix(id, taskId, body) {
+        if (body?.expect !== undefined && (!Array.isArray(body.expect) || body.expect.some((x) => typeof x !== 'string')))
+            throw new BadRequestException('expect must be a list of the contradictions shown');
+        return this.ops.applyContractFix(id, taskId, body?.choices ?? [], body?.expect).catch(fail);
+    }
     /** What going back to before this task would do. Changes nothing. */
     restorePreview(id, taskId) {
         return this.ops.restorePreview(id, taskId).catch(fail);
@@ -339,7 +372,47 @@ let OperatorController = class OperatorController {
     }
     // --- run control ------------------------------------------------------------------------
     start(id, body) {
-        return this.ops.start(id, body?.mode === 'unattended' ? 'unattended' : 'confirm', body?.name);
+        return this.ops.start(id, body?.mode === 'unattended' ? 'unattended' : 'confirm', body?.name, startsFrom(body?.starts));
+    }
+    /**
+     * The start window's question: where each of these sessions starts, and the branches of their
+     * repositories as they are here (nothing fetched). See `vcs/startChoice.ts`.
+     */
+    startOptions(sessions) {
+        return this.ops.startChoices((sessions ?? '').split(',').map((x) => x.trim()).filter(Boolean)).catch(fail);
+    }
+    /** Fetches branches of a remote for the start window — through Git's password window when it asks. */
+    startFetch(body) {
+        const branches = Array.isArray(body?.branches) ? body.branches.filter((b) => typeof b === 'string') : null;
+        return this.ops.startFetch(body?.dir ?? '', body?.remote ?? '', branches).catch(fail);
+    }
+    /** Starts that did not get as far as a first task, newest first; `unanswered=1` only those no press was answered with. */
+    startFailures(unanswered) {
+        return this.ops.recentStartFailures(unanswered === '1' || unanswered === 'true');
+    }
+    /** One of them as a text file: the error, where it stopped, the run's record, the events and the console. */
+    async startFailureReport(id, res) {
+        try {
+            const { fileName, content } = await this.ops.startFailureReport(id);
+            res.type('text/plain; charset=utf-8');
+            res.setHeader('content-disposition', contentDisposition(fileName));
+            res.send(content);
+        }
+        catch (e) {
+            failText(res, e);
+        }
+    }
+    /** What the bot's console showed, the latest lines, as a text file. See `log/terminal.ts`. */
+    async terminal(res) {
+        try {
+            const { fileName, content } = await this.ops.terminalReport();
+            res.type('text/plain; charset=utf-8');
+            res.setHeader('content-disposition', contentDisposition(fileName));
+            res.send(content);
+        }
+        catch (e) {
+            failText(res, e);
+        }
     }
     stop(id) {
         return this.ops.stop(id);
@@ -377,7 +450,7 @@ let OperatorController = class OperatorController {
         // same as "no model": an empty string on a session means "leave the chat alone".
         body?.model, 
         // The same for the review: absent means each session keeps whatever it is set to.
-        body?.reviewModel, body?.name, body?.taskIds)
+        body?.reviewModel, body?.name, body?.taskIds, startsFrom(body?.starts))
             .catch(fail);
     }
     stopBatch() {
@@ -738,6 +811,23 @@ __decorate([
     __metadata("design:paramtypes", [String, String, Object]),
     __metadata("design:returntype", Promise)
 ], OperatorController.prototype, "rerunTask", null);
+__decorate([
+    Get('sessions/:id/tasks/:taskId/contract'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "contractCheck", null);
+__decorate([
+    Post('sessions/:id/tasks/:taskId/contract-fix'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __param(2, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "applyContractFix", null);
 __decorate([
     Get('sessions/:id/tasks/:taskId/restore'),
     __param(0, Param('id')),
@@ -895,6 +985,42 @@ __decorate([
     __metadata("design:paramtypes", [String, Object]),
     __metadata("design:returntype", Promise)
 ], OperatorController.prototype, "start", null);
+__decorate([
+    Get('start/options'),
+    __param(0, Query('sessions')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "startOptions", null);
+__decorate([
+    Post('start/fetch'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "startFetch", null);
+__decorate([
+    Get('start/failures'),
+    __param(0, Query('unanswered')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Object)
+], OperatorController.prototype, "startFailures", null);
+__decorate([
+    Get('start/failures/:id/report'),
+    __param(0, Param('id')),
+    __param(1, Res()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "startFailureReport", null);
+__decorate([
+    Get('terminal'),
+    __param(0, Res()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "terminal", null);
 __decorate([
     Post('sessions/:id/stop'),
     __param(0, Param('id')),