multi-agent-collaboration-mcp 0.12.0

package/dist/poller.js

@@ -0,0 +1,419 @@
+#!/usr/bin/env node
+// One bounded watcher: hold one SQLite connection and run one indexed LIMIT 1
+// probe after each sleep. No shell loop, subprocesses, temp output, counts, or
+// grouping. A hit identifies one room; catch_up does the actual read.
+import Database from "better-sqlite3";
+import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, unlinkSync, writeFileSync, } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { homedir, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+const USAGE = `agent-chat-poller: wait for unread work with one SQLite probe every five seconds.
+Usage:
+  poller.js --agent <id> [--room <id|name>] [--session <nonce>]
+            [--owner-pid <pid>]
+            [--mentions-only] [--interval <seconds>] [--timeout <seconds>]
+            [--ok-on-timeout]
+
+The interval must be 5..3600 seconds (default 5). The timeout must be
+1..86400 seconds (default 1200). Exit 0 = work exists; with --ok-on-timeout,
+exit 0 also reports a quiet deadline as has_updates:false. Without it,
+timeout exits 124. Exit 2 = invalid arguments, duplicate watcher, or DB error.
+`;
+function argumentError(message) {
+    throw new Error(message);
+}
+function parseInteger(value, flag, min, max) {
+    if (!/^\d+$/.test(value))
+        argumentError(`${flag} must be an integer`);
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed < min || parsed > max) {
+        argumentError(`${flag} must be between ${min} and ${max}`);
+    }
+    return parsed;
+}
+function parseArgs(argv) {
+    let agent;
+    let room;
+    let session;
+    let ownerPid;
+    let db;
+    let mentionsOnly = false;
+    let intervalSeconds = 5;
+    let timeoutSeconds = 1200;
+    let timeoutOk = false;
+    for (let i = 0; i < argv.length; i++) {
+        let flag = argv[i];
+        let inline;
+        const eq = flag.indexOf("=");
+        if (eq !== -1) {
+            inline = flag.slice(eq + 1);
+            flag = flag.slice(0, eq);
+        }
+        const take = () => {
+            const value = inline ?? argv[++i];
+            if (value === undefined || value.trim() === "") {
+                argumentError(`${flag} requires a non-empty value`);
+            }
+            return value.trim();
+        };
+        if (flag === "--agent")
+            agent = take();
+        else if (flag === "--room")
+            room = take();
+        else if (flag === "--session")
+            session = take();
+        else if (flag === "--owner-pid") {
+            ownerPid = parseInteger(take(), flag, 1, 2_147_483_647);
+        }
+        else if (flag === "--db")
+            db = take();
+        else if (flag === "--interval") {
+            intervalSeconds = parseInteger(take(), flag, 5, 3600);
+        }
+        else if (flag === "--timeout") {
+            timeoutSeconds = parseInteger(take(), flag, 1, 86_400);
+        }
+        else if (flag === "--mentions-only") {
+            if (inline !== undefined)
+                argumentError(`${flag} takes no value`);
+            mentionsOnly = true;
+        }
+        else if (flag === "--ok-on-timeout") {
+            if (inline !== undefined)
+                argumentError(`${flag} takes no value`);
+            timeoutOk = true;
+        }
+        else if (flag === "--since") {
+            argumentError("--since is intentionally unsupported: frozen baselines can re-fire forever; use --session");
+        }
+        else if (flag === "--help" || flag === "-h") {
+            process.stdout.write(USAGE);
+            process.exit(0);
+        }
+        else {
+            argumentError(`unknown argument: ${flag}`);
+        }
+    }
+    if (!agent)
+        argumentError("--agent is required");
+    if (agent.length > 200)
+        argumentError("--agent is too long");
+    if (room && room.length > 500)
+        argumentError("--room is too long");
+    if (session && session.length > 500)
+        argumentError("--session is too long");
+    return {
+        agent,
+        room,
+        session,
+        ownerPid,
+        db,
+        mentionsOnly,
+        intervalSeconds,
+        timeoutSeconds,
+        timeoutOk,
+    };
+}
+function dbPath(override) {
+    const value = override ?? process.env.AGENT_CHAT_DB;
+    if (value && value.trim()) {
+        const trimmed = value.trim();
+        return trimmed === ":memory:" ? trimmed : resolve(trimmed);
+    }
+    return join(homedir(), ".agent-chat-mcp", "chat.db");
+}
+function processIsAlive(pid) {
+    if (!Number.isSafeInteger(pid) || pid < 1)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+}
+function acquireLock(path, token) {
+    try {
+        const fd = openSync(path, "wx", 0o600);
+        try {
+            writeFileSync(fd, JSON.stringify({ pid: process.pid, token }));
+        }
+        catch (error) {
+            try {
+                unlinkSync(path);
+            }
+            catch { }
+            throw error;
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+        let owner = 0;
+        try {
+            owner = Number(JSON.parse(readFileSync(path, "utf8")).pid);
+        }
+        catch { }
+        if (processIsAlive(owner)) {
+            argumentError(`an equivalent watcher is already running (pid ${owner}; lock: ${path})`);
+        }
+        // Fail closed. Automatic stale-lock stealing needs a second interprocess
+        // lock to avoid two reapers deleting each other's replacement.
+        argumentError(`stale watcher lock requires removal: ${path}`);
+    }
+}
+const sleep = (milliseconds) => new Promise((done) => setTimeout(done, milliseconds));
+async function sleepWhileOwnerAlive(milliseconds, ownerPid) {
+    // Independent/manual pollers need no five-second owner heartbeat; let their
+    // single timer sleep for the requested interval without needless wakeups.
+    if (ownerPid === undefined) {
+        await sleep(milliseconds);
+        return true;
+    }
+    const deadline = Date.now() + milliseconds;
+    for (;;) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            return true;
+        await sleep(Math.min(5_000, remaining));
+        if (ownerPid !== undefined && !processIsAlive(ownerPid))
+            return false;
+    }
+}
+let database = null;
+const lockPaths = [];
+const lockToken = randomUUID();
+let cleaned = false;
+function cleanup() {
+    if (cleaned)
+        return;
+    cleaned = true;
+    try {
+        database?.close();
+    }
+    catch { }
+    for (const lockPath of lockPaths) {
+        try {
+            const current = JSON.parse(readFileSync(lockPath, "utf8"));
+            if (current.token === lockToken)
+                unlinkSync(lockPath);
+        }
+        catch { }
+    }
+}
+// Install lifecycle guards before argument parsing, database opening, and lock
+// acquisition. A SIGHUP or broken output pipe must not strand the fail-closed
+// watcher lock. Cleanup is synchronous/idempotent, so the exit hook also covers
+// ordinary process.exit() calls and exceptions outside the main try/finally.
+function terminate(code) {
+    cleanup();
+    process.exit(code);
+}
+process.once("exit", cleanup);
+process.once("SIGHUP", () => terminate(129));
+process.once("SIGINT", () => terminate(130));
+process.once("SIGTERM", () => terminate(143));
+process.stdout.once("error", () => terminate(2));
+process.stderr.once("error", () => terminate(2));
+let exitCode = 2;
+try {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.ownerPid !== undefined && !processIsAlive(args.ownerPid)) {
+        argumentError(`owner MCP process ${args.ownerPid} has ended; regenerate the poller command`);
+    }
+    const requestedPath = dbPath(args.db);
+    if (requestedPath === ":memory:" || !existsSync(requestedPath)) {
+        argumentError(`database not found: ${requestedPath}`);
+    }
+    // Canonicalize symlinks before deriving the singleton key, so aliases of
+    // the same SQLite file cannot acquire separate watcher locks.
+    const path = realpathSync(requestedPath);
+    database = new Database(path);
+    database.pragma("busy_timeout = 2000");
+    database.pragma("query_only = ON");
+    let resolvedRoom;
+    if (args.room) {
+        const numericRoom = /^\d+$/.test(args.room) && Number.isSafeInteger(Number(args.room));
+        resolvedRoom = numericRoom
+            ? database
+                .prepare("SELECT id, name FROM rooms WHERE id = ?")
+                .get(Number(args.room))
+            : database
+                .prepare("SELECT id, name FROM rooms WHERE name = ?")
+                .get(args.room);
+        if (!resolvedRoom)
+            argumentError(`no room "${args.room}"`);
+    }
+    // A global /tmp/agent-chat-pollers directory makes the first OS user its
+    // owner (0700) and prevents every other user from starting a watcher. Use a
+    // per-UID primary directory on POSIX. When this user owns the legacy
+    // directory, acquire the same scoped lock there first as a zero-runtime-cost
+    // rolling-upgrade guard: old and new pollers must not bypass each other's
+    // singleton merely because the lock directory changed.
+    const uid = typeof process.getuid === "function" ? process.getuid() : null;
+    const legacyLockDir = join(tmpdir(), "agent-chat-pollers");
+    try {
+        mkdirSync(legacyLockDir, { recursive: true, mode: 0o700 });
+    }
+    catch (error) {
+        const code = error.code;
+        if (uid === null || !["EACCES", "EPERM", "EEXIST"].includes(code ?? "")) {
+            throw error;
+        }
+    }
+    const legacyStat = lstatSync(legacyLockDir);
+    const lockDirs = [];
+    if (legacyStat.isDirectory() && (uid === null || legacyStat.uid === uid)) {
+        lockDirs.push(legacyLockDir);
+    }
+    else if (uid === null) {
+        argumentError(`watcher lock path is not a directory: ${legacyLockDir}`);
+    }
+    if (uid !== null) {
+        const uidLockDir = join(tmpdir(), `agent-chat-pollers-${uid}`);
+        mkdirSync(uidLockDir, { recursive: true, mode: 0o700 });
+        const uidStat = lstatSync(uidLockDir);
+        if (!uidStat.isDirectory() || uidStat.uid !== uid) {
+            argumentError(`watcher lock directory is owned by another user: ${uidLockDir}`);
+        }
+        lockDirs.push(uidLockDir);
+    }
+    const scopeKey = JSON.stringify([
+        path,
+        args.agent,
+        resolvedRoom?.id ?? null,
+        args.session ?? null,
+        args.mentionsOnly,
+    ]);
+    const lockName = createHash("sha256").update(scopeKey).digest("hex") + ".lock";
+    for (const lockDir of lockDirs) {
+        const lockPath = join(lockDir, lockName);
+        // Register before acquiring: a signal delivered immediately after the
+        // synchronous create still lets cleanup find the token-owned file.
+        lockPaths.push(lockPath);
+        acquireLock(lockPath, lockToken);
+    }
+    const params = {
+        agent: args.agent,
+        session: args.session ?? "",
+    };
+    const directed = args.mentionsOnly
+        ? ` AND (g.mentions IS NOT NULL OR g.reply_to_agent IS NOT NULL)
+        AND (EXISTS (SELECT 1 FROM json_each(g.mentions) WHERE value = @agent)
+             OR g.reply_to_agent = @agent)`
+        : "";
+    let probe;
+    if (resolvedRoom) {
+        const membership = database
+            .prepare("SELECT 1 FROM memberships WHERE room_id = ? AND agent_id = ?")
+            .get(resolvedRoom.id, args.agent);
+        if (!membership) {
+            argumentError(`agent "${args.agent}" has not joined room ${resolvedRoom.id}`);
+        }
+        params.room_id = resolvedRoom.id;
+        const statement = database.prepare(`SELECT r.name AS room_name,
+              EXISTS (
+                SELECT 1 FROM messages g
+                WHERE g.room_id = r.id
+                  AND g.seq > CASE WHEN @session = '' THEN mb.last_read_seq
+                                   ELSE COALESCE(sm.last_read_seq, mb.last_read_seq) END
+                  AND g.agent_id != @agent${directed}
+                LIMIT 1
+              ) AS has_updates
+       FROM rooms r
+       JOIN memberships mb ON mb.room_id = r.id AND mb.agent_id = @agent
+       LEFT JOIN session_markers sm ON sm.room_id = r.id
+            AND sm.agent_id = mb.agent_id AND sm.session_id = @session
+       WHERE r.id = @room_id`);
+        probe = () => {
+            const row = statement.get(params);
+            if (!row) {
+                argumentError(`room ${resolvedRoom.id} was deleted or the membership disappeared while watching`);
+            }
+            return row.has_updates
+                ? { room_id: resolvedRoom.id, room_name: row.room_name }
+                : undefined;
+        };
+    }
+    else {
+        const present = database
+            .prepare("SELECT 1 FROM memberships WHERE agent_id = ? AND left_at IS NULL LIMIT 1")
+            .get(args.agent);
+        if (!present)
+            argumentError(`agent "${args.agent}" is not present in any room`);
+        const statement = database.prepare(`SELECT mb.room_id AS room_id, r.name AS room_name
+       FROM memberships mb
+       JOIN rooms r ON r.id = mb.room_id
+       LEFT JOIN session_markers sm ON sm.room_id = mb.room_id
+            AND sm.agent_id = mb.agent_id AND sm.session_id = @session
+       WHERE mb.agent_id = @agent AND mb.left_at IS NULL
+         AND (@session = '' OR NOT EXISTS (
+           SELECT 1 FROM session_presence sp
+           WHERE sp.room_id = mb.room_id AND sp.agent_id = mb.agent_id
+             AND sp.session_id = @session AND sp.left_at IS NOT NULL
+         ))
+         AND EXISTS (
+           SELECT 1 FROM messages g
+           WHERE g.room_id = mb.room_id
+             AND g.seq > CASE WHEN @session = '' THEN mb.last_read_seq
+                              ELSE COALESCE(sm.last_read_seq, mb.last_read_seq) END
+             AND g.agent_id != @agent${directed}
+           LIMIT 1
+         )
+       LIMIT 1`);
+        probe = () => statement.get(params);
+    }
+    const deadline = Date.now() + args.timeoutSeconds * 1000;
+    for (;;) {
+        if (args.ownerPid !== undefined && !processIsAlive(args.ownerPid)) {
+            argumentError(`owner MCP process ${args.ownerPid} has ended; regenerate the poller command`);
+        }
+        // Probe before deciding that the deadline is quiet. The final sleep lands
+        // on the deadline; checking time first discarded messages that arrived
+        // during that last interval and reported a false timeout.
+        const hit = probe();
+        if (hit) {
+            await new Promise((resolveWrite, rejectWrite) => {
+                process.stdout.write(JSON.stringify({
+                    has_updates: true,
+                    agent: args.agent,
+                    room_id: hit.room_id,
+                    room_name: hit.room_name,
+                    mentions_only: args.mentionsOnly,
+                }) + "\n", (error) => (error ? rejectWrite(error) : resolveWrite()));
+            });
+            exitCode = 0;
+            break;
+        }
+        if (Date.now() >= deadline) {
+            if (args.timeoutOk) {
+                await new Promise((resolveWrite, rejectWrite) => {
+                    process.stdout.write('{"has_updates":false,"timed_out":true}\n', (error) => (error ? rejectWrite(error) : resolveWrite()));
+                });
+                exitCode = 0;
+            }
+            else {
+                process.stderr.write('{"timed_out":true}\n');
+                exitCode = 124;
+            }
+            break;
+        }
+        const remaining = deadline - Date.now();
+        const ownerAlive = await sleepWhileOwnerAlive(Math.min(args.intervalSeconds * 1000, remaining), args.ownerPid);
+        if (!ownerAlive) {
+            argumentError(`owner MCP process ${args.ownerPid} has ended; regenerate the poller command`);
+        }
+    }
+}
+catch (error) {
+    process.stderr.write(`agent-chat-poller: ${error instanceof Error ? error.message : String(error)}\n`);
+    exitCode = 2;
+}
+finally {
+    cleanup();
+}
+process.exitCode = exitCode;

package/dist/unicode.js

@@ -0,0 +1,78 @@
+// A high surrogate not immediately followed by a low, or a low not preceded
+// by a high: either is an unpaired (lone) surrogate. JavaScript strings can
+// contain these malformed UTF-16 code units even though they are not valid
+// Unicode scalar values.
+const LONE_SURROGATE = /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;
+/** Reject a string that contains malformed UTF-16. */
+export function assertWellFormedUtf16(value, field) {
+    if (LONE_SURROGATE.test(value)) {
+        throw new Error(`${field} contains a lone surrogate (malformed UTF-16); fix the encoding`);
+    }
+}
+/**
+ * Reject a lone surrogate in any string value or object key anywhere in a
+ * PARSED JSON value. Used at the store boundary for direct callers of
+ * postMessage(format:"json"): their already-serialized body hides a nested lone
+ * surrogate as an ASCII "\\uXXXX" escape that a raw-string check cannot see, and
+ * JSON.parse reconstructs it for readers. The MCP handler validates earlier and
+ * more cheaply via stringifyWellFormedJson (pre-escape, single pass); this is
+ * the defense-in-depth walk for everyone else.
+ */
+export function assertWellFormedJsonValue(value, field) {
+    if (typeof value === "string") {
+        assertWellFormedUtf16(value, `${field} string`);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const v of value)
+            assertWellFormedJsonValue(v, field);
+        return;
+    }
+    if (value !== null && typeof value === "object") {
+        for (const k of Object.keys(value)) {
+            assertWellFormedUtf16(k, `${field} object key`);
+            assertWellFormedJsonValue(value[k], field);
+        }
+    }
+}
+/**
+ * Serialize structured content while rejecting lone surrogates in every JSON
+ * string value and object key. A plain JSON.stringify would escape a lone
+ * surrogate to ASCII (for example, "\\ud800"), hiding it from the storage
+ * guard; JSON.parse would then recreate the malformed value for readers.
+ *
+ * The replacer validates values during JSON.stringify's own traversal, before
+ * they are escaped. This covers nested objects, arrays, keys, and toJSON output
+ * without a second recursive walk or a second in-memory representation.
+ * Embedded NUL is deliberately allowed here: JSON escapes it for storage and
+ * it is valid Unicode. Only malformed UTF-16 is a reader-interoperability risk.
+ */
+export function stringifyWellFormedJson(value, field) {
+    const encoded = JSON.stringify(value, function (key, child) {
+        // Array keys are generated decimal indexes and cannot contain malformed
+        // UTF-16. Avoid running the regex on every element of a wide array.
+        if (!Array.isArray(this)) {
+            assertWellFormedUtf16(key, `${field} object key`);
+        }
+        // JSON.stringify unboxes String objects only AFTER the replacer runs.
+        // They cannot arrive over JSON-RPC, but handling them keeps this shared
+        // serializer correct for in-process callers and for toJSON return values.
+        let stringValue = null;
+        if (typeof child === "string") {
+            stringValue = child;
+        }
+        else if (typeof child === "object" &&
+            child !== null &&
+            child instanceof String) {
+            stringValue = String.prototype.valueOf.call(child);
+        }
+        if (stringValue !== null) {
+            assertWellFormedUtf16(stringValue, `${field} string`);
+        }
+        return child;
+    });
+    if (encoded === undefined) {
+        throw new Error(`${field} is not JSON-serializable`);
+    }
+    return encoded;
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "multi-agent-collaboration-mcp",
+  "version": "0.12.0",
+  "description": "MCP server: a shared chat room where AI agents coordinate via a SQLite-backed message log",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Alex-R-A/multi-agent-collaboration-mcp.git"
+  },
+  "homepage": "https://github.com/Alex-R-A/multi-agent-collaboration-mcp#readme",
+  "bugs": "https://github.com/Alex-R-A/multi-agent-collaboration-mcp/issues",
+  "type": "module",
+  "bin": {
+    "multi-agent-collaboration-mcp": "dist/index.js",
+    "agent-chat-mcp": "dist/index.js",
+    "agent-chat-check": "dist/check.js",
+    "agent-chat-poller": "dist/poller.js"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "scripts",
+    "web"
+  ],
+  "scripts": {
+    "build": "tsc && node scripts/stamp-build.mjs",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "mcp:refresh": "node scripts/prepare.mjs && bash scripts/refresh-mcp.sh",
+    "web": "node web/server.mjs",
+    "prepare": "node scripts/prepare.mjs",
+    "pretest": "node scripts/prepare.mjs",
+    "test": "node test/run-suite.mjs",
+    "pretest:concurrency": "node scripts/prepare.mjs",
+    "test:concurrency": "node test/concurrent-catchup.mjs"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "better-sqlite3": "^11.8.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/node": "^22.10.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  }
+}

package/scripts/prepare.mjs

@@ -0,0 +1,82 @@
+// npm runs the `prepare` script in two very different places: a git-dependency
+// install (src/ present: build it) and inside an extracted PUBLISHED tarball
+// (src/ and tsconfig.json deliberately not shipped; dist/ already is).
+// Running tsc unconditionally made `npm install` fail inside the tarball.
+import { existsSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+if (!existsSync(new URL("../src", import.meta.url))) {
+  process.exit(0); // packaged tarball: dist is prebuilt, nothing to do
+}
+const root = fileURLToPath(new URL("..", import.meta.url));
+// Invoke the two build programs directly. `npm run build` adds an npm process
+// and a shell between this watchdog and tsc; killing only that parent on a
+// timeout can leave the compiler running. These direct children do not spawn
+// long-lived descendants (stamp-build's git probes have their own 10s caps).
+const steps = [
+  fileURLToPath(new URL("../node_modules/typescript/bin/tsc", import.meta.url)),
+  fileURLToPath(new URL("./stamp-build.mjs", import.meta.url)),
+];
+
+const grouped = process.platform !== "win32";
+let active = null;
+function killActive() {
+  if (!active?.pid) return;
+  try {
+    if (grouped) process.kill(-active.pid, "SIGKILL");
+    else active.kill("SIGKILL");
+  } catch {}
+}
+function stopFromSignal(code) {
+  killActive();
+  process.exit(code);
+}
+process.once("SIGHUP", () => stopFromSignal(129));
+process.once("SIGINT", () => stopFromSignal(130));
+process.once("SIGTERM", () => stopFromSignal(143));
+process.once("exit", killActive);
+
+async function runStep(script) {
+  return await new Promise((resolve) => {
+    const child = spawn(process.execPath, [script], {
+      stdio: "inherit",
+      detached: grouped,
+      // prepare.mjs may be invoked by absolute path from any directory. Keep
+      // tsc's project discovery inside this repository rather than compiling a
+      // caller's unrelated (and potentially huge) working tree.
+      cwd: root,
+    });
+    active = child;
+    let timedOut = false;
+    let spawnError = null;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      killActive();
+    }, 120_000);
+    child.once("error", (error) => {
+      spawnError = error;
+      killActive();
+    });
+    child.once("close", (code, signal) => {
+      clearTimeout(timer);
+      killActive();
+      active = null;
+      resolve({ code, signal, timedOut, spawnError });
+    });
+  });
+}
+
+for (const script of steps) {
+  const result = await runStep(script);
+  if (result.code !== 0 || result.timedOut || result.spawnError) {
+    const reason = result.timedOut
+      ? "timed out after 120000ms"
+      : result.spawnError
+        ? `spawn failed: ${result.spawnError.message}`
+        : `exited ${result.code ?? result.signal}`;
+    process.stderr.write(`build step ${script} ${reason}\n`);
+    process.exitCode = 1;
+    break;
+  }
+}