zengate 1.0.0

package/src/opencode/backend.js

@@ -0,0 +1,201 @@
+import { execFile, spawn } from 'node:child_process';
+import net from 'node:net';
+import { createOpencodeClient } from './client.js';
+import { resolveOpencodeBinary, spawnCommand } from './binary.js';
+import { backendEnv, createIsolatedRoot, randomPassword, removeIsolatedRoot, sweepStaleRoots } from './isolation.js';
+
+const START_TIMEOUT_MS = 60000;
+const MAX_RESTART_DELAY_MS = 30000;
+const ANSI = /\x1b\[[0-9;]*m/g;
+
+function freePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.unref();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const { port } = server.address();
+            server.close(() => resolve(port));
+        });
+    });
+}
+
+function killTree(child) {
+    if (!child?.pid || child.exitCode !== null) return;
+    if (process.platform === 'win32') {
+        execFile('taskkill', ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true }, () => {});
+        return;
+    }
+    try { process.kill(-child.pid, 'SIGTERM'); } catch { child.kill('SIGTERM'); }
+    setTimeout(() => {
+        try { process.kill(-child.pid, 'SIGKILL'); } catch { /* already gone */ }
+    }, 3000).unref();
+}
+
+async function waitHealthy(client, deadline, isDead) {
+    let lastError = null;
+    while (Date.now() < deadline) {
+        if (isDead()) throw new Error('OpenCode exited during startup');
+        try {
+            const health = await client.health();
+            if (health?.healthy === true) return health;
+        } catch (error) {
+            lastError = error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    throw new Error(`OpenCode did not become healthy in ${START_TIMEOUT_MS / 1000}s${lastError ? `: ${lastError.message}` : ''}`);
+}
+
+function pipeLogs(stream, logger) {
+    let pending = '';
+    stream.setEncoding('utf8');
+    stream.on('data', (chunk) => {
+        pending += chunk;
+        const lines = pending.split(/\r?\n/);
+        pending = lines.pop();
+        for (const line of lines) {
+            const text = line.replace(ANSI, '').trim();
+            if (text) logger.debug(`[opencode] ${text}`);
+        }
+    });
+}
+
+/**
+ * Starts and supervises a private `opencode serve` bound to 127.0.0.1 on a
+ * free port with a random password. It restarts with backoff if it crashes.
+ */
+export function createManagedBackend({ opencodePath, logger }) {
+    let client = null;
+    let child = null;
+    let dirs = null;
+    let version = null;
+    let stopping = false;
+    let restartDelay = 1000;
+    let ready = false;
+    let everReady = false;
+
+    async function launch() {
+        const binary = resolveOpencodeBinary(opencodePath);
+        dirs = createIsolatedRoot();
+        const port = await freePort();
+        const password = randomPassword();
+        const { command, args, windowsVerbatimArguments } = spawnCommand(binary.path, ['serve', '--hostname', '127.0.0.1', '--port', String(port)]);
+        logger.debug('Starting OpenCode backend', { binary: binary.path, source: binary.source, port });
+        const proc = spawn(command, args, {
+            cwd: dirs.workspace,
+            env: backendEnv(dirs, password),
+            stdio: ['ignore', 'pipe', 'pipe'],
+            detached: process.platform !== 'win32',
+            windowsHide: true,
+            windowsVerbatimArguments,
+        });
+        child = proc;
+        pipeLogs(proc.stdout, logger);
+        pipeLogs(proc.stderr, logger);
+        let dead = false;
+        proc.once('error', (error) => { dead = true; logger.error('Could not start OpenCode', { error: error.message }); });
+        proc.once('exit', (code, signal) => {
+            dead = true;
+            ready = false;
+            if (!stopping && everReady) onCrash(code, signal, dirs.root);
+        });
+        const candidate = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}`, username: 'opencode', password });
+        const health = await waitHealthy(candidate, Date.now() + START_TIMEOUT_MS, () => dead);
+        client = candidate;
+        version = health.version || null;
+        ready = true;
+        everReady = true;
+        restartDelay = 1000;
+        logger.info(`OpenCode ${version || ''} backend ready (managed, isolated, tools disabled)`.replace('  ', ' '));
+    }
+
+    function onCrash(code, signal, root) {
+        // Ctrl+C and service managers signal the whole process group, so OpenCode
+        // can exit just before the gateway starts stopping. Only warn if the
+        // restart actually goes ahead.
+        const reason = signal || code;
+        logger.debug(`OpenCode backend exited (${reason})`);
+        removeIsolatedRoot(root);
+        const delay = restartDelay;
+        restartDelay = Math.min(MAX_RESTART_DELAY_MS, restartDelay * 2);
+        setTimeout(() => {
+            if (stopping) return;
+            logger.warn(`OpenCode backend exited (${reason}); restarting after ${delay / 1000}s`);
+            launch().catch((error) => {
+                logger.error('OpenCode restart failed', { error: error.message });
+                killTree(child);
+            });
+        }, delay).unref();
+    }
+
+    return Object.freeze({
+        mode: 'managed',
+        async start() {
+            const swept = sweepStaleRoots();
+            if (swept) logger.debug(`Removed ${swept} stale backend directories`);
+            try {
+                await launch();
+            } catch (error) {
+                stopping = true;
+                killTree(child);
+                removeIsolatedRoot(dirs?.root);
+                throw error;
+            }
+        },
+        getClient() {
+            if (!client) throw new Error('OpenCode backend is not started');
+            return client;
+        },
+        isReady: () => ready,
+        version: () => version,
+        ownsAllSessions: true,
+        async stop() {
+            stopping = true;
+            ready = false;
+            if (child && child.exitCode === null) {
+                const exited = new Promise((resolve) => child.once('exit', resolve));
+                killTree(child);
+                await Promise.race([exited, new Promise((resolve) => setTimeout(resolve, 5000).unref())]);
+            }
+            removeIsolatedRoot(dirs?.root);
+        },
+    });
+}
+
+/** Uses an OpenCode server someone else runs (OPENCODE_SERVER_URL). */
+export function createAttachedBackend({ url, username, password, logger }) {
+    const client = createOpencodeClient({ baseUrl: url, username, password });
+    let ready = false;
+    let version = null;
+    let timer = null;
+
+    async function probe() {
+        try {
+            const health = await client.health();
+            ready = health?.healthy === true;
+            version = health?.version || version;
+        } catch {
+            ready = false;
+        }
+        return ready;
+    }
+
+    return Object.freeze({
+        mode: 'attached',
+        async start() {
+            if (!(await probe())) throw new Error(`OpenCode server at ${url} is not healthy (GET /global/health). Check the URL and credentials.`);
+            logger.info(`Using OpenCode ${version || ''} at ${url}`.replace('  ', ' '));
+            logger.warn('Attached mode: the gateway rejects tool permissions for its own sessions, but the server\'s own configuration still applies. Prefer the managed backend.');
+            timer = setInterval(probe, 10000);
+            timer.unref();
+        },
+        getClient: () => client,
+        isReady: () => ready,
+        version: () => version,
+        ownsAllSessions: false,
+        async stop() {
+            clearInterval(timer);
+        },
+    });
+}

package/src/opencode/binary.js

@@ -0,0 +1,75 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+function isFile(file) {
+    try {
+        return fs.statSync(file).isFile();
+    } catch {
+        return false;
+    }
+}
+
+/** The binary shipped by the official `opencode-ai` npm package (a dependency). */
+function bundledBinary() {
+    try {
+        const root = path.dirname(require.resolve('opencode-ai/package.json'));
+        const binary = path.join(root, 'bin', 'opencode.exe');
+        return isFile(binary) ? binary : null;
+    } catch {
+        return null;
+    }
+}
+
+function searchPath(names) {
+    for (const dir of (process.env.PATH || process.env.Path || '').split(path.delimiter).filter(Boolean)) {
+        for (const name of names) {
+            const candidate = path.join(dir, name);
+            if (isFile(candidate)) return candidate;
+        }
+    }
+    return null;
+}
+
+/**
+ * Locate the OpenCode CLI: explicit OPENCODE_PATH, then the bundled
+ * `opencode-ai` package, then PATH. Never guesses other directories.
+ * @param {string} configured OPENCODE_PATH ('' for automatic)
+ * @returns {{ path: string, source: 'config'|'bundled'|'PATH' }}
+ */
+export function resolveOpencodeBinary(configured) {
+    const windowsNames = ['opencode.exe', 'opencode.cmd', 'opencode.bat', 'opencode'];
+    if (configured) {
+        const looksLikePath = configured.includes('/') || configured.includes('\\');
+        if (looksLikePath) {
+            const full = path.resolve(configured);
+            if (isFile(full)) return { path: full, source: 'config' };
+            throw new Error(`OPENCODE_PATH does not point to a file: ${full}`);
+        }
+        const names = process.platform === 'win32' ? windowsNames.map((n) => n.replace('opencode', configured)) : [configured];
+        const found = searchPath(names);
+        if (found) return { path: found, source: 'config' };
+        throw new Error(`OPENCODE_PATH '${configured}' was not found on PATH`);
+    }
+    const bundled = bundledBinary();
+    if (bundled) return { path: bundled, source: 'bundled' };
+    const found = searchPath(process.platform === 'win32' ? windowsNames : ['opencode']);
+    if (found) return { path: found, source: 'PATH' };
+    throw new Error('OpenCode CLI not found. Run `npm ci` (it installs the bundled opencode-ai package) or set OPENCODE_PATH.');
+}
+
+/**
+ * Build spawn arguments. Windows .cmd/.bat shims need cmd.exe; the command
+ * line is fully quoted and every argument is gateway-controlled.
+ */
+export function spawnCommand(binary, args) {
+    const lower = binary.toLowerCase();
+    if (process.platform === 'win32' && (lower.endsWith('.cmd') || lower.endsWith('.bat'))) {
+        if (/["\r\n%]/.test(binary)) throw new Error('OPENCODE_PATH contains characters that cannot be run safely');
+        const line = [`"${binary}"`, ...args.map((arg) => `"${arg}"`)].join(' ');
+        return { command: process.env.ComSpec || 'cmd.exe', args: ['/d', '/s', '/c', `"${line}"`], windowsVerbatimArguments: true };
+    }
+    return { command: binary, args, windowsVerbatimArguments: false };
+}

package/src/opencode/catalog.js

@@ -0,0 +1,83 @@
+import { ApiError } from '../server/errors.js';
+
+const CACHE_MS = 60000;
+const MODALITIES = ['text', 'image', 'audio', 'video', 'pdf'];
+
+/**
+ * Model catalog read from the backend's /config/providers. Models from the
+ * built-in `opencode` provider (keyless Zen) are exposed by their bare id;
+ * any other provider the backend knows about is exposed as `provider/model`.
+ */
+export function createCatalog({ getClient, logger }) {
+    let cache = null;
+    let cachedAt = 0;
+    let inflight = null;
+
+    async function refresh() {
+        const payload = await getClient().providers();
+        const models = [];
+        for (const provider of Array.isArray(payload?.providers) ? payload.providers : []) {
+            for (const [key, raw] of Object.entries(provider?.models || {})) {
+                const model = normalizeModel(provider.id, key, raw);
+                if (model) models.push(model);
+            }
+        }
+        models.sort((a, b) => a.id.localeCompare(b.id));
+        cache = { list: models, byId: new Map(models.map((model) => [model.id, model])) };
+        cachedAt = Date.now();
+        return cache;
+    }
+
+    async function load() {
+        if (cache && Date.now() - cachedAt < CACHE_MS) return cache;
+        inflight ??= refresh().finally(() => { inflight = null; });
+        try {
+            return await inflight;
+        } catch (error) {
+            if (cache) {
+                logger.warn('Model catalog refresh failed; serving the cached list', { error: error.message });
+                return cache;
+            }
+            throw new ApiError(503, 'The OpenCode backend is not ready yet; retry in a few seconds.', { code: 'backend_unavailable', retryAfter: 2 });
+        }
+    }
+
+    return Object.freeze({
+        list: async () => (await load()).list,
+        /** Resolve a client model id (bare, `opencode/`-prefixed, or provider/model). */
+        async resolve(requested) {
+            const { byId, list } = await load();
+            const id = String(requested || '').trim();
+            const model = byId.get(id) || byId.get(id.replace(/^opencode\//, ''));
+            if (model) return model;
+            const hint = list.slice(0, 12).map((m) => m.id).join(', ');
+            throw new ApiError(404, `The model '${id}' does not exist or is not available keylessly. Available: ${hint}${list.length > 12 ? ', ...' : ''} (see GET /v1/models).`, { param: 'model', code: 'model_not_found' });
+        },
+        invalidate() { cachedAt = 0; },
+    });
+}
+
+function normalizeModel(providerId, key, raw) {
+    if (!raw || typeof raw !== 'object' || !providerId) return null;
+    const modelId = String(raw.id || key);
+    if (raw.status === 'deprecated') return null;
+    const input = raw.capabilities?.input || {};
+    const created = Date.parse(raw.release_date || '');
+    return Object.freeze({
+        id: providerId === 'opencode' ? modelId : `${providerId}/${modelId}`,
+        providerID: providerId,
+        modelID: modelId,
+        name: raw.name || modelId,
+        created: Number.isFinite(created) ? Math.floor(created / 1000) : 0,
+        input: Object.freeze(MODALITIES.filter((kind) => input[kind] === true || (kind === 'text' && input.text !== false))),
+        reasoning: raw.capabilities?.reasoning === true,
+        variants: Object.freeze(Object.keys(raw.variants || {})),
+        contextWindow: raw.limit?.context ?? null,
+        maxOutputTokens: raw.limit?.output ?? null,
+    });
+}
+
+/** The public OpenAI model object. */
+export function toOpenAIModel(model) {
+    return { id: model.id, object: 'model', created: model.created, owned_by: model.providerID };
+}

package/src/opencode/client.js

@@ -0,0 +1,84 @@
+/**
+ * Thin client for the documented `opencode serve` HTTP API
+ * (https://opencode.ai/docs/server/). Plain fetch keeps connections pooled
+ * and avoids coupling the gateway to a specific SDK major version.
+ */
+export class BackendError extends Error {
+    constructor(message, { status = 0, body = null, cause } = {}) {
+        super(message, cause ? { cause } : undefined);
+        this.name = 'BackendError';
+        this.status = status;
+        this.body = body;
+    }
+}
+
+const DEFAULT_TIMEOUT_MS = 30000;
+
+export function basicAuthHeader(username, password) {
+    if (!password) return null;
+    return `Basic ${Buffer.from(`${username || 'opencode'}:${password}`).toString('base64')}`;
+}
+
+/**
+ * @param {{ baseUrl: string, username?: string, password?: string, fetchImpl?: typeof fetch }} options
+ */
+export function createOpencodeClient({ baseUrl, username, password, fetchImpl = fetch }) {
+    const base = String(baseUrl).replace(/\/+$/, '');
+    const auth = basicAuthHeader(username, password);
+    const headers = (extra) => ({ accept: 'application/json', ...(auth ? { authorization: auth } : {}), ...extra });
+
+    async function request(method, path, { body, signal, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+        const timeout = timeoutMs > 0 ? AbortSignal.timeout(timeoutMs) : null;
+        const combined = [signal, timeout].filter(Boolean);
+        let response;
+        try {
+            response = await fetchImpl(`${base}${path}`, {
+                method,
+                redirect: 'error',
+                headers: headers(body === undefined ? {} : { 'content-type': 'application/json' }),
+                body: body === undefined ? undefined : JSON.stringify(body),
+                signal: combined.length > 1 ? AbortSignal.any(combined) : combined[0],
+            });
+        } catch (error) {
+            if (error?.name === 'AbortError' || error?.name === 'TimeoutError') throw error;
+            throw new BackendError(`OpenCode backend unreachable at ${base}: ${error?.cause?.code || error?.message}`, { cause: error });
+        }
+        const text = await response.text();
+        let parsed = null;
+        if (text) {
+            try { parsed = JSON.parse(text); } catch { parsed = text; }
+        }
+        if (!response.ok) {
+            throw new BackendError(`OpenCode ${method} ${path} failed with HTTP ${response.status}`, { status: response.status, body: parsed });
+        }
+        return parsed;
+    }
+
+    const id = (value) => encodeURIComponent(value);
+
+    return Object.freeze({
+        baseUrl: base,
+        health: (options) => request('GET', '/global/health', { timeoutMs: 3000, ...options }),
+        providers: (options) => request('GET', '/config/providers', options),
+        agents: (options) => request('GET', '/agent', options),
+        createSession: (options) => request('POST', '/session', { body: { title: 'openai-gateway' }, ...options }),
+        deleteSession: (sessionId, options) => request('DELETE', `/session/${id(sessionId)}`, options),
+        abortSession: (sessionId, options) => request('POST', `/session/${id(sessionId)}/abort`, { timeoutMs: 5000, ...options }),
+        messages: (sessionId, options) => request('GET', `/session/${id(sessionId)}/message`, options),
+        /** Blocks until the assistant turn finishes; returns { info, parts }. */
+        prompt: (sessionId, body, options) => request('POST', `/session/${id(sessionId)}/message`, { body, timeoutMs: 0, ...options }),
+        replyPermission: (requestId, reply, message) =>
+            request('POST', `/permission/${id(requestId)}/reply`, { body: { reply, ...(message ? { message } : {}) }, timeoutMs: 5000 }),
+        rejectQuestion: (requestId) => request('POST', `/question/${id(requestId)}/reject`, { body: {}, timeoutMs: 5000 }),
+        pendingPermissions: () => request('GET', '/permission', { timeoutMs: 5000 }),
+        pendingQuestions: () => request('GET', '/question', { timeoutMs: 5000 }),
+        /** Opens the server-sent event stream; caller consumes response.body. */
+        async openEvents(signal) {
+            const response = await fetchImpl(`${base}/event`, { headers: headers({ accept: 'text/event-stream' }), signal, redirect: 'error' });
+            if (!response.ok || !response.body) {
+                throw new BackendError(`OpenCode event stream failed with HTTP ${response.status}`, { status: response.status });
+            }
+            return response;
+        },
+    });
+}

package/src/opencode/events.js

@@ -0,0 +1,168 @@
+import { readSseFrames } from './sse-reader.js';
+
+/**
+ * Sent back to the model whenever it tries to use an OpenCode tool. OpenCode
+ * lets the turn continue with this feedback, so the model answers directly.
+ */
+export const TOOL_REJECTION_MESSAGE = 'OpenCode tools are disabled by this gateway. Do not call OpenCode tools; answer directly. '
+    + 'If the user supplied their own functions, use the function-call format described in the system instructions.';
+
+const MAX_BACKOFF_MS = 5000;
+
+async function* readChunks(reader) {
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done) return;
+        yield value;
+    }
+}
+
+/**
+ * One shared subscription to the backend's /event stream, fanned out to
+ * per-session listeners. It also enforces the gateway's security policy:
+ * every OpenCode tool permission request and question from a gateway session
+ * is rejected, so no command, file edit or fetch ever runs on the host.
+ *
+ * @param {{ getClient: () => ReturnType<import('./client.js').createOpencodeClient>, logger: any, ownsAllSessions: boolean }} options
+ */
+export function createEventHub({ getClient, logger, ownsAllSessions }) {
+    const listeners = new Map();
+    const owned = new Set();
+    const children = new Map();
+    let connected = false;
+    let stopped = false;
+    let controller = null;
+    let connectedWaiters = [];
+    let loop = null;
+
+    const isOurs = (sessionId) => ownsAllSessions || owned.has(sessionId);
+
+    function setConnected(value) {
+        connected = value;
+        if (value) {
+            connectedWaiters.forEach((resolve) => resolve(true));
+            connectedWaiters = [];
+        }
+    }
+
+    async function rejectPermission(id, sessionId) {
+        try {
+            await getClient().replyPermission(id, 'reject', TOOL_REJECTION_MESSAGE);
+            logger.debug('Rejected OpenCode tool permission', { sessionId });
+        } catch (error) {
+            logger.warn('Failed to reject an OpenCode tool permission', { sessionId, error: error.message });
+        }
+    }
+
+    async function rejectQuestion(id, sessionId) {
+        try {
+            await getClient().rejectQuestion(id);
+        } catch (error) {
+            logger.warn('Failed to reject an OpenCode question', { sessionId, error: error.message });
+        }
+    }
+
+    /** Sessions spawned by an owned session (e.g. subagents) are owned too. */
+    function adoptChild(info) {
+        if (!info?.id || !info.parentID || !owned.has(info.parentID) || owned.has(info.id)) return;
+        owned.add(info.id);
+        children.set(info.parentID, [...(children.get(info.parentID) || []), info.id]);
+    }
+
+    function dispatch(event) {
+        const props = event?.properties || {};
+        if (event.type === 'session.created' || event.type === 'session.updated') adoptChild(props.info);
+        const sessionId = props.sessionID || props.info?.sessionID || props.part?.sessionID;
+        if (event.type === 'permission.asked' && isOurs(sessionId)) void rejectPermission(props.id, sessionId);
+        else if (event.type === 'question.asked' && isOurs(sessionId)) void rejectQuestion(props.id, sessionId);
+        const set = sessionId ? listeners.get(sessionId) : null;
+        if (!set) return;
+        for (const listener of set) {
+            try { listener(event); } catch (error) { logger.error('Event listener failed', { error: error.message }); }
+        }
+    }
+
+    /** Catch permission requests raised while the stream was down. */
+    async function sweepPending() {
+        const client = getClient();
+        for (const [list, reject] of [[client.pendingPermissions, rejectPermission], [client.pendingQuestions, rejectQuestion]]) {
+            try {
+                const pending = await list();
+                for (const item of Array.isArray(pending) ? pending : []) {
+                    if (item?.id && isOurs(item.sessionID)) await reject(item.id, item.sessionID);
+                }
+            } catch (error) {
+                logger.debug('Pending request sweep failed', { error: error.message });
+            }
+        }
+    }
+
+    async function runLoop() {
+        let backoff = 250;
+        while (!stopped) {
+            controller = new AbortController();
+            try {
+                const response = await getClient().openEvents(controller.signal);
+                // fetch() can drop its abort link once its Request is garbage
+                // collected, so stop() also cancels the body directly.
+                const reader = response.body.getReader();
+                controller.signal.addEventListener('abort', () => { reader.cancel().catch(() => {}); }, { once: true });
+                setConnected(true);
+                backoff = 250;
+                void sweepPending();
+                for await (const frame of readSseFrames(readChunks(reader))) {
+                    let event;
+                    try { event = JSON.parse(frame.data); } catch { continue; }
+                    if (event && typeof event.type === 'string') dispatch(event);
+                }
+                if (!stopped) logger.warn('OpenCode event stream ended; reconnecting');
+            } catch (error) {
+                if (!stopped) logger.debug('OpenCode event stream unavailable', { error: error.message });
+            }
+            setConnected(false);
+            if (stopped) break;
+            await new Promise((resolve) => setTimeout(resolve, backoff).unref());
+            backoff = Math.min(MAX_BACKOFF_MS, backoff * 2);
+        }
+    }
+
+    return Object.freeze({
+        start() {
+            if (!loop) loop = runLoop();
+        },
+        /** Register a listener for one session; returns an unsubscribe function. */
+        subscribe(sessionId, listener) {
+            owned.add(sessionId);
+            const set = listeners.get(sessionId) || new Set();
+            set.add(listener);
+            listeners.set(sessionId, set);
+            return () => {
+                set.delete(listener);
+                if (set.size === 0) listeners.delete(sessionId);
+            };
+        },
+        release(sessionId) {
+            for (const child of children.get(sessionId) || []) owned.delete(child);
+            children.delete(sessionId);
+            owned.delete(sessionId);
+            listeners.delete(sessionId);
+        },
+        isConnected: () => connected,
+        waitConnected(timeoutMs) {
+            if (connected) return Promise.resolve(true);
+            return new Promise((resolve) => {
+                const timer = setTimeout(() => {
+                    connectedWaiters = connectedWaiters.filter((fn) => fn !== done);
+                    resolve(false);
+                }, timeoutMs);
+                const done = (value) => { clearTimeout(timer); resolve(value); };
+                connectedWaiters.push(done);
+            });
+        },
+        async stop() {
+            stopped = true;
+            controller?.abort();
+            await loop?.catch(() => {});
+        },
+    });
+}