docs-combiner 0.4.0 → 1.0.0

package/dist/main.js

@@ -51,6 +51,8 @@ const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const http = __importStar(require("http"));
 const url = __importStar(require("url"));
+const routes_1 = require("./agentApi/routes");
+const agentControlClaim_1 = require("./agentApi/agentControlClaim");
 let pendingGoogleAuth = null;
 let mainWindow = null;
 let agentApiServer = null;
@@ -61,6 +63,8 @@ const windowFolderPaths = new Map();
 const windowWorkspaces = new Map();
 const windowTitles = new Map();
 const closingWindowIds = new Set();
+const closedWorkspaceIds = new Set();
+const agentControlledSessions = new Set();
 const AGENT_API_HOST = '127.0.0.1';
 const DEFAULT_AGENT_API_PORT = 17321;
 const APP_WINDOW_TITLE = 'Комбайнер';
@@ -106,41 +110,87 @@ function getWorkspaceWindows() {
         };
     });
 }
-function getAgentWorkSessions() {
-    const baseUrl = getAgentApiBaseUrl();
-    return getWorkspaceWindows().map(win => {
-        const sessionUrl = `${baseUrl}/api/windows/${encodeURIComponent(win.workspaceId)}`;
-        const details = [
-            win.title,
-            win.folderPath ? `Drive folder: ${win.folderPath}` : 'No Drive folder selected',
-            win.active ? 'active session' : 'background session',
-        ];
-        return {
-            id: win.workspaceId,
-            title: win.title,
-            description: details.join('; '),
-            folderId: win.folderId,
-            folderPath: win.folderPath,
-            active: win.active,
-            url: sessionUrl,
-            endpoints: {
-                info: sessionUrl,
-                update: sessionUrl,
-                setupCampaign: `${sessionUrl}/setup-campaign`,
-                geoBlock: `${sessionUrl}/geo-block`,
-                creativeSelections: `${sessionUrl}/creative-selections`,
-                capabilities: `${sessionUrl}/capabilities`,
-                validation: `${sessionUrl}/validation`,
-                generated: `${sessionUrl}/generated`,
-                logs: `${sessionUrl}/logs`,
-                jobs: `${sessionUrl}/jobs`,
-                createCampaignGroup: `${sessionUrl}/catalog/groups`,
-                createWorkspaceFolder: `${sessionUrl}/catalog/workspaces`,
-                generate: `${sessionUrl}/generate`,
-            },
-        };
+function isSessionAgentControlled(sessionId) {
+    return agentControlledSessions.has(sessionId.trim());
+}
+function setSessionAgentControlMode(sessionId, mode) {
+    const id = sessionId.trim();
+    if (!id)
+        return;
+    if (mode === 'agent') {
+        agentControlledSessions.add(id);
+    }
+    else {
+        agentControlledSessions.delete(id);
+    }
+    const win = getWindowByWorkspaceId(id);
+    if (win && !win.isDestroyed() && !win.webContents.isDestroyed()) {
+        win.webContents.send('agent-control-mode-changed', { mode });
+        syncWindowTitleForAgentControl(win, id);
+    }
+}
+function isAgentApiReadyInSession(sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const win = getWindowByWorkspaceId(sessionId);
+        if (!win || win.isDestroyed() || win.webContents.isDestroyed())
+            return false;
+        try {
+            return (yield win.webContents.executeJavaScript('Boolean(window.__docsCombinerAgentApi)', true)) === true;
+        }
+        catch (_a) {
+            return false;
+        }
     });
 }
+function syncWindowTitleForAgentControl(win, workspaceId) {
+    const webContentsId = win.webContents.id;
+    const folderLabel = windowTitles.get(webContentsId) || 'Новый оффер';
+    const agentPrefix = isSessionAgentControlled(workspaceId) ? '🤖 ' : '';
+    win.setTitle(`${agentPrefix}${APP_WINDOW_TITLE} — ${folderLabel}`);
+}
+function buildAgentWorkSessionInfo(win) {
+    const baseUrl = getAgentApiBaseUrl();
+    const sessionUrl = `${baseUrl}/api/windows/${encodeURIComponent(win.workspaceId)}`;
+    const details = [
+        win.title,
+        win.folderPath ? `Drive folder: ${win.folderPath}` : 'No Drive folder selected',
+        win.active ? 'active session' : 'background session',
+        isSessionAgentControlled(win.workspaceId) ? 'agent-controlled' : 'manual control',
+    ];
+    return {
+        id: win.workspaceId,
+        title: win.title,
+        description: details.join('; '),
+        folderId: win.folderId,
+        folderPath: win.folderPath,
+        active: win.active,
+        agentControlled: isSessionAgentControlled(win.workspaceId),
+        url: sessionUrl,
+        endpoints: {
+            info: sessionUrl,
+            update: sessionUrl,
+            setupCampaign: `${sessionUrl}/setup-campaign`,
+            geoBlock: `${sessionUrl}/geo-block`,
+            creativeSelections: `${sessionUrl}/creative-selections`,
+            approachMatrix: `${sessionUrl}/approach-matrix`,
+            capabilities: `${sessionUrl}/capabilities`,
+            validation: `${sessionUrl}/validation`,
+            generated: `${sessionUrl}/generated`,
+            logs: `${sessionUrl}/logs`,
+            jobs: `${sessionUrl}/jobs`,
+            createCampaignGroup: `${sessionUrl}/catalog/groups`,
+            createWorkspaceFolder: `${sessionUrl}/catalog/workspaces`,
+            generate: `${sessionUrl}/generate`,
+            agentControl: `${sessionUrl}/agent-control`,
+            actions: `${sessionUrl}/actions`,
+            regeneratePair: `${sessionUrl}/actions/regenerate-pair`,
+            regenerateImages: `${sessionUrl}/actions/regenerate-images`,
+        },
+    };
+}
+function getAgentWorkSessions() {
+    return getWorkspaceWindows().map(buildAgentWorkSessionInfo);
+}
 function getWindowByWorkspaceId(workspaceId) {
     var _a;
     const id = workspaceId.trim();
@@ -148,12 +198,139 @@ function getWindowByWorkspaceId(workspaceId) {
         !win.webContents.isDestroyed() &&
         windowWorkspaces.get(win.webContents.id) === id)) !== null && _a !== void 0 ? _a : null;
 }
-function callAgentRendererApi(workspaceId, method, payload) {
+function removeWorkspaceSnapshot(workspaceId) {
+    try {
+        const configPath = path.join(electron_1.app.getPath('userData'), 'config.json');
+        if (!fs.existsSync(configPath))
+            return;
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        const current = Array.isArray(config.workspaceSnapshots) ? config.workspaceSnapshots : [];
+        const next = current.filter((item) => (item === null || item === void 0 ? void 0 : item.id) !== workspaceId);
+        if (next.length !== current.length) {
+            fs.writeFileSync(configPath, JSON.stringify(Object.assign(Object.assign({}, config), { workspaceSnapshots: next })));
+        }
+    }
+    catch (_a) {
+        // ignore snapshot cleanup errors
+    }
+}
+function clearAllWorkspaceSnapshots() {
+    try {
+        const configPath = path.join(electron_1.app.getPath('userData'), 'config.json');
+        if (!fs.existsSync(configPath))
+            return;
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        const nextConfig = Object.assign(Object.assign({}, config), { workspaceSnapshots: [] });
+        fs.writeFileSync(configPath, JSON.stringify(nextConfig));
+        broadcastConfigUpdated(nextConfig);
+    }
+    catch (_a) {
+        // ignore snapshot cleanup errors
+    }
+}
+function pickWindowToKeep(allWindows) {
+    var _a, _b;
+    if (allWindows.length === 0)
+        return null;
+    return ((_b = (_a = electron_1.BrowserWindow.getFocusedWindow()) !== null && _a !== void 0 ? _a : (mainWindow && !mainWindow.isDestroyed() ? mainWindow : null)) !== null && _b !== void 0 ? _b : allWindows[0]);
+}
+function resetWindowToEmptySession(win) {
+    const webContentsId = win.webContents.id;
+    const oldWorkspaceId = windowWorkspaces.get(webContentsId);
+    if (oldWorkspaceId) {
+        agentControlledSessions.delete(oldWorkspaceId);
+        closedWorkspaceIds.add(oldWorkspaceId);
+        removeWorkspaceSnapshot(oldWorkspaceId);
+    }
+    cleanupWindowFolder(webContentsId);
+    const newWorkspaceId = createWorkspaceId();
+    closedWorkspaceIds.delete(newWorkspaceId);
+    windowWorkspaces.set(webContentsId, newWorkspaceId);
+    windowTitles.set(webContentsId, 'Новый оффер');
+    syncWindowTitleForAgentControl(win, newWorkspaceId);
+    mainWindow = win;
+    win.loadFile(path.join(__dirname, 'index.html'), {
+        query: {
+            workspaceId: newWorkspaceId,
+            agentControlled: '0',
+        },
+    });
+}
+function closeAllWorkspaceSessions() {
+    const allWindows = electron_1.BrowserWindow.getAllWindows().filter(win => !win.isDestroyed());
+    const keepWin = pickWindowToKeep(allWindows);
+    if (!keepWin) {
+        createWindow();
+        return { ok: true };
+    }
+    const keepId = keepWin.webContents.id;
+    clearAllWorkspaceSnapshots();
+    for (const win of allWindows) {
+        if (win.webContents.id === keepId)
+            continue;
+        const workspaceId = windowWorkspaces.get(win.webContents.id);
+        if (workspaceId) {
+            closeSessionByWorkspaceId(workspaceId);
+            continue;
+        }
+        const webContentsId = win.webContents.id;
+        closingWindowIds.add(webContentsId);
+        broadcastWorkspaceWindowsUpdated();
+        win.destroy();
+        setImmediate(() => broadcastWorkspaceWindowsUpdated());
+    }
+    resetWindowToEmptySession(keepWin);
+    broadcastWorkspaceWindowsUpdated();
+    return { ok: true };
+}
+function closeOtherWorkspaceSessions(exceptWebContentsId) {
+    const keepId = Number(exceptWebContentsId);
+    const allWindows = electron_1.BrowserWindow.getAllWindows().filter(win => !win.isDestroyed());
+    for (const win of allWindows) {
+        const webContentsId = win.webContents.id;
+        if (webContentsId === keepId)
+            continue;
+        const workspaceId = windowWorkspaces.get(webContentsId);
+        if (workspaceId) {
+            closeSessionByWorkspaceId(workspaceId);
+        }
+        else {
+            closingWindowIds.add(webContentsId);
+            broadcastWorkspaceWindowsUpdated();
+            win.destroy();
+            setImmediate(() => broadcastWorkspaceWindowsUpdated());
+        }
+    }
+    return { ok: true };
+}
+function closeSessionByWorkspaceId(workspaceId) {
+    const id = workspaceId.trim();
+    if (!id) {
+        return { ok: false, error: 'Session id is required.' };
+    }
+    const win = getWindowByWorkspaceId(id);
+    if (!win || win.isDestroyed()) {
+        return { ok: false, error: 'Session not found.' };
+    }
+    const webContentsId = win.webContents.id;
+    agentControlledSessions.delete(id);
+    closedWorkspaceIds.add(id);
+    removeWorkspaceSnapshot(id);
+    closingWindowIds.add(webContentsId);
+    broadcastWorkspaceWindowsUpdated();
+    win.destroy();
+    setImmediate(() => broadcastWorkspaceWindowsUpdated());
+    return { ok: true };
+}
+function callAgentRendererApi(workspaceId, method, payload, options) {
     return __awaiter(this, void 0, void 0, function* () {
         const win = getWindowByWorkspaceId(workspaceId);
         if (!win) {
             return { ok: false, status: 404, error: 'Session not found.' };
         }
+        if ((0, agentControlClaim_1.shouldClaimAgentControl)(method, options)) {
+            setSessionAgentControlMode(workspaceId, 'agent');
+        }
         try {
             const script = `
       (async () => {
@@ -190,9 +367,10 @@ function callAgentRendererApi(workspaceId, method, payload) {
 }
 function callFirstReadyAgentRendererApi(method, payload, preferredSessionId) {
     return __awaiter(this, void 0, void 0, function* () {
+        const readOnlyOptions = { claimAgentControl: false };
         const preferredId = String(preferredSessionId !== null && preferredSessionId !== void 0 ? preferredSessionId : '').trim();
         if (preferredId) {
-            const preferred = yield callAgentRendererApi(preferredId, method, payload);
+            const preferred = yield callAgentRendererApi(preferredId, method, payload, readOnlyOptions);
             if (preferred.ok)
                 return preferred;
         }
@@ -200,7 +378,7 @@ function callFirstReadyAgentRendererApi(method, payload, preferredSessionId) {
         if (focused && !focused.isDestroyed() && !focused.webContents.isDestroyed()) {
             const focusedId = windowWorkspaces.get(focused.webContents.id);
             if (focusedId) {
-                const focusedResponse = yield callAgentRendererApi(focusedId, method, payload);
+                const focusedResponse = yield callAgentRendererApi(focusedId, method, payload, readOnlyOptions);
                 if (focusedResponse.ok)
                     return focusedResponse;
             }
@@ -213,7 +391,7 @@ function callFirstReadyAgentRendererApi(method, payload, preferredSessionId) {
             const sessionId = windowWorkspaces.get(win.webContents.id);
             if (!sessionId)
                 continue;
-            const response = yield callAgentRendererApi(sessionId, method, payload);
+            const response = yield callAgentRendererApi(sessionId, method, payload, readOnlyOptions);
             if (response.ok)
                 return response;
         }
@@ -236,1158 +414,29 @@ function waitForAgentSessionReady(sessionId_1) {
         return null;
     });
 }
-function getAgentApiSpec(port) {
-    return {
-        openapi: '3.1.0',
-        info: {
-            title: 'Docs Combiner Agent API',
-            version: electron_1.app.getVersion(),
-            description: 'Local-only API for automation agents controlling Docs Combiner.',
-        },
-        servers: [
-            {
-                url: `http://${AGENT_API_HOST}:${port}`,
-                description: 'Loopback-only Electron main process API',
-            },
-        ],
-        paths: {
-            '/api/windows': {
-                get: {
-                    operationId: 'listWindows',
-                    summary: 'List open Docs Combiner work sessions',
-                    responses: {
-                        '200': {
-                            description: 'Current work sessions available to an automation agent',
-                            content: {
-                                'application/json': {
-                                    schema: {
-                                        type: 'object',
-                                        required: ['ok', 'windows'],
-                                        properties: {
-                                            ok: { type: 'boolean', const: true },
-                                            windows: {
-                                                type: 'array',
-                                                items: { $ref: '#/components/schemas/AgentWorkSessionInfo' },
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-                post: {
-                    operationId: 'createWindow',
-                    summary: 'Open a new Docs Combiner work session (Electron window)',
-                    requestBody: {
-                        required: false,
-                        content: {
-                            'application/json': {
-                                schema: {
-                                    type: 'object',
-                                    properties: {
-                                        workspaceId: {
-                                            type: 'string',
-                                            description: 'Optional stable session id. Generated if omitted.',
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                    responses: {
-                        '201': {
-                            description: 'New session created and Agent API is ready in the renderer',
-                        },
-                        '202': {
-                            description: 'New window opened, but renderer Agent API is not ready yet',
-                        },
-                    },
-                },
-            },
-            '/api/catalog': {
-                get: {
-                    operationId: 'getDriveCatalog',
-                    summary: 'List offers, campaign groups and workspace folders from Google Drive',
-                    parameters: [
-                        {
-                            name: 'sessionId',
-                            in: 'query',
-                            required: false,
-                            schema: { type: 'string' },
-                            description: 'Prefer data from this session if available.',
-                        },
-                    ],
-                    responses: {
-                        '200': { description: 'Drive catalog snapshot' },
-                        '503': { description: 'No session with Agent API ready' },
-                    },
-                },
-            },
-            '/api/windows/{sessionId}': {
-                get: {
-                    operationId: 'getSessionInfo',
-                    summary: 'Return all agent-visible information from one work session',
-                    parameters: [
-                        {
-                            name: 'sessionId',
-                            in: 'path',
-                            required: true,
-                            schema: { type: 'string' },
-                        },
-                    ],
-                    responses: {
-                        '200': {
-                            description: 'Current live session state',
-                            content: {
-                                'application/json': {
-                                    schema: {
-                                        type: 'object',
-                                        required: ['ok', 'session'],
-                                        properties: {
-                                            ok: { type: 'boolean', const: true },
-                                            session: { $ref: '#/components/schemas/AgentSessionInfo' },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                        '404': { description: 'Session not found' },
-                        '409': { description: 'Session renderer is not ready for agent calls' },
-                    },
-                },
-                patch: {
-                    operationId: 'patchSessionInfo',
-                    summary: 'Partially update one work session without touching omitted fields',
-                    parameters: [
-                        {
-                            name: 'sessionId',
-                            in: 'path',
-                            required: true,
-                            schema: { type: 'string' },
-                        },
-                    ],
-                    requestBody: {
-                        required: true,
-                        content: {
-                            'application/json': {
-                                schema: { $ref: '#/components/schemas/PatchSessionInfoRequest' },
-                                examples: {
-                                    productOnly: {
-                                        value: { generation: { product: 'Detoxil Water' } },
-                                    },
-                                    firstGeoOnly: {
-                                        value: { generation: { firstGeo: 'Romania' } },
-                                    },
-                                    geoPriceLinkPartial: {
-                                        value: {
-                                            generation: {
-                                                geoBlock: [
-                                                    { id: 'market-1', link: 'https://example.com/ro/' },
-                                                ],
-                                            },
-                                        },
-                                    },
-                                    creativeSelectionsOnly: {
-                                        value: {
-                                            creativeSelections: {
-                                                selectedTextApproachNumbers: [1, 2, 3],
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                    responses: {
-                        '200': {
-                            description: 'Session was partially updated',
-                            content: {
-                                'application/json': {
-                                    schema: {
-                                        type: 'object',
-                                        required: ['ok', 'session'],
-                                        properties: {
-                                            ok: { type: 'boolean', const: true },
-                                            session: { $ref: '#/components/schemas/AgentSessionInfo' },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                        '400': { description: 'Invalid partial update payload' },
-                        '404': { description: 'Session not found' },
-                        '409': { description: 'Session renderer is not ready for agent calls' },
-                    },
-                },
-            },
-            '/api/windows/{sessionId}/catalog/groups': {
-                post: {
-                    operationId: 'createCampaignGroup',
-                    summary: 'Create a campaign group folder on Google Drive (same as UI «Создать» for group)',
-                    parameters: [
-                        { name: 'sessionId', in: 'path', required: true, schema: { type: 'string' } },
-                    ],
-                    requestBody: {
-                        required: true,
-                        content: {
-                            'application/json': {
-                                schema: {
-                                    type: 'object',
-                                    required: ['name'],
-                                    properties: {
-                                        name: { type: 'string', description: 'Group folder name under campaigns root' },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                    responses: {
-                        '200': { description: 'Group folder created' },
-                        '400': { description: 'Invalid payload or group already exists' },
-                        '404': { description: 'Session not found' },
-                        '409': { description: 'Session renderer is not ready for agent calls' },
-                    },
-                },
-            },
-            '/api/windows/{sessionId}/catalog/workspaces': {
-                post: {
-                    operationId: 'createWorkspaceFolder',
-                    summary: 'Create a workspace folder inside a campaign group on Google Drive',
-                    parameters: [
-                        { name: 'sessionId', in: 'path', required: true, schema: { type: 'string' } },
-                    ],
-                    requestBody: {
-                        required: true,
-                        content: {
-                            'application/json': {
-                                schema: {
-                                    type: 'object',
-                                    required: ['groupName', 'name'],
-                                    properties: {
-                                        groupName: { type: 'string' },
-                                        name: { type: 'string', description: 'Workspace folder name' },
-                                        select: {
-                                            type: 'boolean',
-                                            default: true,
-                                            description: 'Select the new workspace in this session after creation',
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                    responses: {
-                        '200': { description: 'Workspace folder created' },
-                        '400': { description: 'Invalid payload or folder already exists' },
-                        '404': { description: 'Session not found' },
-                        '409': { description: 'Session renderer is not ready for agent calls' },
-                    },
-                },
-            },
-            '/api/windows/{sessionId}/generate': {
-                post: {
-                    operationId: 'startGeneration',
-                    summary: 'Start content, image, catalog or landing generation (same as UI buttons)',
-                    parameters: [
-                        { name: 'sessionId', in: 'path', required: true, schema: { type: 'string' } },
-                    ],
-                    requestBody: {
-                        required: false,
-                        content: {
-                            'application/json': {
-                                schema: {
-                                    type: 'object',
-                                    properties: {
-                                        targets: {
-                                            type: 'array',
-                                            items: {
-                                                type: 'string',
-                                                enum: ['content', 'images', 'catalog', 'landing', 'all'],
-                                            },
-                                            description: 'Sequential targets. Default: ["content"]. "all" expands to content + images.',
-                                        },
-                                        marketIds: {
-                                            type: 'array',
-                                            items: { type: 'string' },
-                                            description: 'Optional market ids for landing target only',
-                                        },
-                                    },
-                                },
-                                examples: {
-                                    contentAndImages: {
-                                        value: { targets: ['content', 'images'] },
-                                    },
-                                    fullPipeline: {
-                                        value: { targets: ['content', 'images', 'catalog', 'landing'] },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                    responses: {
-                        '200': { description: 'Generation started or completed for requested targets' },
-                        '400': { description: 'Validation failed or unknown target' },
-                        '404': { description: 'Session not found' },
-                        '409': { description: 'Session renderer is not ready or job already running' },
-                    },
-                },
-            },
-            '/api/windows/{sessionId}/setup-campaign': {
-                post: {
-                    operationId: 'setupCampaignWorkspace',
-                    summary: 'Select campaign group, workspace folder, offer binding and optional generation fields',
-                    parameters: [
-                        {
-                            name: 'sessionId',
-                            in: 'path',
-                            required: true,
-                            schema: { type: 'string' },
-                        },
-                    ],
-                    requestBody: {
-                        required: true,
-                        content: {
-                            'application/json': {
-                                schema: { $ref: '#/components/schemas/SetupCampaignWorkspaceRequest' },
-                            },
-                        },
-                    },
-                    responses: {
-                        '200': { description: 'Campaign workspace configured' },
-                        '400': { description: 'Invalid payload or workspace not found' },
-                        '404': { description: 'Session not found' },
-                        '409': { description: 'Session renderer is not ready for agent calls' },
-                    },
-                },
-            },
-            '/api/windows/{sessionId}/geo-block': {
-                post: {
-                    operationId: 'fillGeoBlock',
-                    summary: 'Update the geo + price + link block in one work session',
-                    description: 'A single object partially updates one row and preserves omitted fields. A markets array sets the exact row list, removing rows not present in the array; omitted fields inside each row are preserved by id/index when possible.',
-                    parameters: [
-                        {
-                            name: 'sessionId',
-                            in: 'path',
-                            required: true,
-                            schema: { type: 'string' },
-                        },
-                    ],
-                    requestBody: {
-                        required: true,
-                        content: {
-                            'application/json': {
-                                schema: { $ref: '#/components/schemas/FillGeoBlockRequest' },
-                                examples: {
-                                    singleMarket: {
-                                        value: {
-                                            geo: 'Romania',
-                                            priceWithCurrency: '149 RON',
-                                            link: 'https://example.com/product/',
-                                        },
-                                    },
-                                    multipleMarkets: {
-                                        value: {
-                                            markets: [
-                                                {
-                                                    geo: 'Romania',
-                                                    priceWithCurrency: '149 RON',
-                                                    link: 'https://example.com/ro/',
-                                                },
-                                                {
-                                                    geo: 'Hungary',
-                                                    priceWithCurrency: '11400 HUF',
-                                                    link: 'https://example.com/hu/',
-                                                },
-                                            ],
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                    responses: {
-                        '200': {
-                            description: 'Geo block was replaced',
-                            content: {
-                                'application/json': {
-                                    schema: {
-                                        type: 'object',
-                                        required: ['ok', 'markets'],
-                                        properties: {
-                                            ok: { type: 'boolean', const: true },
-                                            markets: {
-                                                type: 'array',
-                                                items: { $ref: '#/components/schemas/GeoBlockMarket' },
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                        '400': { description: 'Invalid geo block payload' },
-                        '404': { description: 'Session not found' },
-                        '409': { description: 'Session renderer is not ready for agent calls' },
-                    },
-                },
-            },
-            '/api/windows/{sessionId}/creative-selections': {
-                get: {
-                    operationId: 'getCreativeSelections',
-                    summary: 'Return selected text and image creative approaches for one work session',
-                    parameters: [
-                        {
-                            name: 'sessionId',
-                            in: 'path',
-                            required: true,
-                            schema: { type: 'string' },
-                        },
-                    ],
-                    responses: {
-                        '200': {
-                            description: 'Current creative approach selections',
-                            content: {
-                                'application/json': {
-                                    schema: {
-                                        type: 'object',
-                                        required: ['ok', 'selections'],
-                                        properties: {
-                                            ok: { type: 'boolean', const: true },
-                                            selections: { $ref: '#/components/schemas/CreativeSelections' },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                        '404': { description: 'Session not found' },
-                        '409': { description: 'Session renderer is not ready for agent calls' },
-                    },
-                },
-                post: {
-                    operationId: 'setCreativeSelections',
-                    summary: 'Set selected text and image creative approaches for one work session',
-                    parameters: [
-                        {
-                            name: 'sessionId',
-                            in: 'path',
-                            required: true,
-                            schema: { type: 'string' },
-                        },
-                    ],
-                    requestBody: {
-                        required: true,
-                        content: {
-                            'application/json': {
-                                schema: { $ref: '#/components/schemas/SetCreativeSelectionsRequest' },
-                                examples: {
-                                    uiNumbers: {
-                                        value: {
-                                            selectedTextApproachNumbers: [1, 2, 3],
-                                            imageApproachCounts: [1, 1, 0, 0, 2, 0, 0, 0, 0, 0],
-                                        },
-                                    },
-                                    imageNumbers: {
-                                        value: {
-                                            selectedTextApproachIndices: [0, 1, 2],
-                                            selectedImageApproachNumbers: [1, 5],
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                    responses: {
-                        '200': {
-                            description: 'Creative approach selections were updated',
-                            content: {
-                                'application/json': {
-                                    schema: {
-                                        type: 'object',
-                                        required: ['ok', 'selections'],
-                                        properties: {
-                                            ok: { type: 'boolean', const: true },
-                                            selections: { $ref: '#/components/schemas/CreativeSelections' },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                        '400': { description: 'Invalid creative selections payload' },
-                        '404': { description: 'Session not found' },
-                        '409': { description: 'Session renderer is not ready for agent calls' },
-                    },
-                },
-            },
-            '/api/windows/{sessionId}/capabilities': {
-                get: {
-                    operationId: 'getCapabilities',
-                    summary: 'Return what the agent is allowed to read or change in this session',
-                    responses: { '200': { description: 'Session capabilities' } },
-                },
-            },
-            '/api/windows/{sessionId}/validation': {
-                get: {
-                    operationId: 'getValidation',
-                    summary: 'Return readiness checks and blocking issues for this session',
-                    responses: { '200': { description: 'Validation checklist' } },
-                },
-            },
-            '/api/windows/{sessionId}/jobs': {
-                get: {
-                    operationId: 'listJobs',
-                    summary: 'Return observable UI job statuses for this session',
-                    responses: { '200': { description: 'Known job statuses' } },
-                },
-            },
-            '/api/windows/{sessionId}/jobs/{jobId}': {
-                get: {
-                    operationId: 'getJobStatus',
-                    summary: 'Return one observable UI job status',
-                    parameters: [
-                        { name: 'sessionId', in: 'path', required: true, schema: { type: 'string' } },
-                        { name: 'jobId', in: 'path', required: true, schema: { type: 'string' } },
-                    ],
-                    responses: { '200': { description: 'Job status' }, '404': { description: 'Unknown job id' } },
-                },
-            },
-            '/api/windows/{sessionId}/generated': {
-                get: {
-                    operationId: 'getGenerated',
-                    summary: 'Return generated titles, texts, images, catalog rows and landing artifacts',
-                    responses: { '200': { description: 'Generated session artifacts' } },
-                },
-                patch: {
-                    operationId: 'patchGenerated',
-                    summary: 'Partially edit generated titles, texts or image metadata without starting generation',
-                    requestBody: {
-                        required: true,
-                        content: {
-                            'application/json': {
-                                schema: { $ref: '#/components/schemas/PatchGeneratedRequest' },
-                                examples: {
-                                    titleText: {
-                                        value: {
-                                            titles: [{ index: 1, title: 'New title' }],
-                                            texts: [{ index: 1, text: 'New text' }],
-                                        },
-                                    },
-                                    imageMetadata: {
-                                        value: {
-                                            images: [{ index: 1, failed: false, errorMessage: '' }],
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                    responses: { '200': { description: 'Generated artifacts were updated' }, '400': { description: 'Invalid patch' } },
-                },
-            },
-            '/api/windows/{sessionId}/logs': {
-                get: {
-                    operationId: 'getLogs',
-                    summary: 'Return recent content, image, landing and catalog replacement logs',
-                    responses: { '200': { description: 'Session logs' } },
-                },
-            },
-            '/api/spec': {
-                get: {
-                    operationId: 'getAgentApiSpec',
-                    summary: 'Return the machine-readable Agent API description',
-                    responses: {
-                        '200': {
-                            description: 'OpenAPI-like API description for automation agents',
-                        },
-                    },
-                },
-            },
-        },
-        components: {
-            schemas: {
-                AgentWorkSessionInfo: {
-                    type: 'object',
-                    required: ['id', 'title', 'description', 'active', 'url', 'endpoints'],
-                    properties: {
-                        id: {
-                            type: 'string',
-                            description: 'Stable workspace/session id to use in future agent operations.',
-                        },
-                        title: { type: 'string' },
-                        description: {
-                            type: 'string',
-                            description: 'Short human-readable summary of what is open in this session.',
-                        },
-                        folderId: {
-                            type: 'string',
-                            description: 'Current Google Drive folder id, when selected.',
-                        },
-                        folderPath: {
-                            type: 'string',
-                            description: 'Two-level display path for the current Drive folder, for example OFFERS/OfferName.',
-                        },
-                        active: { type: 'boolean' },
-                        url: {
-                            type: 'string',
-                            description: 'Full local URL for reading this session state.',
-                        },
-                        endpoints: {
-                            type: 'object',
-                            required: ['info', 'update', 'geoBlock', 'creativeSelections', 'capabilities', 'validation', 'generated', 'logs', 'jobs'],
-                            properties: {
-                                info: { type: 'string' },
-                                update: { type: 'string' },
-                                geoBlock: { type: 'string' },
-                                creativeSelections: { type: 'string' },
-                                capabilities: { type: 'string' },
-                                validation: { type: 'string' },
-                                generated: { type: 'string' },
-                                logs: { type: 'string' },
-                                jobs: { type: 'string' },
-                            },
-                        },
-                    },
-                },
-                GeoBlockMarket: {
-                    type: 'object',
-                    properties: {
-                        id: { type: 'string' },
-                        geo: { type: 'string' },
-                        priceWithCurrency: { type: 'string' },
-                        link: { type: 'string' },
-                    },
-                },
-                FillGeoBlockRequest: {
-                    oneOf: [
-                        { $ref: '#/components/schemas/GeoBlockMarket' },
-                        {
-                            type: 'object',
-                            required: ['markets'],
-                            properties: {
-                                markets: {
-                                    type: 'array',
-                                    minItems: 1,
-                                    items: { $ref: '#/components/schemas/GeoBlockMarket' },
-                                },
-                            },
-                        },
-                    ],
-                },
-                PatchSessionInfoRequest: {
-                    type: 'object',
-                    description: 'Partial session update. Omitted fields are left unchanged.',
-                    properties: {
-                        generateProduct: { type: 'string' },
-                        generateAdditionalInfo: { type: 'string' },
-                        generateGeo: { type: 'string' },
-                        generatePriceWithCurrency: { type: 'string' },
-                        link: { type: 'string' },
-                        generationMarkets: {
-                            type: 'array',
-                            items: { $ref: '#/components/schemas/GeoBlockMarket' },
-                        },
-                        markets: {
-                            type: 'array',
-                            items: { $ref: '#/components/schemas/GeoBlockMarket' },
-                        },
-                        geoBlock: {
-                            type: 'array',
-                            items: { $ref: '#/components/schemas/GeoBlockMarket' },
-                        },
-                        generation: {
-                            type: 'object',
-                            properties: {
-                                product: { type: 'string' },
-                                additionalInfo: { type: 'string' },
-                                firstGeo: { type: 'string' },
-                                firstPriceWithCurrency: { type: 'string' },
-                                firstLink: { type: 'string' },
-                                geoBlock: {
-                                    type: 'array',
-                                    items: { $ref: '#/components/schemas/GeoBlockMarket' },
-                                },
-                            },
-                        },
-                        catalogUrlSettings: { type: 'object' },
-                        creativeSelections: { $ref: '#/components/schemas/SetCreativeSelectionsRequest' },
-                        promptSettings: { type: 'object' },
-                        drive: {
-                            type: 'object',
-                            description: 'Select campaign group, workspace folder and offer binding before generation.',
-                            properties: {
-                                groupName: { type: 'string' },
-                                workspaceFolderId: { type: 'string' },
-                                workspaceName: { type: 'string' },
-                                offer: { type: 'string' },
-                            },
-                        },
-                    },
-                },
-                SetupCampaignWorkspaceRequest: {
-                    type: 'object',
-                    required: ['groupName'],
-                    properties: {
-                        groupName: { type: 'string' },
-                        workspaceFolderId: { type: 'string' },
-                        workspaceName: { type: 'string' },
-                        offer: { type: 'string' },
-                        generation: { type: 'object' },
-                        creativeSelections: { $ref: '#/components/schemas/SetCreativeSelectionsRequest' },
-                    },
-                },
-                DriveCatalog: {
-                    type: 'object',
-                    description: 'Offers root, campaigns tree and current session Drive bindings.',
-                },
-                CreativeSelections: {
-                    type: 'object',
-                    required: ['textApproaches', 'imageApproaches'],
-                    properties: {
-                        textApproaches: {
-                            type: 'object',
-                            required: ['selectedIndices', 'selectedNumbers'],
-                            properties: {
-                                selectedIndices: {
-                                    type: 'array',
-                                    description: '0-based selected text approach indices.',
-                                    items: { type: 'number' },
-                                },
-                                selectedNumbers: {
-                                    type: 'array',
-                                    description: '1-based selected text approach numbers as shown in the UI.',
-                                    items: { type: 'number' },
-                                },
-                            },
-                        },
-                        imageApproaches: {
-                            type: 'object',
-                            required: ['counts', 'selectedIndices', 'selectedNumbers', 'maxPerApproach'],
-                            properties: {
-                                counts: {
-                                    type: 'array',
-                                    description: 'Image count per creative approach, 10 items, values from 0 to maxPerApproach.',
-                                    items: { type: 'number' },
-                                },
-                                selectedIndices: {
-                                    type: 'array',
-                                    description: '0-based image approach indices where count is greater than 0.',
-                                    items: { type: 'number' },
-                                },
-                                selectedNumbers: {
-                                    type: 'array',
-                                    description: '1-based image approach numbers where count is greater than 0.',
-                                    items: { type: 'number' },
-                                },
-                                maxPerApproach: { type: 'number' },
-                            },
-                        },
-                    },
-                },
-                SetCreativeSelectionsRequest: {
-                    type: 'object',
-                    properties: {
-                        selectedTextApproachIndices: {
-                            type: 'array',
-                            description: '0-based text approach indices. At least two unique approaches are required if provided.',
-                            items: { type: 'number' },
-                        },
-                        selectedTextApproachNumbers: {
-                            type: 'array',
-                            description: '1-based text approach numbers as shown in the UI. At least two unique approaches are required if provided.',
-                            items: { type: 'number' },
-                        },
-                        imageApproachCounts: {
-                            type: 'array',
-                            description: 'Image count per creative approach, 10 items, values from 0 to maxPerApproach.',
-                            items: { type: 'number' },
-                        },
-                        selectedImageApproachIndices: {
-                            type: 'array',
-                            description: '0-based image approach indices. Each selected approach gets count=1.',
-                            items: { type: 'number' },
-                        },
-                        selectedImageApproachNumbers: {
-                            type: 'array',
-                            description: '1-based image approach numbers as shown in the UI. Each selected approach gets count=1.',
-                            items: { type: 'number' },
-                        },
-                    },
-                },
-                PatchGeneratedRequest: {
-                    type: 'object',
-                    description: 'Partial edit for generated artifacts. Omitted fields are unchanged.',
-                    properties: {
-                        titles: {
-                            type: 'array',
-                            items: {
-                                type: 'object',
-                                required: ['index'],
-                                properties: {
-                                    index: { type: 'number', description: '1-based title row index.' },
-                                    title: { type: 'string' },
-                                    failed: { type: 'boolean' },
-                                    errorMessage: { type: 'string' },
-                                },
-                            },
-                        },
-                        texts: {
-                            type: 'array',
-                            items: {
-                                type: 'object',
-                                required: ['index'],
-                                properties: {
-                                    index: { type: 'number', description: '1-based text row index.' },
-                                    text: { type: 'string' },
-                                    failed: { type: 'boolean' },
-                                    errorMessage: { type: 'string' },
-                                },
-                            },
-                        },
-                        images: {
-                            type: 'array',
-                            items: {
-                                type: 'object',
-                                required: ['index'],
-                                properties: {
-                                    index: { type: 'number', description: '1-based image slot index.' },
-                                    imageUrl: { type: 'string' },
-                                    approach: { type: 'string' },
-                                    geo: { type: 'string' },
-                                    priceWithCurrency: { type: 'string' },
-                                    aspectRatio: { type: 'string' },
-                                    uploaded: { type: 'boolean' },
-                                    failed: { type: 'boolean' },
-                                    errorMessage: { type: 'string' },
-                                    checkStatus: { type: 'string' },
-                                    checkResult: { type: 'string' },
-                                    checkErrors: { type: 'array', items: { type: 'string' } },
-                                },
-                            },
-                        },
-                    },
-                },
-                AgentSessionInfo: {
-                    type: 'object',
-                    description: 'Live renderer state for one Docs Combiner work session.',
-                    required: ['id', 'title', 'updatedAt', 'generation', 'snapshot'],
-                    properties: {
-                        id: { type: 'string' },
-                        title: { type: 'string' },
-                        updatedAt: { type: 'string', format: 'date-time' },
-                        drive: { type: 'object' },
-                        generation: {
-                            type: 'object',
-                            properties: {
-                                product: { type: 'string' },
-                                additionalInfo: { type: 'string' },
-                                geoBlock: {
-                                    type: 'array',
-                                    items: { $ref: '#/components/schemas/GeoBlockMarket' },
-                                },
-                                firstGeo: { type: 'string' },
-                                firstPriceWithCurrency: { type: 'string' },
-                                firstLink: { type: 'string' },
-                                brand: { type: 'string' },
-                            },
-                        },
-                        catalogUrlSettings: { type: 'object' },
-                        promptSettings: { type: 'object' },
-                        snapshot: {
-                            type: 'object',
-                            description: 'Serializable workspace snapshot used by the app autosave.',
-                        },
-                    },
-                },
-            },
-        },
-    };
-}
 function startAgentApiServer() {
     if (agentApiServer)
         return;
     const api = (0, express_1.default)();
     api.disable('x-powered-by');
     api.use(express_1.default.json({ limit: '1mb' }));
-    api.get('/api/windows', (_req, res) => {
-        res.json({
-            ok: true,
-            windows: getAgentWorkSessions(),
-        });
-    });
-    api.post('/api/windows', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c;
-        const requestedId = String((_b = (_a = req.body) === null || _a === void 0 ? void 0 : _a.workspaceId) !== null && _b !== void 0 ? _b : '').trim();
-        const workspaceId = requestedId || createWorkspaceId();
-        createWindow(workspaceId);
-        broadcastWorkspaceWindowsUpdated();
-        const session = yield waitForAgentSessionReady(workspaceId);
-        const baseUrl = getAgentApiBaseUrl();
-        const sessionUrl = `${baseUrl}/api/windows/${encodeURIComponent(workspaceId)}`;
-        if (session) {
-            res.status(201).json({
-                ok: true,
-                ready: true,
-                session,
-                url: sessionUrl,
-                endpoints: (_c = getAgentWorkSessions().find(item => item.id === workspaceId)) === null || _c === void 0 ? void 0 : _c.endpoints,
-            });
-            return;
-        }
-        res.status(202).json({
-            ok: true,
-            ready: false,
-            session: { id: workspaceId, title: 'Новый оффер' },
-            url: sessionUrl,
-            message: 'Window opened, but renderer Agent API is not ready yet. Retry GET /api/windows/{sessionId}.',
-        });
-    }));
-    api.get('/api/catalog', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const preferredSessionId = String((_a = req.query.sessionId) !== null && _a !== void 0 ? _a : '').trim();
-        const response = yield callFirstReadyAgentRendererApi('getDriveCatalog', null, preferredSessionId || undefined);
-        if (!response.ok) {
-            res.status(response.status).json({ ok: false, error: response.error });
-            return;
-        }
-        res.json({ ok: true, catalog: response.result });
-    }));
-    api.get('/api/windows/:sessionId', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const sessionId = String((_a = req.params.sessionId) !== null && _a !== void 0 ? _a : '').trim();
-        if (!sessionId) {
-            res.status(400).json({ ok: false, error: 'Session id is required.' });
-            return;
-        }
-        const response = yield callAgentRendererApi(sessionId, 'getSessionInfo');
-        if (!response.ok) {
-            res.status(response.status).json({ ok: false, error: response.error });
-            return;
-        }
-        res.json({ ok: true, session: response.result });
-    }));
-    api.patch('/api/windows/:sessionId', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const sessionId = String((_a = req.params.sessionId) !== null && _a !== void 0 ? _a : '').trim();
-        if (!sessionId) {
-            res.status(400).json({ ok: false, error: 'Session id is required.' });
-            return;
-        }
-        const response = yield callAgentRendererApi(sessionId, 'patchSessionInfo', req.body);
-        if (!response.ok) {
-            res.status(response.status).json({ ok: false, error: response.error });
-            return;
-        }
-        if (((_b = response.result) === null || _b === void 0 ? void 0 : _b.ok) === false) {
-            res.status(400).json(response.result);
-            return;
-        }
-        res.json(response.result);
-    }));
-    api.post('/api/windows/:sessionId/setup-campaign', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const sessionId = String((_a = req.params.sessionId) !== null && _a !== void 0 ? _a : '').trim();
-        if (!sessionId) {
-            res.status(400).json({ ok: false, error: 'Session id is required.' });
-            return;
-        }
-        const response = yield callAgentRendererApi(sessionId, 'setupCampaignWorkspace', req.body);
-        if (!response.ok) {
-            res.status(response.status).json({ ok: false, error: response.error });
-            return;
-        }
-        if (((_b = response.result) === null || _b === void 0 ? void 0 : _b.ok) === false) {
-            res.status(400).json(response.result);
-            return;
-        }
-        res.json(response.result);
-    }));
-    api.post('/api/windows/:sessionId/catalog/groups', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const sessionId = String((_a = req.params.sessionId) !== null && _a !== void 0 ? _a : '').trim();
-        if (!sessionId) {
-            res.status(400).json({ ok: false, error: 'Session id is required.' });
-            return;
-        }
-        const response = yield callAgentRendererApi(sessionId, 'createCampaignGroup', req.body);
-        if (!response.ok) {
-            res.status(response.status).json({ ok: false, error: response.error });
-            return;
-        }
-        if (((_b = response.result) === null || _b === void 0 ? void 0 : _b.ok) === false) {
-            res.status(400).json(response.result);
-            return;
-        }
-        res.json(response.result);
-    }));
-    api.post('/api/windows/:sessionId/catalog/workspaces', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const sessionId = String((_a = req.params.sessionId) !== null && _a !== void 0 ? _a : '').trim();
-        if (!sessionId) {
-            res.status(400).json({ ok: false, error: 'Session id is required.' });
-            return;
-        }
-        const response = yield callAgentRendererApi(sessionId, 'createWorkspaceFolder', req.body);
-        if (!response.ok) {
-            res.status(response.status).json({ ok: false, error: response.error });
-            return;
-        }
-        if (((_b = response.result) === null || _b === void 0 ? void 0 : _b.ok) === false) {
-            res.status(400).json(response.result);
-            return;
-        }
-        res.json(response.result);
-    }));
-    api.post('/api/windows/:sessionId/generate', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const sessionId = String((_a = req.params.sessionId) !== null && _a !== void 0 ? _a : '').trim();
-        if (!sessionId) {
-            res.status(400).json({ ok: false, error: 'Session id is required.' });
-            return;
-        }
-        const body = req.body && typeof req.body === 'object' ? req.body : {};
-        const response = yield callAgentRendererApi(sessionId, 'startGeneration', body);
-        if (!response.ok) {
-            res.status(response.status).json({ ok: false, error: response.error });
-            return;
-        }
-        if (((_b = response.result) === null || _b === void 0 ? void 0 : _b.ok) === false) {
-            res.status(400).json(response.result);
-            return;
-        }
-        res.json(response.result);
-    }));
-    api.post('/api/windows/:sessionId/geo-block', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const sessionId = String((_a = req.params.sessionId) !== null && _a !== void 0 ? _a : '').trim();
-        if (!sessionId) {
-            res.status(400).json({ ok: false, error: 'Session id is required.' });
-            return;
-        }
-        const response = yield callAgentRendererApi(sessionId, 'fillGeoBlock', req.body);
-        if (!response.ok) {
-            res.status(response.status).json({ ok: false, error: response.error });
-            return;
-        }
-        if (((_b = response.result) === null || _b === void 0 ? void 0 : _b.ok) === false) {
-            res.status(400).json(response.result);
-            return;
-        }
-        res.json(response.result);
-    }));
-    api.get('/api/windows/:sessionId/creative-selections', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const sessionId = String((_a = req.params.sessionId) !== null && _a !== void 0 ? _a : '').trim();
-        if (!sessionId) {
-            res.status(400).json({ ok: false, error: 'Session id is required.' });
-            return;
-        }
-        const response = yield callAgentRendererApi(sessionId, 'getCreativeSelections');
-        if (!response.ok) {
-            res.status(response.status).json({ ok: false, error: response.error });
-            return;
-        }
-        res.json({ ok: true, selections: response.result });
-    }));
-    api.post('/api/windows/:sessionId/creative-selections', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const sessionId = String((_a = req.params.sessionId) !== null && _a !== void 0 ? _a : '').trim();
-        if (!sessionId) {
-            res.status(400).json({ ok: false, error: 'Session id is required.' });
-            return;
-        }
-        const response = yield callAgentRendererApi(sessionId, 'setCreativeSelections', req.body);
-        if (!response.ok) {
-            res.status(response.status).json({ ok: false, error: response.error });
-            return;
-        }
-        if (((_b = response.result) === null || _b === void 0 ? void 0 : _b.ok) === false) {
-            res.status(400).json(response.result);
-            return;
-        }
-        res.json(response.result);
-    }));
-    api.get('/api/windows/:sessionId/capabilities', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const sessionId = String((_a = req.params.sessionId) !== null && _a !== void 0 ? _a : '').trim();
-        const response = yield callAgentRendererApi(sessionId, 'getCapabilities');
-        if (!response.ok) {
-            res.status(response.status).json({ ok: false, error: response.error });
-            return;
-        }
-        res.json({ ok: true, capabilities: response.result });
-    }));
-    api.get('/api/windows/:sessionId/validation', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const sessionId = String((_a = req.params.sessionId) !== null && _a !== void 0 ? _a : '').trim();
-        const response = yield callAgentRendererApi(sessionId, 'getValidation');
-        if (!response.ok) {
-            res.status(response.status).json({ ok: false, error: response.error });
-            return;
-        }
-        res.json({ ok: true, validation: response.result });
-    }));
-    api.get('/api/windows/:sessionId/jobs', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const sessionId = String((_a = req.params.sessionId) !== null && _a !== void 0 ? _a : '').trim();
-        const response = yield callAgentRendererApi(sessionId, 'getJobStatus', {});
-        if (!response.ok) {
-            res.status(response.status).json({ ok: false, error: response.error });
-            return;
-        }
-        res.json(response.result);
-    }));
-    api.get('/api/windows/:sessionId/jobs/:jobId', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const sessionId = String((_a = req.params.sessionId) !== null && _a !== void 0 ? _a : '').trim();
-        const response = yield callAgentRendererApi(sessionId, 'getJobStatus', { jobId: req.params.jobId });
-        if (!response.ok) {
-            res.status(response.status).json({ ok: false, error: response.error });
-            return;
-        }
-        if (((_b = response.result) === null || _b === void 0 ? void 0 : _b.ok) === false) {
-            res.status(404).json(response.result);
-            return;
-        }
-        res.json(response.result);
-    }));
-    api.get('/api/windows/:sessionId/generated', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const sessionId = String((_a = req.params.sessionId) !== null && _a !== void 0 ? _a : '').trim();
-        const response = yield callAgentRendererApi(sessionId, 'getGenerated');
-        if (!response.ok) {
-            res.status(response.status).json({ ok: false, error: response.error });
-            return;
-        }
-        res.json({ ok: true, generated: response.result });
-    }));
-    api.patch('/api/windows/:sessionId/generated', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const sessionId = String((_a = req.params.sessionId) !== null && _a !== void 0 ? _a : '').trim();
-        const response = yield callAgentRendererApi(sessionId, 'patchGenerated', req.body);
-        if (!response.ok) {
-            res.status(response.status).json({ ok: false, error: response.error });
-            return;
-        }
-        if (((_b = response.result) === null || _b === void 0 ? void 0 : _b.ok) === false) {
-            res.status(400).json(response.result);
-            return;
-        }
-        res.json(response.result);
-    }));
-    api.get('/api/windows/:sessionId/logs', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const sessionId = String((_a = req.params.sessionId) !== null && _a !== void 0 ? _a : '').trim();
-        const response = yield callAgentRendererApi(sessionId, 'getLogs');
-        if (!response.ok) {
-            res.status(response.status).json({ ok: false, error: response.error });
-            return;
-        }
-        res.json({ ok: true, logs: response.result });
-    }));
-    api.get('/api/spec', (_req, res) => {
-        const address = agentApiServer === null || agentApiServer === void 0 ? void 0 : agentApiServer.address();
-        const port = address && typeof address !== 'string' ? address.port : AGENT_API_PORT;
-        res.json(getAgentApiSpec(port));
+    (0, routes_1.registerAgentApiRoutes)(api, {
+        host: AGENT_API_HOST,
+        port: AGENT_API_PORT,
+        version: electron_1.app.getVersion(),
+        getAgentWorkSessions,
+        isAgentApiReadyInSession,
+        agentControlledSessionCount: () => agentControlledSessions.size,
+        createWorkspaceId,
+        createWindow,
+        broadcastWorkspaceWindowsUpdated,
+        waitForAgentSessionReady,
+        getAgentApiBaseUrl,
+        callFirstReadyAgentRendererApi,
+        callAgentRendererApi,
+        getWindowByWorkspaceId,
+        setSessionAgentControlMode,
+        closeSession: closeSessionByWorkspaceId,
     });
     agentApiServer = api.listen(AGENT_API_PORT, AGENT_API_HOST, () => {
         console.log(`[Agent API] Listening on http://${AGENT_API_HOST}:${AGENT_API_PORT}`);
@@ -1420,7 +469,27 @@ function cleanupWindowFolder(webContentsId) {
     if (!folderId)
         return;
     windowFolders.delete(webContentsId);
-    if (folderOwners.get(folderId) === webContentsId) {
+    const owners = folderOwners.get(folderId);
+    if (!owners)
+        return;
+    owners.delete(webContentsId);
+    if (owners.size === 0) {
+        folderOwners.delete(folderId);
+    }
+}
+function pruneStaleFolderOwners(folderId) {
+    const owners = folderOwners.get(folderId);
+    if (!owners)
+        return;
+    for (const ownerId of [...owners]) {
+        const ownerWin = electron_1.BrowserWindow.getAllWindows().find(w => w.webContents.id === ownerId);
+        const ownerAlive = Boolean(ownerWin) && !ownerWin.isDestroyed() && !ownerWin.webContents.isDestroyed();
+        if (!ownerAlive) {
+            owners.delete(ownerId);
+            windowFolders.delete(ownerId);
+        }
+    }
+    if (owners.size === 0) {
         folderOwners.delete(folderId);
     }
 }
@@ -1457,6 +526,8 @@ function telegramSendMessageViaBot(botToken, chatId, text) {
     return __awaiter(this, void 0, void 0, function* () {
         const apiUrl = `https://api.telegram.org/bot${encodeURIComponent(botToken)}/sendMessage`;
         const safeText = text.length > 4096 ? `${text.slice(0, 4090)}…` : text;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 30000);
         try {
             const res = yield fetch(apiUrl, {
                 method: 'POST',
@@ -1465,6 +536,7 @@ function telegramSendMessageViaBot(botToken, chatId, text) {
                     chat_id: chatId,
                     text: safeText,
                 }),
+                signal: controller.signal,
             });
             const data = (yield res.json());
             if (!data.ok) {
@@ -1481,6 +553,9 @@ function telegramSendMessageViaBot(botToken, chatId, text) {
                 error: e instanceof Error ? e.message : String(e),
             };
         }
+        finally {
+            clearTimeout(timeoutId);
+        }
     });
 }
 function abortPendingGoogleAuth(reason) {
@@ -1562,7 +637,11 @@ function buildAppMenu() {
     });
     electron_1.Menu.setApplicationMenu(electron_1.Menu.buildFromTemplate(template));
 }
-function createWindow(workspaceId = createWorkspaceId()) {
+function createWindow(workspaceId = createWorkspaceId(), options) {
+    closedWorkspaceIds.delete(workspaceId);
+    if (options === null || options === void 0 ? void 0 : options.agentControlled) {
+        agentControlledSessions.add(workspaceId);
+    }
     const win = new electron_1.BrowserWindow({
         width: 1000,
         height: 800,
@@ -1584,6 +663,10 @@ function createWindow(workspaceId = createWorkspaceId()) {
     win.on('closed', () => {
         var _a;
         closingWindowIds.delete(win.webContents.id);
+        const closedWorkspaceId = windowWorkspaces.get(win.webContents.id);
+        if (closedWorkspaceId) {
+            agentControlledSessions.delete(closedWorkspaceId);
+        }
         windows.delete(win);
         cleanupWindowFolder(win.webContents.id);
         windowWorkspaces.delete(win.webContents.id);
@@ -1652,7 +735,10 @@ function createWindow(workspaceId = createWorkspaceId()) {
     });
     // We need to point to the webpack output html
     win.loadFile(path.join(__dirname, 'index.html'), {
-        query: { workspaceId },
+        query: {
+            workspaceId,
+            agentControlled: (options === null || options === void 0 ? void 0 : options.agentControlled) ? '1' : '0',
+        },
     });
     // DevTools disabled by default as requested
     // win.webContents.openDevTools();
@@ -1693,8 +779,12 @@ if (gotSingleInstanceLock)
         };
         const writeConfig = (config) => {
             try {
-                fs.writeFileSync(configPath, JSON.stringify(config));
-                broadcastConfigUpdated(config);
+                const sanitizedConfig = Object.assign({}, config);
+                if (Array.isArray(sanitizedConfig.workspaceSnapshots) && closedWorkspaceIds.size > 0) {
+                    sanitizedConfig.workspaceSnapshots = sanitizedConfig.workspaceSnapshots.filter((item) => { var _a; return !closedWorkspaceIds.has(String((_a = item === null || item === void 0 ? void 0 : item.id) !== null && _a !== void 0 ? _a : '')); });
+                }
+                fs.writeFileSync(configPath, JSON.stringify(sanitizedConfig));
+                broadcastConfigUpdated(sanitizedConfig);
                 return true;
             }
             catch (_a) {
@@ -1725,6 +815,8 @@ if (gotSingleInstanceLock)
             const id = String((_a = snapshot === null || snapshot === void 0 ? void 0 : snapshot.id) !== null && _a !== void 0 ? _a : '').trim();
             if (!id)
                 return { ok: false };
+            if (closedWorkspaceIds.has(id))
+                return { ok: false, error: 'Workspace is closed.' };
             const config = readConfig();
             const current = Array.isArray(config.workspaceSnapshots) ? config.workspaceSnapshots : [];
             const nextSnapshot = Object.assign(Object.assign({}, snapshot), { id, updatedAt: typeof snapshot.updatedAt === 'string' ? snapshot.updatedAt : new Date().toISOString() });
@@ -1742,17 +834,14 @@ if (gotSingleInstanceLock)
                 cleanupWindowFolder(webContentsId);
                 return { ok: true };
             }
-            const currentOwner = folderOwners.get(folderId);
-            if (currentOwner && currentOwner !== webContentsId) {
-                focusWindowByWebContentsId(currentOwner);
-                return {
-                    ok: false,
-                    reason: 'occupied',
-                    folderId,
-                };
-            }
+            pruneStaleFolderOwners(folderId);
             cleanupWindowFolder(webContentsId);
-            folderOwners.set(folderId, webContentsId);
+            let owners = folderOwners.get(folderId);
+            if (!owners) {
+                owners = new Set();
+                folderOwners.set(folderId, owners);
+            }
+            owners.add(webContentsId);
             windowFolders.set(webContentsId, folderId);
             broadcastWorkspaceWindowsUpdated();
             return { ok: true };
@@ -1771,21 +860,22 @@ if (gotSingleInstanceLock)
             return { ok: true };
         }));
         electron_1.ipcMain.handle('set-workspace-window-meta', (event, payload) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             const webContentsId = event.sender.id;
             const title = String((_a = payload === null || payload === void 0 ? void 0 : payload.title) !== null && _a !== void 0 ? _a : '').trim();
             if (title) {
                 windowTitles.set(webContentsId, title);
                 const win = electron_1.BrowserWindow.fromWebContents(event.sender);
-                if (win && !win.isDestroyed()) {
-                    win.setTitle(`${APP_WINDOW_TITLE} — ${title}`);
+                const workspaceId = (_b = windowWorkspaces.get(webContentsId)) !== null && _b !== void 0 ? _b : '';
+                if (win && !win.isDestroyed() && workspaceId) {
+                    syncWindowTitleForAgentControl(win, workspaceId);
                 }
             }
-            const folderId = String((_b = payload === null || payload === void 0 ? void 0 : payload.folderId) !== null && _b !== void 0 ? _b : '').trim();
+            const folderId = String((_c = payload === null || payload === void 0 ? void 0 : payload.folderId) !== null && _c !== void 0 ? _c : '').trim();
             if (folderId) {
                 windowFolders.set(webContentsId, folderId);
             }
-            const folderPath = String((_c = payload === null || payload === void 0 ? void 0 : payload.folderPath) !== null && _c !== void 0 ? _c : '').trim();
+            const folderPath = String((_d = payload === null || payload === void 0 ? void 0 : payload.folderPath) !== null && _d !== void 0 ? _d : '').trim();
             if (folderPath) {
                 windowFolderPaths.set(webContentsId, folderPath);
             }
@@ -1807,19 +897,31 @@ if (gotSingleInstanceLock)
             if (!win || win.isDestroyed())
                 return { ok: false };
             const workspaceId = windowWorkspaces.get(id);
+            if (!workspaceId) {
+                closingWindowIds.add(id);
+                broadcastWorkspaceWindowsUpdated();
+                win.destroy();
+                setImmediate(() => broadcastWorkspaceWindowsUpdated());
+                return { ok: true };
+            }
+            return closeSessionByWorkspaceId(workspaceId);
+        }));
+        electron_1.ipcMain.handle('close-all-workspace-windows', () => __awaiter(void 0, void 0, void 0, function* () { return closeAllWorkspaceSessions(); }));
+        electron_1.ipcMain.handle('close-other-workspace-windows', (event) => __awaiter(void 0, void 0, void 0, function* () { return closeOtherWorkspaceSessions(event.sender.id); }));
+        electron_1.ipcMain.handle('get-agent-control-mode', (event) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const workspaceId = (_a = windowWorkspaces.get(event.sender.id)) !== null && _a !== void 0 ? _a : '';
+            return {
+                mode: workspaceId && agentControlledSessions.has(workspaceId) ? 'agent' : 'manual',
+            };
+        }));
+        electron_1.ipcMain.handle('release-agent-control', (event) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const workspaceId = (_a = windowWorkspaces.get(event.sender.id)) !== null && _a !== void 0 ? _a : '';
             if (workspaceId) {
-                const config = readConfig();
-                const current = Array.isArray(config.workspaceSnapshots) ? config.workspaceSnapshots : [];
-                const next = current.filter((item) => (item === null || item === void 0 ? void 0 : item.id) !== workspaceId);
-                if (next.length !== current.length) {
-                    writeConfig(Object.assign(Object.assign({}, config), { workspaceSnapshots: next }));
-                }
+                setSessionAgentControlMode(workspaceId, 'manual');
             }
-            closingWindowIds.add(id);
-            broadcastWorkspaceWindowsUpdated();
-            win.destroy();
-            setImmediate(() => broadcastWorkspaceWindowsUpdated());
-            return { ok: true };
+            return { ok: true, mode: 'manual' };
         }));
         electron_1.ipcMain.handle('telegram-send-test', (_event, payload) => __awaiter(void 0, void 0, void 0, function* () {
             var _a, _b;