copilot-operator 0.1.0

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

@@ -0,0 +1,975 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Body, Controller, Delete, Get, Param, Post, Put, Query, Res, Sse, NotFoundException, BadRequestException } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { OperatorService } from './operator.service.js';
+function fail(e) {
+    throw new BadRequestException(e.message);
+}
+/**
+ * A `content-disposition` header a session name cannot break.
+ *
+ * Header values are ASCII. A session called "тест4" produced a file name with Cyrillic in it,
+ * and Node refused to send the header at all, so the download failed with an error that said
+ * nothing about names. The fix is the standard pair: an ASCII fallback for anything old, and
+ * `filename*` with the real name percent-encoded for every current browser.
+ */
+/** The three kinds, checked here so a path cannot name a file of its own choosing. */
+function asContextKind(kind) {
+    if (kind !== 'organisation' && kind !== 'persona' && kind !== 'work') {
+        throw new BadRequestException('kind must be organisation, persona or work');
+    }
+    return kind;
+}
+function contentDisposition(fileName) {
+    const ascii = fileName.replace(/[^\x20-\x7e]/g, '_').replace(/["\\]/g, '_');
+    return `attachment; filename="${ascii}"; filename*=UTF-8''${encodeURIComponent(fileName)}`;
+}
+let OperatorController = class OperatorController {
+    ops;
+    constructor(ops) {
+        this.ops = ops;
+    }
+    health() {
+        return { ok: true, time: new Date().toISOString() };
+    }
+    doctor() {
+        return this.ops.doctor();
+    }
+    // --- settings ---------------------------------------------------------------------------
+    async settings() {
+        const [raw, defaults, resolved] = await Promise.all([this.ops.settings.raw(), this.ops.settings.defaults(), this.ops.settings.load()]);
+        return { raw, defaults, resolved: resolved.resolved };
+    }
+    async saveSettings(body) {
+        await this.ops.settings.save(body).catch(fail);
+        return { ok: true };
+    }
+    // --- level 1 ----------------------------------------------------------------------------
+    level1() {
+        return this.ops.getLevel1();
+    }
+    async setLevel1(body) {
+        if (typeof body?.content !== 'string' || body.content.trim().length < 100) {
+            throw new BadRequestException('Level 1 must be a real contract, not a few words.');
+        }
+        await this.ops.setLevel1(body.content);
+        return { ok: true };
+    }
+    resetLevel1() {
+        return this.ops.resetLevel1();
+    }
+    // --- level 2 presets --------------------------------------------------------------------
+    presets() {
+        return this.ops.listPresets();
+    }
+    savePreset(name, body) {
+        return this.ops.savePreset(name, body?.content ?? '').catch(fail);
+    }
+    async deletePreset(name) {
+        await this.ops.deletePreset(name);
+        return { ok: true };
+    }
+    // --- sessions ---------------------------------------------------------------------------
+    sessions() {
+        return this.ops.listSessions();
+    }
+    createSession(body) {
+        return this.ops.createSession(body?.name ?? '', body?.mirror).catch(fail);
+    }
+    async session(id) {
+        const s = await this.ops.getSession(id);
+        if (!s)
+            throw new NotFoundException();
+        return s;
+    }
+    /** Name, model, queue behaviour, files, version control and the independent review. */
+    updateSession(id, body) {
+        return this.ops.updateSession(id, body).catch(fail);
+    }
+    async deleteSession(id) {
+        await this.ops.deleteSession(id).catch(fail);
+        return { ok: true };
+    }
+    addTask(id, body) {
+        return this.ops.addTask(id, { title: body?.title ?? '', level2: body?.level2 ?? '', prompt: body?.prompt ?? '' }).catch(fail);
+    }
+    updateTask(id, taskId, body) {
+        return this.ops.updateTask(id, taskId, body).catch(fail);
+    }
+    async deleteTask(id, taskId) {
+        await this.ops.deleteTask(id, taskId).catch(fail);
+        return { ok: true };
+    }
+    /**
+     * Puts a finished task back in the queue, keeping the earlier attempt on the record.
+     *
+     * A body with `title`, `prompt` or `level2` edits the task on the way: the attempt that
+     * already ran keeps the text it ran with, and the next one uses the new text.
+     */
+    rerunTask(id, taskId, body) {
+        return this.ops.rerunTask(id, taskId, body ?? {}).catch(fail);
+    }
+    /** What going back to before this task would do. Changes nothing. */
+    restorePreview(id, taskId) {
+        return this.ops.restorePreview(id, taskId).catch(fail);
+    }
+    /** Does it: a new branch at the commit that task started from, checked out. */
+    restore(id, taskId) {
+        return this.ops.restore(id, taskId).catch(fail);
+    }
+    /** What starting the run again from this task would re-queue, and do to the code. */
+    restartPlan(id, taskId) {
+        return this.ops.restartPlan(id, taskId).catch(fail);
+    }
+    /** Restores the code, queues this task and everything after it, and starts the run again. */
+    restartFrom(id, taskId, body) {
+        return this.ops.restartFrom(id, taskId, body ?? {}).catch(fail);
+    }
+    async taskLog(id, taskId, res, run) {
+        const text = await this.ops.taskLog(id, taskId, run);
+        if (text === null) {
+            res.status(404).send('no log yet');
+            return;
+        }
+        res.type('text/plain; charset=utf-8').send(text);
+    }
+    /**
+     * The same log, saved to the Desktop and shown in Explorer, which is what the operator
+     * actually wants it for. The GET above stays as it is: it is where this falls back to when
+     * the machine refuses to write the file, or when there is no Desktop to write it to.
+     */
+    async saveTaskLog(id, taskId, run) {
+        const saved = await this.ops.saveTaskLog(id, taskId, run).catch(fail);
+        if (!saved)
+            throw new NotFoundException('This task has not produced a log yet.');
+        return saved;
+    }
+    /** The attempt as a story: what was sent, answered, run and how it ended. `run` picks an earlier attempt. */
+    async taskStory(id, taskId, run) {
+        const story = await this.ops.taskStory(id, taskId, run);
+        if (!story)
+            throw new NotFoundException('This task has not run yet, or that attempt is not its own.');
+        return story;
+    }
+    taskFiles(id, taskId, run) {
+        return this.ops.taskFiles(id, taskId, run);
+    }
+    async taskFile(id, taskId, kind, name, res, run) {
+        if (!['reports', 'artifacts', 'replies'].includes(kind)) {
+            res.status(400).send('bad kind');
+            return;
+        }
+        const text = await this.ops.taskFile(id, taskId, kind, name, run);
+        if (text === null) {
+            res.status(404).send('not found');
+            return;
+        }
+        res.type('text/plain; charset=utf-8').send(text);
+    }
+    /** A task's own file, saved to the Desktop and shown in Explorer, exactly as its log is. */
+    async saveTaskFile(id, taskId, kind, name, run) {
+        if (!['reports', 'artifacts', 'replies'].includes(kind))
+            throw new BadRequestException('kind must be reports, artifacts or replies');
+        const saved = await this.ops.saveTaskFile(id, taskId, kind, name, run).catch(fail);
+        if (!saved)
+            throw new NotFoundException('That file is not there.');
+        return saved;
+    }
+    /**
+     * Downloads the record of selected tasks.
+     *
+     * `tasks` is a comma-separated list of task ids, or absent for every task that has run.
+     * `variant` is `full` for the whole conversation, or `outcome` for the first and the last
+     * message only, which is the expected-and-actual pair.
+     */
+    async exportTasks(id, res, tasks, variant) {
+        const ids = (tasks ?? '').split(',').map((x) => x.trim()).filter(Boolean);
+        const kind = variant === 'full' ? 'full' : 'outcome';
+        try {
+            const { fileName, content } = await this.ops.exportTasks(id, ids, kind);
+            res.type('text/plain; charset=utf-8');
+            res.setHeader('content-disposition', contentDisposition(fileName));
+            res.send(content);
+        }
+        catch (e) {
+            res.status(400).send(e.message);
+        }
+    }
+    /**
+     * Everything that happened across several sessions, as one JSON file.
+     *
+     * `sessions` is a comma-separated list of ids; leaving it out means the sessions of the last
+     * batch. Meant for handing to somebody — or something — that has to work out why a run went
+     * the way it did.
+     */
+    async debugExport(res, sessions) {
+        const ids = (sessions ?? '').split(',').map((x) => x.trim()).filter(Boolean);
+        try {
+            const { fileName, content } = await this.ops.debugExport(ids);
+            res.type('application/json; charset=utf-8');
+            res.setHeader('content-disposition', contentDisposition(fileName));
+            res.send(content);
+        }
+        catch (e) {
+            res.status(400).send(e.message);
+        }
+    }
+    /**
+     * All three views of a set of tasks the operator ticked, as one file.
+     *
+     * A POST rather than a GET, which makes it the odd one out among the exports and is the right
+     * odd one out: the others name a run, a session or a task and fit in a query string, while this
+     * names every task that was chosen, and a register with sixty finished tasks in it would put a
+     * selection past what a URL can carry. The browser saves the body with a download link made
+     * from a blob, so nothing about the operator's side of it changes.
+     */
+    async exportBundle(res, body) {
+        const pairs = (body?.tasks ?? [])
+            .map((x) => ({ sessionId: (x?.sessionId ?? '').trim(), taskId: (x?.taskId ?? '').trim() }))
+            .filter((x) => x.sessionId && x.taskId);
+        try {
+            const { fileName, content } = await this.ops.exportBundle(pairs);
+            res.type('application/json; charset=utf-8');
+            res.setHeader('content-disposition', contentDisposition(fileName));
+            res.send(content);
+        }
+        catch (e) {
+            res.status(400).send(e.message);
+        }
+    }
+    /**
+     * One of the three JSON views of a task, a session or a run: `plan` (what was asked, in the
+     * format that imports again), `domain` (what happened to the work) or `bot` (what the runner
+     * did). Exactly one of `run`, `session` or `session`+`task` names the scope.
+     */
+    async exportView(kind, res, run, session, task) {
+        if (kind !== 'plan' && kind !== 'domain' && kind !== 'bot') {
+            res.status(400).send('kind must be plan, domain or bot');
+            return;
+        }
+        try {
+            const { fileName, content } = await this.ops.exportView(kind, { runId: run?.trim() || undefined, sessionId: session?.trim() || undefined, taskId: task?.trim() || undefined });
+            res.type('application/json; charset=utf-8');
+            res.setHeader('content-disposition', contentDisposition(fileName));
+            res.send(content);
+        }
+        catch (e) {
+            res.status(400).send(e.message);
+        }
+    }
+    // --- run control ------------------------------------------------------------------------
+    start(id, body) {
+        return this.ops.start(id, body?.mode === 'unattended' ? 'unattended' : 'confirm', body?.name);
+    }
+    stop(id) {
+        return this.ops.stop(id);
+    }
+    // --- running several sessions in turn ------------------------------------------------------
+    /** The batch in progress, or the last one that ran. Null when none ever has. */
+    batch() {
+        return this.ops.batchState();
+    }
+    /**
+     * Runs the queued tasks of several sessions, one after another, in the order given.
+     *
+     * `onFailure` is about the sessions, not the tasks inside them: `stop` gives up on the rest
+     * once a session fails, `continue` works through all of them.
+     */
+    /**
+     * What this run would be called if nobody typed anything, so the page can show it first.
+     *
+     * The same answer `startBatch` would reach on its own, asked before the fact rather than after,
+     * because a name the operator can see and correct is worth more than a name that appears in the
+     * register once it is too late to argue with.
+     */
+    suggestRunName(sessions) {
+        const ids = (sessions ?? '').split(',').map((x) => x.trim()).filter(Boolean);
+        return this.ops.suggestRunName(ids).then((name) => ({ name }));
+    }
+    startBatch(body) {
+        if (!Array.isArray(body?.sessionIds))
+            throw new BadRequestException('sessionIds must be a list of session ids');
+        return this.ops
+            .startBatch(body.sessionIds, body?.mode === 'unattended' ? 'unattended' : 'confirm', body?.onFailure === 'continue' ? 'continue' : 'stop', 
+        // Absent or empty means every session keeps the model it already has, which is not the
+        // 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)
+            .catch(fail);
+    }
+    stopBatch() {
+        return this.ops.stopBatch();
+    }
+    /**
+     * Holds the run after the task that is running finishes, rather than after its current step.
+     *
+     * The pair of them are one switch from the page's point of view, so they are one route each
+     * rather than one route with a flag: a request that says what it wants cannot be misread.
+     */
+    pauseBatch() {
+        return this.ops.pauseBatch();
+    }
+    resumeBatch() {
+        return this.ops.resumeBatch();
+    }
+    // --- plans ---------------------------------------------------------------------------------
+    /**
+     * The text the operator pastes into a chat model to have a plan written.
+     *
+     * One text per language and nothing else to choose. It used to be assembled from answers
+     * given on the import page — version control on or off, which folder — and those are now
+     * questions the brief tells the model to ask, because the model is the one in the
+     * conversation and the answers belong to a session rather than to the whole document.
+     */
+    async planBrief(lang) {
+        return await this.ops.planBrief({ lang: lang ?? 'en' });
+    }
+    // --- the operator's own two texts for the plan persona -------------------------------
+    /**
+     * `organisation` is how the company works and where the projects are, which changes rarely;
+     * `work` is what this group of tasks is about, which changes whenever the work does.
+     */
+    context(kind, lang) {
+        return this.ops.getContext(asContextKind(kind), lang ?? 'en');
+    }
+    async setContext(kind, body) {
+        if (typeof body?.content !== 'string')
+            throw new BadRequestException('content must be text');
+        await this.ops.setContext(asContextKind(kind), body.content);
+        return { ok: true };
+    }
+    resetContext(kind, lang) {
+        return this.ops.resetContext(asContextKind(kind), lang ?? 'en');
+    }
+    /** Checks a pasted plan without importing anything, and says what it would duplicate. */
+    checkPlan(body) {
+        return this.ops.checkPlan(body?.text ?? '').catch(fail);
+    }
+    /**
+     * Creates the sessions and tasks a plan describes, and starts nothing.
+     *
+     * A plan that does not validate comes back as 200 with `ok: false` rather than as an error,
+     * because the list of what is wrong is the useful part of that answer and the UI shows it
+     * to the operator to hand back to the chat.
+     */
+    importPlan(body) {
+        return this.ops.importPlan(body?.text ?? '').catch(fail);
+    }
+    events(id) {
+        return this.ops.recentEvents(id);
+    }
+    /** Live events as server-sent events. The browser's EventSource reconnects on its own. */
+    stream(id) {
+        return new Observable((subscriber) => {
+            for (const e of this.ops.recentEvents(id))
+                subscriber.next({ data: JSON.stringify(e) });
+            const off = this.ops.subscribe(id, (e) => subscriber.next({ data: JSON.stringify(e) }));
+            const keepAlive = setInterval(() => subscriber.next({ data: JSON.stringify({ type: 'ping', at: new Date().toISOString() }) }), 25_000);
+            return () => {
+                off();
+                clearInterval(keepAlive);
+            };
+        });
+    }
+    // --- approvals --------------------------------------------------------------------------
+    approvals(session) {
+        return this.ops.pendingApprovals(session);
+    }
+    decide(id, body) {
+        if (!['run', 'skip', 'abort', 'run-all'].includes(body?.action)) {
+            throw new BadRequestException('action must be run, run-all, skip or abort');
+        }
+        return this.ops.decide(id, body.action);
+    }
+    /** Turns asking on or off in the middle of a run. */
+    setMode(id, body) {
+        if (body?.mode !== 'confirm' && body?.mode !== 'unattended') {
+            throw new BadRequestException('mode must be confirm or unattended');
+        }
+        return this.ops.setRunMode(id, body.mode);
+    }
+    /**
+     * Is anything running? Answered from memory, so it is safe to ask from every page.
+     */
+    activity() {
+        return this.ops.activity();
+    }
+    // --- the project being worked on -----------------------------------------------------------
+    /** The folder new sessions start pointed at, and whether it can carry version control. */
+    project() {
+        return this.ops.project();
+    }
+    /** Stores it. A field left out is kept; an empty `rootDir` clears the default. */
+    setProject(body) {
+        return this.ops
+            .setProject({ rootDir: body?.rootDir, name: body?.name, others: body?.others, mirrorToDesktop: body?.mirrorToDesktop, mirror: body?.mirror })
+            .catch(fail);
+    }
+    /**
+     * Whether a folder can be used for version control at all, asked before the choice is made.
+     *
+     * Separate from the session's own preflight because that one only speaks when version
+     * control is already on, and the question here is whether it may be turned on.
+     */
+    repo(dir) {
+        const problem = this.ops.repoProblem(dir ?? '');
+        return problem ? { ok: false, problem } : { ok: true };
+    }
+    /** Can version control do its job in this session right now? */
+    vcsStatus(id) {
+        return this.ops.vcsStatus(id).catch(fail);
+    }
+    // --- the model picker ---------------------------------------------------------------------
+    /** The cached list. Returns null when the picker has never been read on this machine. */
+    models() {
+        return this.ops.models();
+    }
+    /**
+     * Re-reads the picker from the live chat. Slow on purpose: it opens the browser with the
+     * bot profile, so it cannot run while a session is running.
+     */
+    refreshModels() {
+        return this.ops.refreshModels().catch(fail);
+    }
+    /** The model new sessions start on. An empty name means "leave the chat alone". */
+    setDefaultModel(body) {
+        return this.ops.setDefaultModel(body?.model ?? '').catch(fail);
+    }
+    /** The model a new session's independent review runs on. An empty name means "the session's own". */
+    setDefaultReviewModel(body) {
+        return this.ops.setDefaultReviewModel(body?.model ?? '').catch(fail);
+    }
+    // --- the registry of every task -----------------------------------------------------------
+    tasks() {
+        return this.ops.taskRegistry();
+    }
+    // --- helpers for the UI -----------------------------------------------------------------
+    dirs(root, gitignore) {
+        if (!root)
+            throw new BadRequestException('root is required');
+        return this.ops.dirs(root, gitignore !== '0' && gitignore !== 'false');
+    }
+    /**
+     * Opens the machine's own folder dialog. A POST because it has a visible effect: a window
+     * appears on the operator's desktop and waits for them.
+     */
+    browseFolder(body) {
+        return this.ops.browseFolder(body?.start);
+    }
+    preview(body) {
+        if (!body?.rootDir?.trim())
+            throw new BadRequestException('rootDir is required');
+        return this.ops
+            .previewMirror({
+            rootDir: body.rootDir.trim(),
+            includeDirs: body.includeDirs ?? [],
+            excludeDirs: body.excludeDirs ?? [],
+            respectGitignore: body.respectGitignore ?? true,
+            includeEnvFiles: body.includeEnvFiles ?? false,
+        })
+            .catch(fail);
+    }
+};
+__decorate([
+    Get('health'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], OperatorController.prototype, "health", null);
+__decorate([
+    Get('doctor'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "doctor", null);
+__decorate([
+    Get('settings'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "settings", null);
+__decorate([
+    Put('settings'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "saveSettings", null);
+__decorate([
+    Get('level1'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "level1", null);
+__decorate([
+    Put('level1'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "setLevel1", null);
+__decorate([
+    Delete('level1'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "resetLevel1", null);
+__decorate([
+    Get('presets'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "presets", null);
+__decorate([
+    Put('presets/:name'),
+    __param(0, Param('name')),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "savePreset", null);
+__decorate([
+    Delete('presets/:name'),
+    __param(0, Param('name')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "deletePreset", null);
+__decorate([
+    Get('sessions'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "sessions", null);
+__decorate([
+    Post('sessions'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "createSession", null);
+__decorate([
+    Get('sessions/:id'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "session", null);
+__decorate([
+    Put('sessions/:id'),
+    __param(0, Param('id')),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "updateSession", null);
+__decorate([
+    Delete('sessions/:id'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "deleteSession", null);
+__decorate([
+    Post('sessions/:id/tasks'),
+    __param(0, Param('id')),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "addTask", null);
+__decorate([
+    Put('sessions/:id/tasks/:taskId'),
+    __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, "updateTask", null);
+__decorate([
+    Delete('sessions/:id/tasks/:taskId'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "deleteTask", null);
+__decorate([
+    Post('sessions/:id/tasks/:taskId/rerun'),
+    __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, "rerunTask", null);
+__decorate([
+    Get('sessions/:id/tasks/:taskId/restore'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "restorePreview", null);
+__decorate([
+    Post('sessions/:id/tasks/:taskId/restore'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "restore", null);
+__decorate([
+    Get('sessions/:id/tasks/:taskId/restart'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "restartPlan", null);
+__decorate([
+    Post('sessions/:id/tasks/:taskId/restart'),
+    __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, "restartFrom", null);
+__decorate([
+    Get('sessions/:id/tasks/:taskId/log'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __param(2, Res()),
+    __param(3, Query('run')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "taskLog", null);
+__decorate([
+    Post('sessions/:id/tasks/:taskId/log'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __param(2, Query('run')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "saveTaskLog", null);
+__decorate([
+    Get('sessions/:id/tasks/:taskId/story'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __param(2, Query('run')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "taskStory", null);
+__decorate([
+    Get('sessions/:id/tasks/:taskId/files'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __param(2, Query('run')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "taskFiles", null);
+__decorate([
+    Get('sessions/:id/tasks/:taskId/files/:kind/:name'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __param(2, Param('kind')),
+    __param(3, Param('name')),
+    __param(4, Res()),
+    __param(5, Query('run')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, String, Object, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "taskFile", null);
+__decorate([
+    Post('sessions/:id/tasks/:taskId/files/:kind/:name'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __param(2, Param('kind')),
+    __param(3, Param('name')),
+    __param(4, Query('run')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "saveTaskFile", null);
+__decorate([
+    Get('sessions/:id/export'),
+    __param(0, Param('id')),
+    __param(1, Res()),
+    __param(2, Query('tasks')),
+    __param(3, Query('variant')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "exportTasks", null);
+__decorate([
+    Get('debug/export'),
+    __param(0, Res()),
+    __param(1, Query('sessions')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "debugExport", null);
+__decorate([
+    Post('export/bundle'),
+    __param(0, Res()),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "exportBundle", null);
+__decorate([
+    Get('export/:kind'),
+    __param(0, Param('kind')),
+    __param(1, Res()),
+    __param(2, Query('run')),
+    __param(3, Query('session')),
+    __param(4, Query('task')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, String, String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "exportView", null);
+__decorate([
+    Post('sessions/:id/start'),
+    __param(0, Param('id')),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "start", null);
+__decorate([
+    Post('sessions/:id/stop'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "stop", null);
+__decorate([
+    Get('batch'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], OperatorController.prototype, "batch", null);
+__decorate([
+    Get('batch/name'),
+    __param(0, Query('sessions')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "suggestRunName", null);
+__decorate([
+    Post('batch/start'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "startBatch", null);
+__decorate([
+    Post('batch/stop'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "stopBatch", null);
+__decorate([
+    Post('batch/pause'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "pauseBatch", null);
+__decorate([
+    Post('batch/resume'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "resumeBatch", null);
+__decorate([
+    Get('plan/brief'),
+    __param(0, Query('lang')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "planBrief", null);
+__decorate([
+    Get('context/:kind'),
+    __param(0, Param('kind')),
+    __param(1, Query('lang')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "context", null);
+__decorate([
+    Put('context/:kind'),
+    __param(0, Param('kind')),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "setContext", null);
+__decorate([
+    Delete('context/:kind'),
+    __param(0, Param('kind')),
+    __param(1, Query('lang')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "resetContext", null);
+__decorate([
+    Post('plan/check'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "checkPlan", null);
+__decorate([
+    Post('plan/import'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "importPlan", null);
+__decorate([
+    Get('sessions/:id/events'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Object)
+], OperatorController.prototype, "events", null);
+__decorate([
+    Sse('sessions/:id/stream'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Observable)
+], OperatorController.prototype, "stream", null);
+__decorate([
+    Get('approvals'),
+    __param(0, Query('session')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Object)
+], OperatorController.prototype, "approvals", null);
+__decorate([
+    Post('approvals/:id'),
+    __param(0, Param('id')),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Object)
+], OperatorController.prototype, "decide", null);
+__decorate([
+    Post('sessions/:id/mode'),
+    __param(0, Param('id')),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Object)
+], OperatorController.prototype, "setMode", null);
+__decorate([
+    Get('activity'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], OperatorController.prototype, "activity", null);
+__decorate([
+    Get('project'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "project", null);
+__decorate([
+    Put('project'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "setProject", null);
+__decorate([
+    Get('repo'),
+    __param(0, Query('dir')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Object)
+], OperatorController.prototype, "repo", null);
+__decorate([
+    Get('sessions/:id/vcs'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "vcsStatus", null);
+__decorate([
+    Get('models'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "models", null);
+__decorate([
+    Post('models/refresh'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "refreshModels", null);
+__decorate([
+    Put('models/default'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "setDefaultModel", null);
+__decorate([
+    Put('models/review-default'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "setDefaultReviewModel", null);
+__decorate([
+    Get('tasks'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "tasks", null);
+__decorate([
+    Get('dirs'),
+    __param(0, Query('root')),
+    __param(1, Query('gitignore')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "dirs", null);
+__decorate([
+    Post('browse-folder'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "browseFolder", null);
+__decorate([
+    Post('mirror/preview'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "preview", null);
+OperatorController = __decorate([
+    Controller(),
+    __metadata("design:paramtypes", [OperatorService])
+], OperatorController);
+export { OperatorController };