docs-combiner 0.2.2 → 0.4.0

package/dist/main.js

@@ -41,14 +41,39 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const electron_1 = require("electron");
+const express_1 = __importDefault(require("express"));
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const http = __importStar(require("http"));
 const url = __importStar(require("url"));
 let pendingGoogleAuth = null;
 let mainWindow = null;
+let agentApiServer = null;
+const windows = new Set();
+const folderOwners = new Map();
+const windowFolders = new Map();
+const windowFolderPaths = new Map();
+const windowWorkspaces = new Map();
+const windowTitles = new Map();
+const closingWindowIds = new Set();
+const AGENT_API_HOST = '127.0.0.1';
+const DEFAULT_AGENT_API_PORT = 17321;
+const APP_WINDOW_TITLE = 'Комбайнер';
+const AGENT_API_PORT = (() => {
+    const rawPort = Number(process.env.DOCS_COMBINER_AGENT_API_PORT);
+    return Number.isInteger(rawPort) && rawPort > 0 && rawPort <= 65535
+        ? rawPort
+        : DEFAULT_AGENT_API_PORT;
+})();
+const gotSingleInstanceLock = electron_1.app.requestSingleInstanceLock();
+if (!gotSingleInstanceLock) {
+    electron_1.app.quit();
+}
 if (process.env.DOCS_COMBINER_DISABLE_GPU === '1') {
     electron_1.app.disableHardwareAcceleration();
 }
@@ -56,6 +81,1356 @@ function getInspectableWindow() {
     var _a, _b, _c;
     return (_c = (_b = (_a = electron_1.BrowserWindow.getFocusedWindow()) !== null && _a !== void 0 ? _a : mainWindow) !== null && _b !== void 0 ? _b : electron_1.BrowserWindow.getAllWindows()[0]) !== null && _c !== void 0 ? _c : null;
 }
+function createWorkspaceId() {
+    return `workspace-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function getAgentApiBaseUrl() {
+    return `http://${AGENT_API_HOST}:${AGENT_API_PORT}`;
+}
+function getWorkspaceWindows() {
+    var _a, _b;
+    const focusedId = (_b = (_a = electron_1.BrowserWindow.getFocusedWindow()) === null || _a === void 0 ? void 0 : _a.webContents.id) !== null && _b !== void 0 ? _b : null;
+    return electron_1.BrowserWindow.getAllWindows()
+        .filter(win => !win.isDestroyed() && !win.webContents.isDestroyed() && !closingWindowIds.has(win.webContents.id))
+        .map(win => {
+        var _a;
+        const webContentsId = win.webContents.id;
+        const workspaceId = (_a = windowWorkspaces.get(webContentsId)) !== null && _a !== void 0 ? _a : '';
+        return {
+            workspaceId,
+            webContentsId,
+            title: windowTitles.get(webContentsId) || 'Новый оффер',
+            folderId: windowFolders.get(webContentsId),
+            folderPath: windowFolderPaths.get(webContentsId),
+            active: webContentsId === focusedId,
+        };
+    });
+}
+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 getWindowByWorkspaceId(workspaceId) {
+    var _a;
+    const id = workspaceId.trim();
+    return (_a = electron_1.BrowserWindow.getAllWindows().find(win => !win.isDestroyed() &&
+        !win.webContents.isDestroyed() &&
+        windowWorkspaces.get(win.webContents.id) === id)) !== null && _a !== void 0 ? _a : null;
+}
+function callAgentRendererApi(workspaceId, method, payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const win = getWindowByWorkspaceId(workspaceId);
+        if (!win) {
+            return { ok: false, status: 404, error: 'Session not found.' };
+        }
+        try {
+            const script = `
+      (async () => {
+        const api = window.__docsCombinerAgentApi;
+        if (!api || typeof api[${JSON.stringify(method)}] !== 'function') {
+          return { ok: false, error: 'Agent API is not ready in this session.' };
+        }
+        try {
+          const result = await api[${JSON.stringify(method)}](${JSON.stringify(payload !== null && payload !== void 0 ? payload : null)});
+          return { ok: true, result };
+        } catch (err) {
+          return { ok: false, error: err && err.message ? err.message : String(err) };
+        }
+      })()
+    `;
+            const response = yield win.webContents.executeJavaScript(script, true);
+            if (!(response === null || response === void 0 ? void 0 : response.ok)) {
+                return {
+                    ok: false,
+                    status: 409,
+                    error: String((response === null || response === void 0 ? void 0 : response.error) || 'Agent API call failed.'),
+                };
+            }
+            return { ok: true, result: response.result };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                status: 500,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    });
+}
+function callFirstReadyAgentRendererApi(method, payload, preferredSessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const preferredId = String(preferredSessionId !== null && preferredSessionId !== void 0 ? preferredSessionId : '').trim();
+        if (preferredId) {
+            const preferred = yield callAgentRendererApi(preferredId, method, payload);
+            if (preferred.ok)
+                return preferred;
+        }
+        const focused = electron_1.BrowserWindow.getFocusedWindow();
+        if (focused && !focused.isDestroyed() && !focused.webContents.isDestroyed()) {
+            const focusedId = windowWorkspaces.get(focused.webContents.id);
+            if (focusedId) {
+                const focusedResponse = yield callAgentRendererApi(focusedId, method, payload);
+                if (focusedResponse.ok)
+                    return focusedResponse;
+            }
+        }
+        for (const win of electron_1.BrowserWindow.getAllWindows()) {
+            if (win.isDestroyed() || win.webContents.isDestroyed())
+                continue;
+            if (win === focused)
+                continue;
+            const sessionId = windowWorkspaces.get(win.webContents.id);
+            if (!sessionId)
+                continue;
+            const response = yield callAgentRendererApi(sessionId, method, payload);
+            if (response.ok)
+                return response;
+        }
+        return {
+            ok: false,
+            status: 503,
+            error: 'No session with Agent API ready.',
+        };
+    });
+}
+function waitForAgentSessionReady(sessionId_1) {
+    return __awaiter(this, arguments, void 0, function* (sessionId, timeoutMs = 15000) {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < timeoutMs) {
+            const response = yield callAgentRendererApi(sessionId, 'getSessionInfo');
+            if (response.ok)
+                return response.result;
+            yield new Promise(resolve => setTimeout(resolve, 250));
+        }
+        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));
+    });
+    agentApiServer = api.listen(AGENT_API_PORT, AGENT_API_HOST, () => {
+        console.log(`[Agent API] Listening on http://${AGENT_API_HOST}:${AGENT_API_PORT}`);
+    });
+    agentApiServer.on('error', (err) => {
+        console.error('[Agent API] Failed to start:', err);
+    });
+}
+function broadcastWorkspaceWindowsUpdated() {
+    const list = getWorkspaceWindows();
+    for (const win of electron_1.BrowserWindow.getAllWindows()) {
+        if (!win.isDestroyed() && !win.webContents.isDestroyed()) {
+            win.webContents.send('workspace-windows-updated', list);
+        }
+    }
+}
+function focusWindowByWebContentsId(webContentsId) {
+    const win = electron_1.BrowserWindow.getAllWindows().find(w => w.webContents.id === webContentsId);
+    if (!win || win.isDestroyed())
+        return false;
+    if (win.isMinimized())
+        win.restore();
+    win.show();
+    win.focus();
+    return true;
+}
+function cleanupWindowFolder(webContentsId) {
+    const folderId = windowFolders.get(webContentsId);
+    windowFolderPaths.delete(webContentsId);
+    if (!folderId)
+        return;
+    windowFolders.delete(webContentsId);
+    if (folderOwners.get(folderId) === webContentsId) {
+        folderOwners.delete(folderId);
+    }
+}
+function broadcastConfigUpdated(config) {
+    for (const win of electron_1.BrowserWindow.getAllWindows()) {
+        if (!win.isDestroyed() && !win.webContents.isDestroyed()) {
+            win.webContents.send('config-updated', config);
+        }
+    }
+}
 function toggleDevToolsForWindow(win) {
     if (!win || win.isDestroyed()) {
         console.warn('[DevTools] No BrowserWindow available');
@@ -128,11 +1503,31 @@ function buildAppMenu() {
         template.push({ role: 'appMenu' });
         // Cut/Copy/Paste/Select All — без этого Cmd+V в полях иногда не работает (Chromium + системное меню).
         template.push({ role: 'editMenu' });
+        template.push({
+            label: 'File',
+            submenu: [
+                {
+                    label: 'New Window',
+                    accelerator: 'CmdOrCtrl+N',
+                    click: () => createWindow(),
+                },
+                { type: 'separator' },
+                { role: 'close' },
+            ],
+        });
     }
     else {
         template.push({
             label: 'File',
-            submenu: [{ role: 'quit' }],
+            submenu: [
+                {
+                    label: 'New Window',
+                    accelerator: 'Ctrl+N',
+                    click: () => createWindow(),
+                },
+                { type: 'separator' },
+                { role: 'quit' },
+            ],
         });
         template.push({
             label: 'Edit',
@@ -167,10 +1562,11 @@ function buildAppMenu() {
     });
     electron_1.Menu.setApplicationMenu(electron_1.Menu.buildFromTemplate(template));
 }
-function createWindow() {
-    mainWindow = new electron_1.BrowserWindow({
+function createWindow(workspaceId = createWorkspaceId()) {
+    const win = new electron_1.BrowserWindow({
         width: 1000,
         height: 800,
+        title: APP_WINDOW_TITLE,
         backgroundColor: '#121212', // Set to dark by default, will be corrected by preload if light
         show: false, // Don't show until ready to prevent flash
         webPreferences: {
@@ -180,7 +1576,25 @@ function createWindow() {
             sandbox: false
         },
     });
-    const win = mainWindow;
+    mainWindow = win;
+    windows.add(win);
+    windowWorkspaces.set(win.webContents.id, workspaceId);
+    windowTitles.set(win.webContents.id, 'Новый оффер');
+    broadcastWorkspaceWindowsUpdated();
+    win.on('closed', () => {
+        var _a;
+        closingWindowIds.delete(win.webContents.id);
+        windows.delete(win);
+        cleanupWindowFolder(win.webContents.id);
+        windowWorkspaces.delete(win.webContents.id);
+        windowTitles.delete(win.webContents.id);
+        if (mainWindow === win) {
+            mainWindow = (_a = electron_1.BrowserWindow.getAllWindows()[0]) !== null && _a !== void 0 ? _a : null;
+        }
+        broadcastWorkspaceWindowsUpdated();
+    });
+    win.on('focus', () => broadcastWorkspaceWindowsUpdated());
+    win.on('show', () => broadcastWorkspaceWindowsUpdated());
     // Toggles from main: works when the page/React failed — handled before the renderer consumes the key.
     // F12, Cmd+Shift+D (mac) / Ctrl+Shift+D (win/linux); also View → Toggle Developer Tools / Cmd+Option+I (see menu).
     win.webContents.on('before-input-event', (event, input) => {
@@ -237,201 +1651,350 @@ function createWindow() {
         });
     });
     // We need to point to the webpack output html
-    win.loadFile(path.join(__dirname, 'index.html'));
+    win.loadFile(path.join(__dirname, 'index.html'), {
+        query: { workspaceId },
+    });
     // DevTools disabled by default as requested
-    // mainWindow.webContents.openDevTools();
+    // win.webContents.openDevTools();
 }
-electron_1.app.whenReady().then(() => {
-    buildAppMenu();
-    electron_1.app.on('child-process-gone', (_event, details) => {
-        console.error(`[Electron] child-process-gone: type=${details.type}, reason=${details.reason}, exitCode=${details.exitCode}`);
-    });
-    const userDataPath = electron_1.app.getPath('userData');
-    if (!fs.existsSync(userDataPath)) {
-        fs.mkdirSync(userDataPath, { recursive: true });
-    }
-    const configPath = path.join(userDataPath, 'config.json');
-    electron_1.ipcMain.handle('save-config', (event, config) => __awaiter(void 0, void 0, void 0, function* () {
-        try {
-            fs.writeFileSync(configPath, JSON.stringify(config));
-            return true;
+if (gotSingleInstanceLock) {
+    electron_1.app.on('second-instance', () => {
+        if (electron_1.app.isReady()) {
+            createWindow();
+            return;
         }
-        catch (e) {
-            return false;
+        electron_1.app.whenReady().then(() => createWindow()).catch(err => {
+            console.error('[Main] Failed to open window for second instance:', err);
+        });
+    });
+}
+if (gotSingleInstanceLock)
+    electron_1.app.whenReady().then(() => {
+        buildAppMenu();
+        startAgentApiServer();
+        electron_1.app.on('child-process-gone', (_event, details) => {
+            console.error(`[Electron] child-process-gone: type=${details.type}, reason=${details.reason}, exitCode=${details.exitCode}`);
+        });
+        const userDataPath = electron_1.app.getPath('userData');
+        if (!fs.existsSync(userDataPath)) {
+            fs.mkdirSync(userDataPath, { recursive: true });
         }
-    }));
-    electron_1.ipcMain.handle('load-config', () => __awaiter(void 0, void 0, void 0, function* () {
-        try {
-            if (fs.existsSync(configPath)) {
+        const configPath = path.join(userDataPath, 'config.json');
+        const readConfig = () => {
+            try {
+                if (!fs.existsSync(configPath))
+                    return {};
                 const content = fs.readFileSync(configPath, 'utf-8');
                 return JSON.parse(content);
             }
-            return {};
-        }
-        catch (e) {
-            return {};
-        }
-    }));
-    electron_1.ipcMain.handle('telegram-send-test', (_event, payload) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b;
-        const botToken = String((_a = payload === null || payload === void 0 ? void 0 : payload.botToken) !== null && _a !== void 0 ? _a : '').trim();
-        const chatId = String((_b = payload === null || payload === void 0 ? void 0 : payload.chatId) !== null && _b !== void 0 ? _b : '').trim();
-        if (!botToken || !chatId) {
-            return { ok: false, error: 'Укажите токен бота и ID чата.' };
-        }
-        return telegramSendMessageViaBot(botToken, chatId, 'Docs Combiner — тест оповещений.');
-    }));
-    electron_1.ipcMain.handle('telegram-send-message', (_event, payload) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b, _c;
-        const botToken = String((_a = payload === null || payload === void 0 ? void 0 : payload.botToken) !== null && _a !== void 0 ? _a : '').trim();
-        const chatId = String((_b = payload === null || payload === void 0 ? void 0 : payload.chatId) !== null && _b !== void 0 ? _b : '').trim();
-        const text = String((_c = payload === null || payload === void 0 ? void 0 : payload.text) !== null && _c !== void 0 ? _c : '');
-        if (!botToken || !chatId) {
-            return { ok: false, error: 'Укажите токен бота и ID чата.' };
-        }
-        if (!text.trim()) {
-            return { ok: false, error: 'Пустой текст сообщения.' };
-        }
-        return telegramSendMessageViaBot(botToken, chatId, text);
-    }));
-    electron_1.ipcMain.handle('save-file', (event, content, filename) => __awaiter(void 0, void 0, void 0, function* () {
-        const { canceled, filePath } = yield electron_1.dialog.showSaveDialog({
-            defaultPath: filename,
-        });
-        if (canceled || !filePath)
-            return false;
-        fs.writeFileSync(filePath, content);
-        return true;
-    }));
-    electron_1.ipcMain.handle('start-auth', (event, clientId) => __awaiter(void 0, void 0, void 0, function* () {
-        abortPendingGoogleAuth('AUTH_SUPERSEDED');
-        return new Promise((resolve, reject) => {
-            const server = http.createServer((req, res) => __awaiter(void 0, void 0, void 0, function* () {
-                try {
-                    if (!req.url)
-                        return;
-                    const parsedUrl = url.parse(req.url, true);
-                    // Allow any path for flexibility
-                    const query = parsedUrl.query;
-                    if (query.code) {
-                        const address = server.address();
-                        const port = address && typeof address !== 'string' ? address.port : 0;
-                        res.writeHead(200, { 'Content-Type': 'text/html' });
-                        res.end('<h1>Authentication successful!</h1><p>You can close this window and return to the app.</p><script>window.close();</script>');
+            catch (_a) {
+                return {};
+            }
+        };
+        const writeConfig = (config) => {
+            try {
+                fs.writeFileSync(configPath, JSON.stringify(config));
+                broadcastConfigUpdated(config);
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        };
+        const getWorkspaceSnapshots = () => {
+            const config = readConfig();
+            return Array.isArray(config.workspaceSnapshots)
+                ? config.workspaceSnapshots.filter((item) => Boolean(item && typeof item === 'object' && typeof item.id === 'string'))
+                : [];
+        };
+        electron_1.ipcMain.handle('save-config', (event, config) => __awaiter(void 0, void 0, void 0, function* () {
+            return writeConfig(config);
+        }));
+        electron_1.ipcMain.handle('load-config', () => __awaiter(void 0, void 0, void 0, function* () {
+            return readConfig();
+        }));
+        electron_1.ipcMain.handle('load-workspace-snapshot', (_event, workspaceId) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const id = String(workspaceId !== null && workspaceId !== void 0 ? workspaceId : '').trim();
+            if (!id)
+                return null;
+            return (_a = getWorkspaceSnapshots().find(snapshot => snapshot.id === id)) !== null && _a !== void 0 ? _a : null;
+        }));
+        electron_1.ipcMain.handle('save-workspace-snapshot', (_event, snapshot) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const id = String((_a = snapshot === null || snapshot === void 0 ? void 0 : snapshot.id) !== null && _a !== void 0 ? _a : '').trim();
+            if (!id)
+                return { ok: false };
+            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() });
+            const next = [
+                nextSnapshot,
+                ...current.filter((item) => (item === null || item === void 0 ? void 0 : item.id) !== id),
+            ].slice(0, 12);
+            const ok = writeConfig(Object.assign(Object.assign({}, config), { workspaceSnapshots: next }));
+            return { ok };
+        }));
+        electron_1.ipcMain.handle('register-workspace-folder', (event, rawFolderId) => __awaiter(void 0, void 0, void 0, function* () {
+            const webContentsId = event.sender.id;
+            const folderId = String(rawFolderId !== null && rawFolderId !== void 0 ? rawFolderId : '').trim();
+            if (!folderId) {
+                cleanupWindowFolder(webContentsId);
+                return { ok: true };
+            }
+            const currentOwner = folderOwners.get(folderId);
+            if (currentOwner && currentOwner !== webContentsId) {
+                focusWindowByWebContentsId(currentOwner);
+                return {
+                    ok: false,
+                    reason: 'occupied',
+                    folderId,
+                };
+            }
+            cleanupWindowFolder(webContentsId);
+            folderOwners.set(folderId, webContentsId);
+            windowFolders.set(webContentsId, folderId);
+            broadcastWorkspaceWindowsUpdated();
+            return { ok: true };
+        }));
+        electron_1.ipcMain.handle('unregister-workspace-folder', (event, rawFolderId) => __awaiter(void 0, void 0, void 0, function* () {
+            const webContentsId = event.sender.id;
+            const folderId = rawFolderId == null ? null : String(rawFolderId).trim();
+            if (!folderId || windowFolders.get(webContentsId) === folderId) {
+                cleanupWindowFolder(webContentsId);
+            }
+            broadcastWorkspaceWindowsUpdated();
+            return { ok: true };
+        }));
+        electron_1.ipcMain.handle('new-window', (_event, workspaceId) => __awaiter(void 0, void 0, void 0, function* () {
+            createWindow(String(workspaceId !== null && workspaceId !== void 0 ? workspaceId : '').trim() || createWorkspaceId());
+            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;
+            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 folderId = String((_b = payload === null || payload === void 0 ? void 0 : payload.folderId) !== null && _b !== void 0 ? _b : '').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();
+            if (folderPath) {
+                windowFolderPaths.set(webContentsId, folderPath);
+            }
+            else {
+                windowFolderPaths.delete(webContentsId);
+            }
+            broadcastWorkspaceWindowsUpdated();
+            return { ok: true };
+        }));
+        electron_1.ipcMain.handle('list-workspace-windows', () => __awaiter(void 0, void 0, void 0, function* () { return getWorkspaceWindows(); }));
+        electron_1.ipcMain.handle('focus-workspace-window', (_event, webContentsId) => __awaiter(void 0, void 0, void 0, function* () {
+            return ({
+                ok: focusWindowByWebContentsId(Number(webContentsId)),
+            });
+        }));
+        electron_1.ipcMain.handle('close-workspace-window', (_event, webContentsId) => __awaiter(void 0, void 0, void 0, function* () {
+            const id = Number(webContentsId);
+            const win = electron_1.BrowserWindow.getAllWindows().find(w => w.webContents.id === id);
+            if (!win || win.isDestroyed())
+                return { ok: false };
+            const workspaceId = windowWorkspaces.get(id);
+            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 }));
+                }
+            }
+            closingWindowIds.add(id);
+            broadcastWorkspaceWindowsUpdated();
+            win.destroy();
+            setImmediate(() => broadcastWorkspaceWindowsUpdated());
+            return { ok: true };
+        }));
+        electron_1.ipcMain.handle('telegram-send-test', (_event, payload) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a, _b;
+            const botToken = String((_a = payload === null || payload === void 0 ? void 0 : payload.botToken) !== null && _a !== void 0 ? _a : '').trim();
+            const chatId = String((_b = payload === null || payload === void 0 ? void 0 : payload.chatId) !== null && _b !== void 0 ? _b : '').trim();
+            if (!botToken || !chatId) {
+                return { ok: false, error: 'Укажите токен бота и ID чата.' };
+            }
+            return telegramSendMessageViaBot(botToken, chatId, 'Docs Combiner — тест оповещений.');
+        }));
+        electron_1.ipcMain.handle('telegram-send-message', (_event, payload) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const botToken = String((_a = payload === null || payload === void 0 ? void 0 : payload.botToken) !== null && _a !== void 0 ? _a : '').trim();
+            const chatId = String((_b = payload === null || payload === void 0 ? void 0 : payload.chatId) !== null && _b !== void 0 ? _b : '').trim();
+            const text = String((_c = payload === null || payload === void 0 ? void 0 : payload.text) !== null && _c !== void 0 ? _c : '');
+            if (!botToken || !chatId) {
+                return { ok: false, error: 'Укажите токен бота и ID чата.' };
+            }
+            if (!text.trim()) {
+                return { ok: false, error: 'Пустой текст сообщения.' };
+            }
+            return telegramSendMessageViaBot(botToken, chatId, text);
+        }));
+        electron_1.ipcMain.handle('save-file', (event, content, filename) => __awaiter(void 0, void 0, void 0, function* () {
+            const { canceled, filePath } = yield electron_1.dialog.showSaveDialog({
+                defaultPath: filename,
+            });
+            if (canceled || !filePath)
+                return false;
+            fs.writeFileSync(filePath, content);
+            return true;
+        }));
+        electron_1.ipcMain.handle('start-auth', (event, clientId) => __awaiter(void 0, void 0, void 0, function* () {
+            abortPendingGoogleAuth('AUTH_SUPERSEDED');
+            return new Promise((resolve, reject) => {
+                const server = http.createServer((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+                    try {
+                        if (!req.url)
+                            return;
+                        const parsedUrl = url.parse(req.url, true);
+                        // Allow any path for flexibility
+                        const query = parsedUrl.query;
+                        if (query.code) {
+                            const address = server.address();
+                            const port = address && typeof address !== 'string' ? address.port : 0;
+                            res.writeHead(200, { 'Content-Type': 'text/html' });
+                            res.end('<h1>Authentication successful!</h1><p>You can close this window and return to the app.</p><script>window.close();</script>');
+                            pendingGoogleAuth = null;
+                            try {
+                                server.close();
+                            }
+                            catch (_a) {
+                                /* ignore */
+                            }
+                            resolve({ code: query.code, redirectUri: `http://127.0.0.1:${port}` });
+                        }
+                        else if (query.error) {
+                            res.writeHead(400, { 'Content-Type': 'text/html' });
+                            res.end('Authentication failed.');
+                            pendingGoogleAuth = null;
+                            try {
+                                server.close();
+                            }
+                            catch (_b) {
+                                /* ignore */
+                            }
+                            reject(new Error(query.error));
+                        }
+                    }
+                    catch (e) {
                         pendingGoogleAuth = null;
                         try {
                             server.close();
                         }
-                        catch (_a) {
+                        catch (_c) {
                             /* ignore */
                         }
-                        resolve({ code: query.code, redirectUri: `http://127.0.0.1:${port}` });
+                        reject(e instanceof Error ? e : new Error(String(e)));
                     }
-                    else if (query.error) {
-                        res.writeHead(400, { 'Content-Type': 'text/html' });
-                        res.end('Authentication failed.');
+                }));
+                server.on('error', (err) => {
+                    if ((pendingGoogleAuth === null || pendingGoogleAuth === void 0 ? void 0 : pendingGoogleAuth.server) === server) {
                         pendingGoogleAuth = null;
+                    }
+                    reject(err);
+                });
+                server.listen(0, '127.0.0.1', () => {
+                    const address = server.address();
+                    if (!address || typeof address === 'string') {
                         try {
                             server.close();
                         }
-                        catch (_b) {
+                        catch (_a) {
                             /* ignore */
                         }
-                        reject(new Error(query.error));
-                    }
-                }
-                catch (e) {
-                    pendingGoogleAuth = null;
-                    try {
-                        server.close();
-                    }
-                    catch (_c) {
-                        /* ignore */
+                        reject(new Error('Failed to get server port'));
+                        return;
                     }
-                    reject(e instanceof Error ? e : new Error(String(e)));
-                }
-            }));
-            server.on('error', (err) => {
-                if ((pendingGoogleAuth === null || pendingGoogleAuth === void 0 ? void 0 : pendingGoogleAuth.server) === server) {
-                    pendingGoogleAuth = null;
-                }
-                reject(err);
+                    const port = address.port;
+                    const redirectUri = `http://127.0.0.1:${port}`;
+                    // Google Drive Scope: https://www.googleapis.com/auth/drive (Full Access)
+                    // Added prompt=consent to force new refresh token with correct scopes
+                    const authUrl = `https://accounts.google.com/o/oauth2/v2/auth?access_type=offline&scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fdrive&response_type=code&client_id=${clientId}&redirect_uri=${redirectUri}&prompt=consent`;
+                    pendingGoogleAuth = { authUrl, server, resolve, reject };
+                    electron_1.shell.openExternal(authUrl);
+                });
             });
-            server.listen(0, '127.0.0.1', () => {
-                const address = server.address();
-                if (!address || typeof address === 'string') {
+        }));
+        electron_1.ipcMain.handle('reopen-pending-auth-browser', () => __awaiter(void 0, void 0, void 0, function* () {
+            if (!pendingGoogleAuth) {
+                return { ok: false };
+            }
+            yield electron_1.shell.openExternal(pendingGoogleAuth.authUrl);
+            return { ok: true };
+        }));
+        electron_1.ipcMain.handle('cancel-pending-auth', () => __awaiter(void 0, void 0, void 0, function* () {
+            if (!pendingGoogleAuth) {
+                return { ok: false };
+            }
+            abortPendingGoogleAuth('LOGIN_CANCELLED');
+            return { ok: true };
+        }));
+        electron_1.ipcMain.handle('open-external', (event, url) => __awaiter(void 0, void 0, void 0, function* () {
+            yield electron_1.shell.openExternal(url);
+        }));
+        electron_1.ipcMain.handle('log', (event, level, ...args) => __awaiter(void 0, void 0, void 0, function* () {
+            const timestamp = new Date().toISOString();
+            const message = args.map(arg => {
+                if (typeof arg === 'object') {
                     try {
-                        server.close();
+                        return JSON.stringify(arg, null, 2);
                     }
                     catch (_a) {
-                        /* ignore */
+                        return String(arg);
                     }
-                    reject(new Error('Failed to get server port'));
-                    return;
-                }
-                const port = address.port;
-                const redirectUri = `http://127.0.0.1:${port}`;
-                // Google Drive Scope: https://www.googleapis.com/auth/drive (Full Access)
-                // Added prompt=consent to force new refresh token with correct scopes
-                const authUrl = `https://accounts.google.com/o/oauth2/v2/auth?access_type=offline&scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fdrive&response_type=code&client_id=${clientId}&redirect_uri=${redirectUri}&prompt=consent`;
-                pendingGoogleAuth = { authUrl, server, resolve, reject };
-                electron_1.shell.openExternal(authUrl);
-            });
-        });
-    }));
-    electron_1.ipcMain.handle('reopen-pending-auth-browser', () => __awaiter(void 0, void 0, void 0, function* () {
-        if (!pendingGoogleAuth) {
-            return { ok: false };
-        }
-        yield electron_1.shell.openExternal(pendingGoogleAuth.authUrl);
-        return { ok: true };
-    }));
-    electron_1.ipcMain.handle('cancel-pending-auth', () => __awaiter(void 0, void 0, void 0, function* () {
-        if (!pendingGoogleAuth) {
-            return { ok: false };
-        }
-        abortPendingGoogleAuth('LOGIN_CANCELLED');
-        return { ok: true };
-    }));
-    electron_1.ipcMain.handle('open-external', (event, url) => __awaiter(void 0, void 0, void 0, function* () {
-        yield electron_1.shell.openExternal(url);
-    }));
-    electron_1.ipcMain.handle('log', (event, level, ...args) => __awaiter(void 0, void 0, void 0, function* () {
-        const timestamp = new Date().toISOString();
-        const message = args.map(arg => {
-            if (typeof arg === 'object') {
-                try {
-                    return JSON.stringify(arg, null, 2);
-                }
-                catch (_a) {
-                    return String(arg);
                 }
+                return String(arg);
+            }).join(' ');
+            const formattedMessage = `[${timestamp}] ${message}`;
+            switch (level) {
+                case 'log':
+                case 'info':
+                    console.log(formattedMessage);
+                    break;
+                case 'warn':
+                    console.warn(formattedMessage);
+                    break;
+                case 'error':
+                    console.error(formattedMessage);
+                    break;
             }
-            return String(arg);
-        }).join(' ');
-        const formattedMessage = `[${timestamp}] ${message}`;
-        switch (level) {
-            case 'log':
-            case 'info':
-                console.log(formattedMessage);
-                break;
-            case 'warn':
-                console.warn(formattedMessage);
-                break;
-            case 'error':
-                console.error(formattedMessage);
-                break;
+        }));
+        const snapshotsToRestore = getWorkspaceSnapshots();
+        if (snapshotsToRestore.length > 0) {
+            snapshotsToRestore.forEach(snapshot => createWindow(snapshot.id));
         }
-    }));
-    createWindow();
-    electron_1.app.on('activate', function () {
-        if (electron_1.BrowserWindow.getAllWindows().length === 0)
+        else {
             createWindow();
+        }
+        electron_1.app.on('activate', function () {
+            if (electron_1.BrowserWindow.getAllWindows().length === 0) {
+                const snapshot = getWorkspaceSnapshots()[0];
+                createWindow(snapshot === null || snapshot === void 0 ? void 0 : snapshot.id);
+            }
+        });
     });
-});
 electron_1.app.on('window-all-closed', function () {
     electron_1.app.quit();
 });
+electron_1.app.on('before-quit', () => {
+    if (agentApiServer) {
+        agentApiServer.close();
+        agentApiServer = null;
+    }
+});
 process.on('uncaughtException', (err) => {
     console.error('[Main] uncaughtException:', err);
 });