larkin 0.2.70

package/dist/app/session-cli.mjs

@@ -0,0 +1,83 @@
+import { loadConfig } from "../platform/config.mjs";
+import { requestSessionReset } from "./local-control.mjs";
+function parseResetArguments(args) {
+    if (args[0] !== "reset")
+        throw new Error("unsupported session subcommand");
+    const values = new Map();
+    let json = false;
+    for (let index = 1; index < args.length; index += 1) {
+        const token = args[index];
+        if (token === "--json") {
+            if (json)
+                throw new Error("duplicate flag: --json");
+            json = true;
+            continue;
+        }
+        if (!["--agent", "--wait-ready"].includes(token)) {
+            throw new Error(token.startsWith("-") ? `unknown flag: ${token}` : `unexpected positional: ${token}`);
+        }
+        if (values.has(token))
+            throw new Error(`duplicate flag: ${token}`);
+        const value = args[index + 1];
+        if (!value || value.startsWith("-"))
+            throw new Error(`missing value: ${token}`);
+        values.set(token, value);
+        index += 1;
+    }
+    if (!json)
+        throw new Error("--json is required");
+    const agentId = values.get("--agent");
+    if (!agentId || !/^cli_[A-Za-z0-9]+$/.test(agentId))
+        throw new Error("--agent requires an exact App ID");
+    const waitSeconds = Number(values.get("--wait-ready") ?? "30");
+    if (!Number.isFinite(waitSeconds) || waitSeconds < 0 || waitSeconds > 300)
+        throw new Error("--wait-ready must be 0..300 seconds");
+    return { agentId, waitReadyMs: Math.round(waitSeconds * 1000) };
+}
+export async function runSessionCli(args, env = process.env, dependencies = {}) {
+    const io = dependencies.io ?? { stdout: (value) => process.stdout.write(value), stderr: (value) => process.stderr.write(value) };
+    const fail = (code, message, agentId = "invalid") => {
+        io.stdout(`${JSON.stringify({ ok: false, agent_id: agentId, code, error: message }, null, 2)}\n`);
+        return 1;
+    };
+    let parsed;
+    try {
+        parsed = parseResetArguments(args);
+    }
+    catch (error) {
+        return fail("invalid_arguments", error instanceof Error ? error.message : String(error));
+    }
+    const agentId = parsed.agentId;
+    if (typeof env.LARKIN_AGENT_ID === "string" && env.LARKIN_AGENT_ID.trim()) {
+        return fail("user_authority_required", "session reset is available only from a user terminal", agentId);
+    }
+    try {
+        const loaded = loadConfig(env);
+        const result = await (dependencies.request ?? requestSessionReset)({
+            larkinHome: loaded.config.larkinHome, agentId, waitReadyMs: parsed.waitReadyMs,
+        });
+        const output = {
+            ok: result.ok, agent_id: result.agentId,
+            reset_committed: result.resetCommitted, generation_changed: result.generationChanged,
+            session_changed: result.sessionChanged, turns: result.turns, runtime_ready: result.runtimeReady,
+            channel_connected: result.channelConnected, reconnecting: result.reconnecting,
+            pending_count: result.pendingCount, ready_for_fresh_scenario: result.readyForFreshScenario,
+            inbound_observed: result.inboundObserved, ...(result.code ? { code: result.code } : {}),
+            ...(result.error ? { error: result.error } : {}), ...(result.readiness ? { readiness: result.readiness } : {}),
+        };
+        io.stdout(`${JSON.stringify(output, null, 2)}\n`);
+        return result.ok ? 0 : 1;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const output = {
+            ok: false, agent_id: agentId,
+            code: /timeout/i.test(message) ? "control_timeout" : "control_unavailable", error: message,
+        };
+        io.stdout(`${JSON.stringify(output, null, 2)}\n`);
+        return 1;
+    }
+}
+export async function main(args = process.argv.slice(2), env = process.env) {
+    process.exitCode = await runSessionCli(args, env);
+}

package/dist/app/setup-dashboard.mjs

@@ -0,0 +1,26 @@
+import { spawnSync } from "node:child_process";
+import { readProcessState } from "../platform/process-state.mjs";
+export async function waitForOwnedDashboard(configDir, { timeoutMs = 15_000, pollMs = 100, readDashboard = (root) => readProcessState(root).dashboard, } = {}) {
+    const deadline = Date.now() + timeoutMs;
+    do {
+        const state = readDashboard(configDir);
+        if (state.state === "owned" && typeof state.url === "string" && state.url) {
+            return { state: "owned", url: state.url };
+        }
+        if (Date.now() >= deadline)
+            break;
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+    } while (true);
+    return { state: "timeout" };
+}
+export function openBrowser(url) {
+    const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+    return spawnSync(command, args, { stdio: "ignore" }).status === 0;
+}
+export async function openOwnedDashboardWhenReady(configDir, { opener = openBrowser, ...readinessOptions } = {}) {
+    const readiness = await waitForOwnedDashboard(configDir, readinessOptions);
+    if (readiness.state !== "owned" || !readiness.url)
+        return { readiness, opened: false };
+    return { readiness, opened: opener(readiness.url) };
+}

package/dist/app/setup.mjs

@@ -0,0 +1,166 @@
+#!/usr/bin/env bun
+import "../platform/check-bun-version.cjs";
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import * as larkinConfig from "../platform/config.mjs";
+import { acquireProcessLock, readProcessState } from "../platform/process-state.mjs";
+import { requestAgentUpsert } from "./local-control.mjs";
+import { openOwnedDashboardWhenReady } from "./setup-dashboard.mjs";
+import { probeNativeRuntimeReadiness } from "../runtime/runtime-readiness.mjs";
+import { internalCommandSpec, processCommandToken } from "./internal-command.mjs";
+import { ensureOfficialLarkCliForSetup, } from "./official-lark-cli.mjs";
+const CFG_DIR = process.env.LARKIN_CONFIG_DIR || path.join(os.homedir(), ".larkin");
+const argv = process.argv.slice(2);
+const has = (name) => argv.includes(name);
+const flag = (name) => { const index = argv.indexOf(name); return index >= 0 ? argv[index + 1] : undefined; };
+const say = (...args) => console.log(...args);
+const die = (message) => { console.error(`✗ ${message}`); process.exit(1); };
+if (argv.some((arg) => arg === "--app-id" || arg.startsWith("--app-id="))) {
+    die("setup 不支持 --app-id；请运行 larkin setup 并在飞书网页中选择机器人");
+}
+if (argv.some((arg) => arg === "--no-dashboard" || arg.startsWith("--no-dashboard="))) {
+    die("--no-dashboard 已移除；dashboard 由 larkin start 统一管理");
+}
+if (has("--start") && has("--no-start"))
+    die("--start 与 --no-start 不能同时使用");
+const commentSubscription = flag("--comment-subscription") || null;
+if (has("--comment-subscription") && !commentSubscription)
+    die("--comment-subscription 缺少参数值");
+if (commentSubscription && !["none", "application"].includes(commentSubscription)) {
+    die("--comment-subscription 只支持 none 或 application");
+}
+const OPT = { runtime: flag("--runtime") || null, commentSubscription, start: !has("--no-start"), help: has("--help") || has("-h") };
+if (OPT.help) {
+    say(`larkin setup — Create or connect a Feishu bot, then configure and attach its Agent
+
+Usage:
+  larkin setup                         Select a bot in the browser and run setup
+
+Options:
+  --runtime <runtime>                   Select the Agent runtime
+  --comment-subscription <mode>         none (safe default) or application
+  --no-start                           Configure the Agent without starting or attaching it
+
+setup handles browser authorization, permission grants, credential storage, Agent configuration,
+and target-only hot attach. Each Agent is identified by its bot App ID: selecting the same bot reuses
+its existing Agent, memory, and state; creating a new bot creates a new Agent.
+
+If larkin is running, only the selected Agent is added or updated. Otherwise setup starts the same
+daemon + dashboard supervisor used by larkin start.`);
+    process.exit(0);
+}
+function runForeground(mode, args) {
+    return new Promise((resolve, reject) => {
+        const childSpec = internalCommandSpec(mode, args);
+        const child = spawn(childSpec.command, childSpec.args, { env: process.env, stdio: "inherit" });
+        const forward = (signal) => { if (child.exitCode === null && child.signalCode === null)
+            child.kill(signal); };
+        const onInt = () => forward("SIGINT");
+        const onTerm = () => forward("SIGTERM");
+        process.on("SIGINT", onInt);
+        process.on("SIGTERM", onTerm);
+        const cleanup = () => { process.off("SIGINT", onInt); process.off("SIGTERM", onTerm); };
+        child.once("error", (error) => { cleanup(); reject(error); });
+        child.once("exit", (code, signal) => { cleanup(); resolve({ code, signal }); });
+    });
+}
+async function openOwnedDashboard() {
+    const result = await openOwnedDashboardWhenReady(CFG_DIR);
+    if (result.readiness.state !== "owned" || !result.readiness.url) {
+        say("! dashboard 尚未在等待期限内就绪；稍后可运行 larkin status 查看 URL");
+        return;
+    }
+    say(`✓ dashboard：${result.readiness.url}`);
+    if (!result.opened)
+        say(`! 未能自动打开浏览器，请手动打开 ${result.readiness.url}`);
+}
+export async function main() {
+    const mutationLock = acquireProcessLock(path.join(CFG_DIR, "setup.lock.json"), processCommandToken("setup", "app/setup.mjs"));
+    const releaseMutationLock = mutationLock.release;
+    process.on("exit", releaseMutationLock);
+    const official = await ensureOfficialLarkCliForSetup({
+        env: process.env,
+        interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+        async confirmInstall(command) {
+            say("[setup 0/5] Larkin 需要未修改的官方 lark-cli 作为 Feishu 命令下游。");
+            say(`将执行：${command}`);
+            const input = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const answer = (await input.question("是否安装？[y/N] ")).trim().toLowerCase();
+            input.close();
+            return answer === "y" || answer === "yes";
+        },
+    }).catch((error) => die(error instanceof Error ? error.message : String(error)));
+    say(`[setup 0/5] ✓ 官方 lark-cli ${official.command.version}: ${official.command.command}${official.installed ? "（刚刚安装）" : ""}`);
+    say("\nAgent 与飞书机器人按 App ID 一一对应：");
+    say("  • 网页选择同一个机器人 → 热更新该 Agent，不重启其他 Agent");
+    say("  • 网页创建新机器人 → 热挂载新 Agent，状态彼此独立\n");
+    fs.mkdirSync(CFG_DIR, { recursive: true, mode: 0o700 });
+    const resultFile = path.join(CFG_DIR, `.setup-result-${process.pid}.json`);
+    const registerArgs = ["--auto", "--result-file", resultFile];
+    if (OPT.runtime)
+        registerArgs.push("--runtime", OPT.runtime);
+    if (OPT.commentSubscription)
+        registerArgs.push("--comment-subscription", OPT.commentSubscription);
+    const result = await runForeground("bot-register", registerArgs);
+    if (result.code !== 0)
+        die("机器人授权或 Agent 配置未完成");
+    let agentId;
+    try {
+        ({ agentId } = JSON.parse(fs.readFileSync(resultFile, "utf8")));
+    }
+    finally {
+        try {
+            fs.unlinkSync(resultFile);
+        }
+        catch { /* best effort */ }
+    }
+    if (!agentId)
+        die("setup 完成但没有取得 Agent ID");
+    const selectedAgentId = agentId;
+    const { config: configured } = larkinConfig.loadConfig(process.env);
+    const configuredAgent = configured.agents[selectedAgentId];
+    if (!configuredAgent)
+        die(`setup 完成但 Agent ${selectedAgentId} 配置不可读`);
+    if (!["codex", "claude", "pi"].includes(configuredAgent.runtime))
+        die(`Runtime ${configuredAgent.runtime} 不受支持`);
+    const runtimeReadiness = await probeNativeRuntimeReadiness({ runtime: configuredAgent.runtime,
+        agentId: selectedAgentId, cwd: configuredAgent.workspaceDir,
+        env: { ...process.env, LARKIN_CONFIG_DIR: CFG_DIR,
+            ...(configuredAgent.piDistribution ? { LARKIN_PI_DISTRIBUTION: configuredAgent.piDistribution } : {}) } });
+    if (runtimeReadiness.state !== "ready") {
+        die(`Runtime ${configuredAgent.runtime} ${runtimeReadiness.state}：${runtimeReadiness.reason || "prerequisite unavailable"}；${runtimeReadiness.nextAction || "修复后重试"}`);
+    }
+    if (!OPT.start) {
+        say(`\n[setup 5/5] ✓ 配置完成。运行 larkin start 启动。`);
+        releaseMutationLock();
+        return;
+    }
+    const state = readProcessState(CFG_DIR);
+    if (state.daemon.state === "unknown" || state.supervisor.state === "unknown") {
+        throw new Error("现有 Larkin 进程身份无法确认；拒绝热挂载或并行启动");
+    }
+    if (state.daemon.state === "owned") {
+        say(`\n[setup 5/5] 正在向 daemon PID ${state.daemon.pid} 热挂载 Agent ${agentId}…`);
+        const response = await requestAgentUpsert({ larkinHome: CFG_DIR, agentId: selectedAgentId });
+        if (!response.ok)
+            die(`Agent ${agentId} 热挂载失败：${response.error || "unknown error"}`);
+        releaseMutationLock();
+        say(`[setup 5/5] ✓ Agent ${agentId} 已热挂载/更新；其他 Agent、session、连接和任务未重启`);
+        await openOwnedDashboard();
+        return;
+    }
+    say(`\n[setup 5/5] 正在通过统一 supervisor 启动 daemon + dashboard（Agent ${agentId}）…`);
+    releaseMutationLock();
+    void openOwnedDashboard().catch((error) => say(`! dashboard 自动打开失败：${error instanceof Error ? error.message : String(error)}`));
+    const started = await runForeground("run", []);
+    if (started.code !== 0 && started.signal !== "SIGINT" && started.signal !== "SIGTERM") {
+        die(`Larkin 启动失败（exit=${started.code ?? started.signal}），请运行 larkin status 查看详情`);
+    }
+}
+if (path.resolve(process.argv[1] || "") === path.resolve(fileURLToPath(import.meta.url))) {
+    main().catch((error) => { console.error(`✗ ${error instanceof Error ? error.message : String(error)}`); process.exit(1); });
+}

package/dist/app/telemetry.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env bun
+import path from "node:path";
+import { loadTelemetryConfig, safeEndpointLabel, validateOtlpEndpoint } from "../platform/telemetry-config.mjs";
+import { TelemetrySpool } from "../platform/telemetry-spool.mjs";
+import { flushTelemetry } from "../platform/telemetry-uploader.mjs";
+function option(argv, name) {
+    const index = argv.indexOf(name);
+    if (index < 0)
+        return undefined;
+    const value = argv[index + 1];
+    if (!value || value.startsWith("--"))
+        throw new Error(`${name} requires a value`);
+    return value;
+}
+function headers(argv) {
+    const output = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        if (argv[index] !== "--header")
+            continue;
+        const value = argv[++index];
+        const separator = value?.indexOf("=") ?? -1;
+        if (!value || separator <= 0 || /[\r\n]/.test(value))
+            throw new Error("--header must use name=value");
+        output[value.slice(0, separator)] = value.slice(separator + 1);
+    }
+    return output;
+}
+const print = (value) => { process.stdout.write(`${JSON.stringify(value, null, 2)}\n`); };
+async function run(argv, env) {
+    const [operation = "status"] = argv;
+    const config = loadTelemetryConfig(env);
+    const spool = new TelemetrySpool(config);
+    if (operation === "status") {
+        print({ endpoint: safeEndpointLabel(config.endpoint), autoUpload: Boolean(config.endpoint), ...spool.status() });
+        return;
+    }
+    if (operation === "export") {
+        const destination = path.resolve(option(argv, "--output") || `larkin-telemetry-${Date.now()}.json.gz`);
+        const result = spool.exportBundle(destination);
+        print({ operation, output: path.basename(destination), ...result, sourceQueueRetained: true });
+        return;
+    }
+    if (operation === "import") {
+        const source = option(argv, "--input") || argv[1];
+        if (!source)
+            throw new Error("telemetry import requires --input <bundle>");
+        print({ operation, ...spool.importBundle(path.resolve(source)) });
+        return;
+    }
+    if (operation === "flush") {
+        const endpoint = option(argv, "--endpoint") ? validateOtlpEndpoint(option(argv, "--endpoint")) : config.endpoint;
+        if (!endpoint)
+            throw new Error("telemetry flush requires --endpoint or LARKIN_TELEMETRY_OTLP_ENDPOINT");
+        const result = await flushTelemetry(spool, { endpoint, headers: { ...config.headers, ...headers(argv) }, timeoutMs: config.requestTimeoutMs });
+        print({ operation, endpoint: safeEndpointLabel(endpoint), ...result, ...spool.status() });
+        if (result.status === "retained")
+            process.exitCode = 1;
+        return;
+    }
+    if (operation === "help" || operation === "--help" || operation === "-h") {
+        process.stdout.write(`Usage:
+  larkin telemetry status
+  larkin telemetry export --output <bundle.json.gz>
+  larkin telemetry import --input <bundle.json.gz>
+  larkin telemetry flush [--endpoint <http(s)://host:port/v1/traces>] [--header name=value]\n`);
+        return;
+    }
+    throw new Error("unknown telemetry operation");
+}
+export async function main(argv = process.argv.slice(2), env = process.env) {
+    try {
+        await run(argv, env);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "telemetry operation failed";
+        if (/^(?:unknown telemetry operation|telemetry (?:import|flush) requires|--(?:input|output|endpoint|header) |OTLP (?:endpoint|header))/.test(message))
+            throw new Error(message);
+        throw new Error("telemetry operation failed");
+    }
+}
+if (path.resolve(process.argv[1] || "") === path.resolve(import.meta.filename)) {
+    main().catch((error) => { process.stderr.write(`larkin telemetry: ${error instanceof Error ? error.message : String(error)}\n`); process.exitCode = 1; });
+}

package/dist/dashboard/dashboard-assets.mjs

@@ -0,0 +1,21 @@
+import fs from "node:fs";
+import path from "node:path";
+const MIME_TYPES = {
+    "larkin-mark.svg": "image/svg+xml",
+    "dashboard.css": "text/css; charset=utf-8",
+    "dashboard.js": "text/javascript; charset=utf-8",
+};
+export function dashboardAsset(name, root) {
+    const embedded = globalThis.__LARKIN_EMBEDDED_DASHBOARD_ASSETS__?.[name];
+    if (embedded)
+        return { body: embedded, contentType: MIME_TYPES[name], embedded: true };
+    const file = name === "larkin-mark.svg"
+        ? path.join(root, "assets", name)
+        : path.join(root, "dist", "dashboard", "web", "assets", name);
+    try {
+        return { body: fs.readFileSync(file), contentType: MIME_TYPES[name], embedded: false };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/dashboard/dashboard-avatar.mjs

@@ -0,0 +1,128 @@
+import crypto from "node:crypto";
+const MAX_AVATAR_BYTES = 2_000_000;
+const DEFAULT_TTL_MS = 5 * 60 * 1_000;
+const ALLOWED_CONTENT_TYPES = new Set(["image/avif", "image/gif", "image/jpeg", "image/png", "image/webp"]);
+export function isAllowedDashboardAvatarUrl(value) {
+    if (typeof value !== "string")
+        return false;
+    try {
+        const url = new URL(value);
+        return url.protocol === "https:"
+            && url.username === ""
+            && url.password === ""
+            && (url.port === "" || url.port === "443")
+            && /^s\d+-imfile\.feishucdn\.com$/i.test(url.hostname)
+            && url.pathname.startsWith("/static-resource/v1/");
+    }
+    catch {
+        return false;
+    }
+}
+async function readBoundedBody(response) {
+    const declared = Number(response.headers.get("content-length"));
+    if (Number.isFinite(declared) && declared > MAX_AVATAR_BYTES) {
+        throw new Error(`avatar exceeds ${MAX_AVATAR_BYTES} bytes`);
+    }
+    if (!response.body)
+        throw new Error("avatar response has no body");
+    const chunks = [];
+    let total = 0;
+    const reader = response.body.getReader();
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        total += value.byteLength;
+        if (total > MAX_AVATAR_BYTES) {
+            await reader.cancel();
+            throw new Error(`avatar exceeds ${MAX_AVATAR_BYTES} bytes`);
+        }
+        chunks.push(Buffer.from(value));
+    }
+    return Buffer.concat(chunks, total);
+}
+async function fetchDashboardAvatar(sourceUrl, fetchImpl) {
+    if (!isAllowedDashboardAvatarUrl(sourceUrl))
+        throw new Error("avatar source is not allowed");
+    const response = await fetchImpl(sourceUrl, {
+        headers: { Accept: "image/avif,image/webp,image/png,image/jpeg,image/gif" },
+        redirect: "error",
+        signal: AbortSignal.timeout(5_000),
+    });
+    if (!response.ok)
+        throw new Error(`avatar upstream returned ${response.status}`);
+    const contentType = (response.headers.get("content-type") || "").split(";", 1)[0].trim().toLowerCase();
+    if (!ALLOWED_CONTENT_TYPES.has(contentType))
+        throw new Error("unsupported avatar content type");
+    const body = await readBoundedBody(response);
+    const digest = crypto.createHash("sha256").update(body).digest("hex");
+    return { body, contentType, etag: `"sha256-${digest}"` };
+}
+export function createDashboardAvatarCache(options = {}) {
+    const fetchImpl = options.fetchImpl || fetch;
+    const now = options.now || Date.now;
+    const ttlMs = options.ttlMs || DEFAULT_TTL_MS;
+    const entries = new Map();
+    return {
+        async get(agentId, sourceUrl) {
+            const cached = entries.get(agentId);
+            if (cached && cached.sourceUrl === sourceUrl && cached.expiresAt > now())
+                return cached.payload;
+            const payload = await fetchDashboardAvatar(sourceUrl, fetchImpl);
+            entries.set(agentId, { sourceUrl, expiresAt: now() + ttlMs, payload });
+            return payload;
+        },
+    };
+}
+export function createDashboardAvatarController(options) {
+    const cache = createDashboardAvatarCache({ fetchImpl: options.fetchImpl });
+    return {
+        async handle(req, res, requestUrl) {
+            const match = /^\/api\/avatar\/([^/]+)$/.exec(requestUrl.pathname);
+            if (!match)
+                return false;
+            if (req.method !== "GET" && req.method !== "HEAD") {
+                res.writeHead(405, { Allow: "GET, HEAD", "Cache-Control": "no-store" });
+                res.end();
+                return true;
+            }
+            let agentId;
+            try {
+                agentId = decodeURIComponent(match[1]);
+            }
+            catch {
+                res.writeHead(400, { "Cache-Control": "no-store" });
+                res.end("bad request");
+                return true;
+            }
+            try {
+                const sourceUrl = options.resolveSource(agentId);
+                if (!sourceUrl) {
+                    res.writeHead(404, { "Cache-Control": "no-store" });
+                    res.end("not found");
+                    return true;
+                }
+                const payload = await cache.get(agentId, sourceUrl);
+                if (req.headers["if-none-match"] === payload.etag) {
+                    res.writeHead(304, { ETag: payload.etag });
+                    res.end();
+                    return true;
+                }
+                res.writeHead(200, {
+                    "Content-Type": payload.contentType,
+                    "Content-Length": payload.body.byteLength,
+                    "Cache-Control": "private, max-age=60, must-revalidate",
+                    "X-Content-Type-Options": "nosniff",
+                    "Content-Security-Policy": "default-src 'none'; sandbox",
+                    ETag: payload.etag,
+                });
+                res.end(req.method === "HEAD" ? undefined : payload.body);
+            }
+            catch {
+                res.writeHead(502, { "Cache-Control": "no-store" });
+                res.end("avatar unavailable");
+            }
+            return true;
+        },
+    };
+}