@noimosai/platform-cli 0.1.2 → 0.1.4

package/dist/cli/local-agents.js

@@ -0,0 +1,199 @@
+import { execFile, spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { access, open, realpath, stat } from "node:fs/promises";
+import { delimiter, isAbsolute, join } from "node:path";
+import { promisify } from "node:util";
+import { createInterface } from "node:readline";
+import { once } from "node:events";
+import { z } from "zod";
+const execute = promisify(execFile);
+export const managedCliChildEnv = "RELVO_MANAGED_CHILD";
+export function cleanAgentEnvironment(env, home) {
+    const result = { ...env, HOME: home };
+    for (const key of ["RELVO_API_KEY", "RELVO_API_URL", "RELVO_ENV", "NOIMOS_PLATFORM_API_KEY", "NOIMOS_PLATFORM_API_URL", "NOIMOS_PLATFORM_ENV", "RELVO_MCP_ALLOWED_UPLOAD_ROOTS", "NOIMOS_MCP_ALLOWED_UPLOAD_ROOTS", "RELVO_WALLET_PRIVATE_KEY", "RELVO_WALLET_AUTO_TOP_UP_USD"])
+        delete result[key];
+    return result;
+}
+export async function executable(name, env, keepPath = false) {
+    for (const directory of (env.PATH ?? "").split(delimiter).filter(isAbsolute)) {
+        try {
+            const path = await realpath(join(directory, name));
+            const info = await stat(path);
+            if (!info.isFile() || info.mode & 0o022 || typeof process.getuid === "function" && ![0, process.getuid()].includes(info.uid))
+                continue;
+            await access(path, constants.X_OK);
+            return keepPath ? join(directory, name) : path;
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error(`Install ${name} and make its executable available on PATH before setup.`);
+}
+export async function preflightAgent(client, env, home, registryRuntime = true, purpose = "setup") {
+    if (Number(process.versions.node.split(".")[0]) < 22)
+        throw new Error("Relvo setup requires Node.js 22 or newer.");
+    if (client === "terminal")
+        return {};
+    if (client === "claude" && env.CLAUDE_CONFIG_DIR !== undefined)
+        throw new Error("Relvo setup cannot safely inspect a custom Claude configuration directory. Use the default Claude user configuration for automatic setup.");
+    const agent = await executable(client, env), launcher = registryRuntime ? await executable("npx", env, true) : undefined;
+    try {
+        await execute(agent, ["--version"], { cwd: home, env: cleanAgentEnvironment(env, home), timeout: 15000, maxBuffer: 65536 });
+    }
+    catch {
+        throw new Error(`The ${client} executable could not be verified.${purpose === "setup" ? " No login request was created." : " Run relvo doctor again."}`);
+    }
+    return { agent, launcher };
+}
+export const agentNames = { claude: "Claude Code", codex: "Codex" };
+export async function preflightAgents(requested, env, home, registryRuntime, report) {
+    if (requested !== "auto") {
+        const { agent, launcher } = await preflightAgent(requested, env, home, registryRuntime);
+        return requested === "terminal" || !agent ? [] : [{ client: requested, agent, launcher }];
+    }
+    await preflightAgent("terminal", env, home);
+    const prepared = [];
+    for (const client of ["claude", "codex"]) {
+        try {
+            await executable(client, env);
+        }
+        catch {
+            report(`${agentNames[client]} was not found on PATH; skipped.`);
+            continue;
+        }
+        if (client === "claude" && env.CLAUDE_CONFIG_DIR !== undefined) {
+            report("Claude Code uses a custom configuration directory, which automatic setup cannot inspect safely; skipped.");
+            continue;
+        }
+        const { agent, launcher } = await preflightAgent(client, env, home, registryRuntime);
+        if (agent)
+            prepared.push({ client, agent, launcher });
+    }
+    if (!prepared.length)
+        report("Neither Claude Code nor Codex was found; setting up the Relvo CLI only.");
+    return prepared;
+}
+const entrySchema = z.object({ type: z.literal("stdio"), command: z.string(), args: z.array(z.string()).default([]), env: z.record(z.string(), z.string()).optional().nullable(), cwd: z.string().optional().nullable() });
+export function registrationMatches(input, expected) {
+    const value = entrySchema.safeParse(input);
+    return value.success && value.data.command === expected.command && JSON.stringify(value.data.args) === JSON.stringify(expected.args) &&
+        !Object.keys(value.data.env ?? {}).length && !value.data.cwd;
+}
+export async function agentRegistration(client, agent, env, home, name = "relvo") {
+    if (client === "codex") {
+        let stdout;
+        try {
+            ({ stdout } = await execute(agent, ["mcp", "list", "--json"], { cwd: home, env: cleanAgentEnvironment(env, home), timeout: 15000, maxBuffer: 1048576 }));
+        }
+        catch {
+            throw new Error("Codex MCP configuration could not be inspected. No server was overwritten.");
+        }
+        try {
+            const rows = z.array(z.object({ name: z.string(), transport: z.unknown() }).passthrough()).parse(JSON.parse(stdout));
+            return rows.find((row) => row.name === name)?.transport ?? null;
+        }
+        catch {
+            throw new Error("Codex returned an unexpected MCP configuration. No server was overwritten.");
+        }
+    }
+    let handle;
+    try {
+        handle = await open(join(home, ".claude.json"), constants.O_RDONLY | constants.O_NOFOLLOW);
+        const info = await handle.stat();
+        if (!info.isFile() || info.size > 4194304 || info.mode & 0o022 || typeof process.getuid === "function" && info.uid !== process.getuid())
+            throw new Error("Unsafe Claude configuration");
+        const result = z.object({ mcpServers: z.record(z.string(), z.unknown()).optional() }).passthrough().parse(JSON.parse(await handle.readFile("utf8")));
+        return result.mcpServers?.[name] ?? null;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return null;
+        throw new Error("Claude MCP configuration could not be safely inspected. No server was overwritten.");
+    }
+    finally {
+        await handle?.close();
+    }
+}
+export async function registerAgent(registration, agent, env, home) {
+    if (await agentRegistration(registration.client, agent, env, home, registration.name))
+        throw new Error("A Relvo MCP entry appeared while setup was awaiting approval. It was preserved; rerun setup after resolving the conflict.");
+    const args = registration.client === "codex" ? ["mcp", "add", registration.name, "--", registration.command, ...registration.args]
+        : ["mcp", "add", "--transport", "stdio", "--scope", "user", registration.name, "--", registration.command, ...registration.args];
+    try {
+        await execute(agent, args, { cwd: home, env: cleanAgentEnvironment(env, home), timeout: 20000, maxBuffer: 1048576 });
+    }
+    catch {
+        throw new Error("Relvo MCP registration failed. Login was saved; rerun setup to resume without minting another key.");
+    }
+    if (!registrationMatches(await agentRegistration(registration.client, agent, env, home, registration.name), registration))
+        throw new Error("Relvo could not verify the saved MCP registration. Run doctor before using it.");
+}
+export async function probeMcp(registration, env, home, projectId, signal) {
+    const failed = new Error("Relvo MCP verification failed. Run doctor to inspect the saved connection; no paid work was started.");
+    if (signal?.aborted)
+        throw failed;
+    const child = spawn(registration.command, registration.args, { cwd: home, env: { ...cleanAgentEnvironment(env, home), [managedCliChildEnv]: "1", RELVO_PROJECT_AUTO_SYNC: "0" }, stdio: ["pipe", "pipe", "pipe"] });
+    let stderrBytes = 0, stdoutBytes = 0;
+    const aborted = new AbortController();
+    const cancel = () => aborted.abort(failed);
+    signal?.addEventListener("abort", cancel, { once: true });
+    if (signal?.aborted)
+        cancel();
+    child.stderr.on("data", (chunk) => { stderrBytes += chunk.byteLength; if (stderrBytes > 65536)
+        aborted.abort(failed); });
+    child.stdout.on("data", (chunk) => { stdoutBytes += chunk.byteLength; if (stdoutBytes > 1048576)
+        aborted.abort(failed); });
+    child.on("error", () => aborted.abort(failed));
+    const deadline = setTimeout(() => aborted.abort(failed), 30000);
+    const lines = createInterface({ input: child.stdout })[Symbol.asyncIterator]();
+    let id = 0;
+    const meta = { "io.modelcontextprotocol/protocolVersion": "2026-07-28", "io.modelcontextprotocol/clientInfo": { name: "relvo-doctor", version: "1" }, "io.modelcontextprotocol/clientCapabilities": {} };
+    const rpc = async (method, params) => {
+        const requestId = ++id;
+        child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id: requestId, method, params: { ...params, _meta: meta } }) + "\n");
+        for (;;) {
+            aborted.signal.throwIfAborted();
+            const next = await new Promise((resolve, reject) => {
+                const cancel = () => reject(failed);
+                aborted.signal.addEventListener("abort", cancel, { once: true });
+                lines.next().then(resolve, reject).finally(() => aborted.signal.removeEventListener("abort", cancel));
+            });
+            if (next.done)
+                throw failed;
+            const reply = z.object({ id: z.number().optional(), result: z.record(z.string(), z.unknown()).optional(), error: z.unknown().optional() }).parse(JSON.parse(next.value));
+            if (reply.id === requestId) {
+                if (reply.error || !reply.result)
+                    throw failed;
+                return reply.result;
+            }
+        }
+    };
+    try {
+        await rpc("server/discover", {});
+        const catalog = z.object({ tools: z.array(z.object({ name: z.string() }).passthrough()) }).parse(await rpc("tools/list", {}));
+        const names = new Set(catalog.tools.map((tool) => tool.name));
+        const compact = ["platform_tools", "platform_run", "platform"].every((name) => names.has(name));
+        if (!compact && !["platform_project", "platform_tools", "platform_skills", "platform_quote", "platform_execute"].every((name) => names.has(name)))
+            throw failed;
+        const call = (name, input) => rpc("tools/call", compact ? { name: "platform", arguments: { operation: "call", input: { name, input } } } : { name, arguments: input });
+        const project = z.object({ isError: z.boolean().optional(), structuredContent: z.object({ data: z.object({ developerProjectId: z.string() }) }) }).parse(await call("platform_project", {}));
+        if (project.isError || project.structuredContent.data.developerProjectId !== projectId)
+            throw failed;
+        const guides = await call("platform_skills", { summary: true });
+        if (guides.isError || !guides.structuredContent)
+            throw failed;
+    }
+    catch {
+        throw failed;
+    }
+    finally {
+        signal?.removeEventListener("abort", cancel);
+        clearTimeout(deadline);
+        const closed = child.exitCode === null && child.signalCode === null ? once(child, "close") : null;
+        child.kill("SIGTERM");
+        const force = setTimeout(() => child.kill("SIGKILL"), 2000);
+        await closed;
+        clearTimeout(force);
+    }
+}

package/dist/cli/mcp-supervisor.js

@@ -0,0 +1,136 @@
+import { createInterface } from "node:readline";
+import { z } from "zod";
+export const mcpWorkerEnv = "RELVO_MCP_WORKER";
+const HANDSHAKE_ID = "relvo-supervisor-initialize";
+const HANDSHAKE_TIMEOUT_MS = 120_000, EXIT_GRACE_MS = 5_000;
+const messageSchema = z.object({ id: z.union([z.string(), z.number()]).nullable().optional(), method: z.string().optional() }).loose();
+const serverInfoSchema = z.object({ version: z.string() }).loose().optional();
+const handshakeSchema = z.object({ result: z.object({ serverInfo: serverInfoSchema, _meta: z.object({ "io.modelcontextprotocol/serverInfo": serverInfoSchema }).loose().optional(),
+        capabilities: z.object({ tools: z.object({ listChanged: z.boolean().optional() }).loose().optional() }).loose().optional() }).loose() }).loose();
+function parsed(line) {
+    try {
+        return messageSchema.safeParse(JSON.parse(line)).data ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export function superviseMcp({ input, output, start, target, version, stop, pollMs = 30_000, retryMs = 300_000, now = Date.now }) {
+    return new Promise(resolve => {
+        const fromHost = new Set(), fromServer = new Set();
+        const watch = (worker) => {
+            const live = { worker, onLine: () => { } };
+            createInterface({ input: worker.stdout, crlfDelay: Infinity }).on("line", line => { live.onLine(line); });
+            return live;
+        };
+        let opening = null, initialized = null;
+        let current = watch(start(false)), next = null;
+        let running = version, replacing = false, retryAt = 0, closing = false;
+        const send = (line) => { output.write(`${line}\n`); };
+        const finish = (code) => {
+            clearInterval(poll);
+            next?.live.worker.kill();
+            hostLines.close();
+            resolve(code);
+        };
+        const follow = (live) => { void live.worker.exited.then(code => { if (live === current)
+            finish(code); }); };
+        const close = () => {
+            if (closing)
+                return;
+            closing = true;
+            current.worker.stdin.end();
+            setTimeout(() => { current.worker.kill(); }, EXIT_GRACE_MS).unref();
+        };
+        const advance = () => {
+            if (!next || fromHost.size || fromServer.size)
+                return;
+            const previous = current, { live, version: adopted, toolsChanged } = next;
+            next = null;
+            current = live;
+            running = adopted;
+            live.onLine = serve;
+            previous.onLine = () => { };
+            follow(live);
+            previous.worker.stdin.end();
+            setTimeout(() => { previous.worker.kill(); }, EXIT_GRACE_MS).unref();
+            if (toolsChanged)
+                send(JSON.stringify({ jsonrpc: "2.0", method: "notifications/tools/list_changed" }));
+        };
+        const serve = (line) => {
+            const message = parsed(line), id = message?.id;
+            if (id !== undefined && id !== null) {
+                if (message?.method)
+                    fromServer.add(id);
+                else
+                    fromHost.delete(id);
+            }
+            send(line);
+            advance();
+        };
+        current.onLine = serve;
+        follow(current);
+        const handshake = (live) => new Promise(settle => {
+            if (!opening) {
+                settle({ toolsChanged: false });
+                return;
+            }
+            const timeout = setTimeout(() => { settle(null); }, HANDSHAKE_TIMEOUT_MS);
+            timeout.unref();
+            void live.worker.exited.then(() => { clearTimeout(timeout); settle(null); });
+            live.onLine = line => {
+                if (parsed(line)?.id !== HANDSHAKE_ID)
+                    return;
+                clearTimeout(timeout);
+                const reply = handshakeSchema.safeParse(JSON.parse(line)).data?.result;
+                if (!reply) {
+                    settle(null);
+                    return;
+                }
+                if (initialized)
+                    live.worker.stdin.write(`${initialized}\n`);
+                settle({ version: (reply.serverInfo ?? reply._meta?.["io.modelcontextprotocol/serverInfo"])?.version, toolsChanged: reply.capabilities?.tools?.listChanged === true });
+            };
+            live.worker.stdin.write(`${JSON.stringify({ ...opening, id: HANDSHAKE_ID })}\n`);
+        });
+        const check = async () => {
+            if (closing || replacing || next || now() < retryAt)
+                return;
+            replacing = true;
+            try {
+                const wanted = await target().catch(() => null);
+                if (!wanted || wanted === running)
+                    return;
+                retryAt = now() + retryMs;
+                const live = watch(start(true)), ready = await handshake(live);
+                if (!ready || closing || ready.version && ready.version !== wanted) {
+                    live.worker.kill();
+                    return;
+                }
+                next = { live, version: wanted, toolsChanged: ready.toolsChanged };
+                advance();
+            }
+            finally {
+                replacing = false;
+            }
+        };
+        const poll = setInterval(() => { void check(); }, pollMs);
+        poll.unref();
+        const hostLines = createInterface({ input, crlfDelay: Infinity }).on("line", line => {
+            const message = parsed(line), id = message?.id;
+            if (message?.method === "initialize" || message?.method === "server/discover")
+                opening = message;
+            if (message?.method === "notifications/initialized")
+                initialized = line;
+            if (id !== undefined && id !== null) {
+                if (message?.method)
+                    fromHost.add(id);
+                else
+                    fromServer.delete(id);
+            }
+            current.worker.stdin.write(`${line}\n`);
+            advance();
+        }).on("close", close);
+        stop?.addEventListener("abort", close, { once: true });
+    });
+}

package/dist/cli/noimos-cli.js

@@ -0,0 +1,72 @@
+import { PLATFORM_DISTRIBUTIONS } from "../client/index.js";
+import { runCli } from "./cli.js";
+const COMMANDS = [
+    ["project", "project", "Show the developer organization and project bound to the API key"],
+    ["usage", "usage", "Show the current project's monthly request count and spend"],
+    ["tools", `tools [--query <text>] [--category <id>] [--provider <id>]
+        [--available-only | --include-unavailable] [--summary | --with-schemas]
+        [--max-charge-micros <integer>] [--quote-arguments '<json>'] [--price-unit <unit>]
+        [--sort-by relevance|price_asc] [--include '<filter-json>'] [--exclude '<filter-json>']
+        [--limit <1-12>] [--mode auto|keyword|semantic]`, "Search up to 12 tool summaries and USD prices (default 8); search uses monthly free calls, then is charged"],
+    ["tool", "tool <name>", "Inspect one tool's arguments, example and price"],
+    ["executions", "executions [--limit <1-100>] [--before <id>] [--status <state>] [--tool <name>]", "Recover the API key's project execution history"],
+    ["quote", "quote <tool> '<arguments-json>' [--provider <id>] [--relevance-check auto|light] [--maximum-charge-micros <cap>]", "Get a free quote without running the tool"],
+    ["execute", `execute <tool> '<arguments-json>' --maximum-charge-micros <integer>
+          --price-version <version> --idempotency-key <key> [--provider <id>] [--relevance-check auto|light] [--raw]`, "Reserve up to the quoted amount and enqueue paid work"],
+    ["execution", "execution <id> [--raw]", "Read status, a bounded output preview and the final USD charge"],
+    ["result", `result <id> [--path '<JSON-array>'] [--fields '<JSON-array>'] [--offset <n>] [--limit <n>]
+        [--max-chars <1-8000>]`, "Read a selected page of the stored output without paying again"],
+    ["wait", "wait <id> [--timeout <seconds>] [--raw]", "Wait for completion (default 480 seconds, maximum 900)"],
+    ["cancel", "cancel <id> [--raw]", "Request cancellation of work that has not started"],
+    ["artifact-url", "artifact-url <execution-id> <artifact-id>", "Get a private output's download URL, valid for up to 5 minutes"],
+    ["download", "download <execution-id> <artifact-id> --out <file>", "Save an artifact after size/SHA-256 checks; never overwrite a file"],
+    ["upload", "upload <file>", "Upload one explicit JPG/PNG/WebP/WAV/MP3/MP4/MOV input, at most 12 MiB"],
+];
+const REFUSED_OPTIONS = {
+    tools: ["--app", "--funding"],
+    quote: ["--session"],
+    execute: ["--session"],
+    result: ["--file", "--find", "--pick", "--wait"],
+};
+const entry = ([, usage, summary]) => `  ${usage}\n             ${summary}`;
+export const noimosPlatformHelp = `NoimosAI Developer Platform CLI
+
+Usage: noimos-platform <command>
+       noimos-platform <command> --help | help <command>
+
+${COMMANDS.map(entry).join("\n")}
+
+Get a quote first. Use its price version and maximum charge (1 USD = 1000000
+micros). Keep the same body and idempotency key when retrying a submission.
+Execution is asynchronous. Poll at intervals of at least 5 seconds.
+For quote and execute, use - in place of arguments-json to read JSON from stdin,
+or --input-file <path> to read a JSON file (at most 1 MiB).
+wait exits 0 on success, 1 on failed/cancelled/needs_review, 3 on timeout.
+A timeout leaves accepted work running; read or wait on the same execution ID.
+Large outputs stay in the execution: read them with result. --raw returns the
+full output for execution, wait, execute or cancel.
+
+Standalone tools only: no workspace, brand, knowledge base, dataset, connected
+provider account, post, workspace skill or chat-session commands. Scope comes
+from the developer API key; supply prompts, public URLs, project files or artifacts.
+
+Environment: NOIMOS_PLATFORM_API_URL, NOIMOS_PLATFORM_API_KEY
+Local emulators only: NOIMOS_PLATFORM_ENV=local
+
+Manage organizations, members, keys and billing at platform.noimosai.com.
+`;
+export const NOIMOS_PLATFORM_CLI_SURFACE = {
+    distribution: PLATFORM_DISTRIBUTIONS.noimos,
+    help: noimosPlatformHelp,
+    fullHelp: noimosPlatformHelp,
+    commandHelp: name => {
+        const command = COMMANDS.find(([commandName]) => commandName === name);
+        return command && `Usage: noimos-platform ${command[1]}\n\n${command[2]}.\nEnvironment: NOIMOS_PLATFORM_API_URL, NOIMOS_PLATFORM_API_KEY\n`;
+    },
+    supports: ([name, ...rest]) => COMMANDS.some(([commandName]) => commandName === name) && (name !== "project" || rest.length === 0)
+        && !(REFUSED_OPTIONS[name] ?? []).some(option => rest.some(arg => arg === option || arg.startsWith(`${option}=`))),
+    savedLogins: false,
+};
+export function runNoimosPlatformCli(args, env, output, error, transport = fetch, stdin = process.stdin) {
+    return runCli(args, env, output, error, transport, stdin, undefined, NOIMOS_PLATFORM_CLI_SURFACE);
+}

package/dist/cli/project-archive.js

@@ -0,0 +1,27 @@
+import { createHash, randomUUID } from "node:crypto";
+import { lstat, rename } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { localProfilePath, profileDirectory, safeDirectory, writePrivateBytes, writePrivateJson } from "../client/local-profile.js";
+async function destination(home, projectId, source) {
+    const profile = localProfilePath(home);
+    await profileDirectory(profile, true);
+    const root = join(dirname(profile), "project-archives");
+    await safeDirectory(root, true, true);
+    const folder = join(root, `${createHash("sha256").update(projectId).digest("hex").slice(0, 16)}-${randomUUID()}`);
+    await safeDirectory(folder, true, true);
+    await writePrivateJson(join(folder, "origin.json"), { projectId, source }, false, 16_384);
+    return join(folder, basename(source));
+}
+export async function archiveProjectPath(home, projectId, source) {
+    const before = await lstat(source);
+    if (before.isSymbolicLink() || !before.isFile() && !before.isDirectory() || typeof process.getuid === "function" && before.uid !== process.getuid())
+        throw new Error(`Cannot archive unsafe managed path: ${source}`);
+    const backup = await destination(home, projectId, source);
+    await rename(source, backup);
+    return backup;
+}
+export async function archiveProjectBytes(home, projectId, source, bytes) {
+    const backup = await destination(home, projectId, source);
+    await writePrivateBytes(backup, bytes, false, Math.max(bytes.byteLength, 1));
+    return backup;
+}

package/dist/cli/project-files.js

@@ -0,0 +1,25 @@
+import { realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import { localProfilePath } from "../client/local-profile.js";
+import { syncTeamSkills } from "./team-skills.js";
+import { TEAM_HARNESSES, assertHarnessProjectSwitch, harnessRoots, readCustomHarnesses, syncTeamHarness } from "./team-harness.js";
+import { invalidateProjectSyncReceipts } from "./project-sync.js";
+export async function deactivateProjectFiles(projectId, env = process.env, home = homedir()) {
+    home = await realpath(home);
+    const roots = harnessRoots(home, env, await readCustomHarnesses(home));
+    const clients = [...TEAM_HARNESSES, ...roots.custom.map(entry => entry.name)];
+    const empty = {
+        teamSkills: async () => ({ data: { skills: [] } }),
+        teamSkill: async () => { throw new Error("Project deactivation never downloads or installs a new item."); },
+    };
+    await assertHarnessProjectSwitch(roots, clients, projectId);
+    await invalidateProjectSyncReceipts(localProfilePath(home), projectId);
+    const skills = await syncTeamSkills(home, clients, projectId, empty, false, roots, true);
+    const harnesses = await syncTeamHarness(roots, clients, projectId, empty, false, env, true);
+    const removed = skills.flatMap(result => result.removed), archived = skills.flatMap(result => (result.archived ?? []).map(item => ({ path: item.folder, backup: item.backup })));
+    for (const result of Object.values(harnesses)) {
+        removed.push(...result.removed, ...result.folders?.removed ?? []);
+        archived.push(...result.archived ?? [], ...result.folders?.archived ?? []);
+    }
+    return { projectId, removed, archived, reloadRequired: true };
+}