rushes 0.9.0 → 0.10.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,44 @@
1
+ import { execFile } from "node:child_process";
2
+ import { homedir } from "node:os";
3
+ import { delimiter, join } from "node:path";
4
+ /** The user's PATH plus the usual install folders, which a server started from a desktop shortcut may lack. */
5
+ export function searchPath() {
6
+ const parts = [...(process.env.PATH ?? "").split(delimiter), "/opt/homebrew/bin", "/usr/local/bin", join(homedir(), ".local", "bin")];
7
+ return [...new Set(parts.filter(Boolean))].join(delimiter);
8
+ }
9
+ /** execFile (never a shell). A missing command, or one that outlives the timeout (killed), resolves `code: null`. */
10
+ export const defaultRunner = (cmd, args, { timeoutMs }) => new Promise((resolve) => {
11
+ execFile(cmd, args, { timeout: timeoutMs, env: { ...process.env, PATH: searchPath() }, maxBuffer: 1024 * 1024, killSignal: "SIGKILL" }, (error, stdout, stderr) => {
12
+ const e = error;
13
+ if (!e)
14
+ return resolve({ code: 0, stdout: String(stdout), stderr: String(stderr) });
15
+ if (e.killed || typeof e.code !== "number")
16
+ return resolve({ code: null, stdout: "", stderr: "" });
17
+ resolve({ code: e.code, stdout: String(stdout), stderr: String(stderr) });
18
+ });
19
+ });
20
+ const TIMEOUT_MS = 5000;
21
+ const CACHE_MS = 30_000;
22
+ const SPECS = [
23
+ { id: "claude", name: "Claude Code", bin: "claude", status: ["auth", "status"], signIn: "claude auth login" },
24
+ { id: "codex", name: "Codex", bin: "codex", status: ["login", "status"], signIn: "codex login" },
25
+ ];
26
+ let cache = null;
27
+ /** Forget the 30 s cache (tests, and after the user signs in). */
28
+ export function clearDetectCache() { cache = null; }
29
+ async function detectOne(spec, run) {
30
+ const which = await run("which", [spec.bin], { timeoutMs: TIMEOUT_MS });
31
+ const path = which.code === 0 ? (which.stdout.split("\n")[0] ?? "").trim() : "";
32
+ if (!path)
33
+ return { id: spec.id, name: spec.name, installed: false, signedIn: false, path: null, signIn: spec.signIn };
34
+ const status = await run(spec.bin, spec.status, { timeoutMs: TIMEOUT_MS });
35
+ return { id: spec.id, name: spec.name, installed: true, signedIn: status.code === 0, path, signIn: spec.signIn };
36
+ }
37
+ /** Which agents are installed and signed in on this Mac. Signed in = the status command exits 0. */
38
+ export async function detectAgents(run = defaultRunner) {
39
+ if (cache && Date.now() - cache.at < CACHE_MS)
40
+ return cache.value;
41
+ const value = await Promise.all(SPECS.map((s) => detectOne(s, run)));
42
+ cache = { at: Date.now(), value };
43
+ return value;
44
+ }
@@ -0,0 +1,30 @@
1
+ // §28.5: the user's answer on a note goes back to the conversation as its own turn, for a note that is still with
2
+ // the agent (sent). Ruling R11: the runner sends it when Send to AI is on, the agent is signed in and a session is
3
+ // kept for it (loaded as Send loads it, so a restart loses nothing). Otherwise the note goes back to to do (runner.ts).
4
+ import { AGENT_LINES } from "../../core/agentActivity.js";
5
+ import { oneLine } from "../../core/labels.js";
6
+ import { noteState } from "../../core/noteState.js";
7
+ /** How much of a note's words an Activity line about an answer on it quotes (Task 10, 4). */
8
+ export const ANSWER_QUOTE_MAX = 40;
9
+ /** "your answer on '<the note's first words…>'": how Activity names an answer on a note, as M7 names a batch by its notes. */
10
+ export const answerLabel = (noteText) => `your answer on '${oneLine(noteText, ANSWER_QUOTE_MAX) || "a note"}'`;
11
+ /** A follow-up quotes the note's text up to this many characters. */
12
+ export const FOLLOW_UP_QUOTE_MAX = 200;
13
+ const count = (n, one, many) => `${n} ${n === 1 ? one : many}`;
14
+ /** A batch's turn by what it holds (M7): "3 notes", or its script lines when it holds no note. Never its id. */
15
+ export const batchLabel = (b) => b.noteIds.length === 0 && b.sectionIds.length > 0 ? count(b.sectionIds.length, "script line", "script lines") : count(b.noteIds.length, "note", "notes");
16
+ export const batchJob = (b) => ({ kind: "batch", batchId: b.id, note: null, label: batchLabel(b), prompt: b.prompt + "\n\n" + AGENT_LINES });
17
+ export function followUpText(note, noteText, answer) {
18
+ const quote = Array.from(noteText).slice(0, FOLLOW_UP_QUOTE_MAX).join("");
19
+ return `The user answered on note ${note} ("${quote}"): ${answer}\nCarry on with that note, then rushes_reply on it.`;
20
+ }
21
+ /** The follow-up turn for a "user-reply" event, or null when nothing is to be sent. */
22
+ export async function followUpFor(store, e) {
23
+ const answer = String(e?.text ?? "").trim();
24
+ if (!answer)
25
+ return null;
26
+ const n = (await store.read("notes")).notes.find((x) => x.id === e.note);
27
+ if (!n || noteState(n) !== "sent" || n.batch === null)
28
+ return null;
29
+ return { kind: "followUp", batchId: n.batch, note: n.id, label: answerLabel(n.text), prompt: followUpText(n.id, n.text, answer) };
30
+ }
@@ -0,0 +1,54 @@
1
+ // Spec §5.4: when the agent waits on the user (an ask, or a run that ends in a question) and no desk is open,
2
+ // Rushes says so with a macOS notification. Fixed text only: never a command or anything the agent wrote.
3
+ import { execFile } from "node:child_process";
4
+ import { basename } from "node:path";
5
+ import { AGENT_NAMES } from "./runner.js";
6
+ /** One line of AppleScript text: backslashes and quotes escaped, line breaks as spaces. */
7
+ const quoted = (s) => `"${s.replace(/[\r\n\t]+/g, " ").replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
8
+ /** The AppleScript that shows `body` under `title`. */
9
+ export function notificationScript(title, body) {
10
+ return `display notification ${quoted(body)} with title ${quoted(title)}`;
11
+ }
12
+ const run = (file, args) => new Promise((resolve, reject) => {
13
+ execFile(file, args, { timeout: 10_000 }, (e) => (e ? reject(e) : resolve()));
14
+ });
15
+ /**
16
+ * The default: `osascript -e 'display notification …'` on macOS, nothing on other platforms. RUSHES_NO_NOTIFY=1
17
+ * turns it off (the test suite sets it, so no test shows a real notification).
18
+ */
19
+ export function osNotifier(o = {}) {
20
+ const platform = o.platform ?? process.platform;
21
+ const env = o.env ?? process.env;
22
+ const exec = o.run ?? run;
23
+ return async (title, body) => {
24
+ if (platform !== "darwin" || env.RUSHES_NO_NOTIFY === "1")
25
+ return;
26
+ try {
27
+ await exec("osascript", ["-e", notificationScript(title, body)]);
28
+ }
29
+ catch (e) {
30
+ console.error(`Rushes: couldn't show a notification: ${e instanceof Error ? e.message : String(e)}`);
31
+ }
32
+ };
33
+ }
34
+ /**
35
+ * Listens to the runner's status on `store` and calls `notify` when a new ask arrives or the run reaches question,
36
+ * only while `watchers()` is 0 (no desk has the events stream open). Returns the function that stops listening.
37
+ */
38
+ export function notifyWhenWaiting(store, notify, watchers) {
39
+ const seen = new Set();
40
+ let phase = null;
41
+ const onStatus = (s) => {
42
+ const fresh = s.asks.some((a) => !seen.has(a.id));
43
+ for (const a of s.asks)
44
+ seen.add(a.id);
45
+ const question = s.phase === "question" && phase !== "question";
46
+ phase = s.phase;
47
+ if (!(fresh || question) || watchers() > 0)
48
+ return;
49
+ const name = s.agent ? AGENT_NAMES[s.agent] : "Your agent";
50
+ void notify("Rushes", `${name} is waiting for you in ${basename(store.root)}`).catch(() => undefined);
51
+ };
52
+ store.on("agent", onStatus);
53
+ return () => store.off("agent", onStatus);
54
+ }
@@ -0,0 +1,88 @@
1
+ import { isProjectRoot } from "../../core/projectFolder.js";
2
+ /*
3
+ * R16: an ask for one of Rushes's own MCP tools (the server the runner passes in session/new and session/load,
4
+ * named "rushes"; see rushesMcp) is allowed with no ask, under every permission level. Those tools only read and
5
+ * write the project's Rushes data through Rushes's own API. Everything else, other servers and lookalike names
6
+ * included, goes on to decide() as before. Matched on structured fields only, never on a title or other free text.
7
+ *
8
+ * Claude (claude-agent-acp 0.107.3, dist/permissions/presentation.js:112-124, set at dist/v1/acp-agent.js:6679-6686):
9
+ * toolCall._meta.claudeCode.toolName "mcp__rushes__rushes_reply"
10
+ * toolCall._meta.claudeCode.mcpServer { name: "rushes", source: "dynamic" } (the SDK's canUseTool mcpServer)
11
+ * All three must hold: source is exactly "dynamic", name is exactly "rushes", and toolName is exactly
12
+ * "mcp__rushes__" + a rushes_ tool. On a Claude CLI too old to report mcpServer, the ask goes to the user.
13
+ * Why "dynamic": the SDK says to key trust on `source`, not the name (claude-agent-sdk sdk.d.ts:258-268). The
14
+ * server Rushes passes in session/new is an ACP stdio server; the adapter makes it a stdio config
15
+ * (claude-agent-acp dist/mcp-servers.js:19-25); the SDK (0.3.325, sdk.mjs:166) hands every non-sdk server to the
16
+ * CLI as `--mcp-config`; and the CLI's can_use_tool schema says `source` is "dynamic for --mcp-config /
17
+ * mcp_set_servers process servers" (the bundled CLI, claude-agent-sdk-darwin-arm64 0.3.325, `mcp_server`
18
+ * description; its --mcp-config parser passes scope:"dynamic"). A server named "rushes" from the user's,
19
+ * project's or local config reads "user", "project" or "local", and asks. Read from the source only: the next
20
+ * real run confirms the value.
21
+ *
22
+ * Codex (codex-acp 2.7.0, dist/index.js): the approval itself carries no server or tool name. When the MCP call
23
+ * starts, Codex sends a tool_call update whose rawInput is { server, tool, arguments } (McpToolReporter.started
24
+ * :35824-35835, mcpInput :35851). The approval then comes as session/request_permission with the request's
25
+ * _meta.is_mcp_tool_approval === true and toolCall { toolCallId: <that call's id>, kind: "execute" }
26
+ * (buildMcpPermissionRequest :40486-40505, :40494; ElicitationReporter.permission :40386-40393, the correlated id from
27
+ * popPendingMcpApproval :40304, keyed by the same server). So the runner remembers each tool_call's rawInput
28
+ * server and tool by id (noteMcpCall), and the approval matches when its id names a rushes_ tool of server
29
+ * "rushes". Codex's standalone form (two calls to one server pending at once) names the tool only in free
30
+ * text, so it asks.
31
+ */
32
+ /** The name of the MCP server Rushes hands the agent. */
33
+ export const RUSHES_SERVER = "rushes";
34
+ /** One of Rushes's tool names: rushes_ then lower-case letters, digits and single underscores. Anchored. */
35
+ const OWN_TOOL = /^rushes_[a-z0-9]+(?:_[a-z0-9]+)*$/;
36
+ const CLAUDE_PREFIX = `mcp__${RUSHES_SERVER}__`;
37
+ /** The `source` Claude Code gives a server passed in session/new (see above). */
38
+ const CLAUDE_SOURCE = "dynamic";
39
+ const KEPT = 200;
40
+ const record = (v) => (typeof v === "object" && v !== null ? v : null);
41
+ /** Keeps the server and tool of a tool_call update whose rawInput names them (Codex's MCP calls). The oldest go past 200. */
42
+ export function noteMcpCall(calls, update) {
43
+ const u = record(update);
44
+ if (!u || u.sessionUpdate !== "tool_call" || typeof u.toolCallId !== "string")
45
+ return;
46
+ const input = record(u.rawInput);
47
+ if (!input || typeof input.server !== "string" || typeof input.tool !== "string")
48
+ return;
49
+ calls.delete(u.toolCallId);
50
+ calls.set(u.toolCallId, { server: input.server, tool: input.tool, args: input.arguments });
51
+ while (calls.size > KEPT)
52
+ calls.delete(calls.keys().next().value);
53
+ }
54
+ /**
55
+ * True only for an ask to run one of Rushes's own MCP tools. Only the branch of the agent that runs is read:
56
+ * a Codex-shaped request from Claude, or a Claude-shaped one from Codex, asks.
57
+ */
58
+ export function isOwnRushesTool(agent, root, p, calls) {
59
+ const tc = record(p.toolCall);
60
+ if (!tc)
61
+ return false;
62
+ return agent === "claude" ? ownClaudeTool(tc, root) : agent === "codex" ? ownCodexTool(p, tc, calls, root) : false;
63
+ }
64
+ /**
65
+ * R17, defence in depth beside the pinned MCP server: the tool's arguments name no project, or this one. Claude
66
+ * sends the tool's input as toolCall.rawInput (claude-agent-acp dist/tool-calls/renderer.js:212); Codex as
67
+ * rawInput.arguments of its tool_call (codex-acp dist/index.js mcpInput :35851).
68
+ */
69
+ function ownProject(args, root) {
70
+ const a = record(args);
71
+ return a !== null && isProjectRoot(root, a.project);
72
+ }
73
+ function ownClaudeTool(tc, root) {
74
+ const claude = record(record(tc._meta)?.claudeCode);
75
+ if (!claude)
76
+ return false;
77
+ const name = claude.toolName;
78
+ const server = record(claude.mcpServer);
79
+ return server?.source === CLAUDE_SOURCE && server?.name === RUSHES_SERVER && typeof name === "string" && name.startsWith(CLAUDE_PREFIX) && OWN_TOOL.test(name.slice(CLAUDE_PREFIX.length)) && ownProject(tc.rawInput, root);
80
+ }
81
+ function ownCodexTool(p, tc, calls, root) {
82
+ if (record(p._meta)?.is_mcp_tool_approval !== true)
83
+ return false;
84
+ if (tc.kind !== "execute" || typeof tc.toolCallId !== "string")
85
+ return false;
86
+ const call = calls.get(tc.toolCallId);
87
+ return call !== undefined && call.server === RUSHES_SERVER && OWN_TOOL.test(call.tool) && ownProject(call.args, root);
88
+ }
@@ -0,0 +1,126 @@
1
+ import { createInterface } from "node:readline";
2
+ /** A JSON-RPC error that came back from the other side. */
3
+ export class RpcError extends Error {
4
+ code;
5
+ data;
6
+ constructor(message, code, data) {
7
+ super(message);
8
+ this.code = code;
9
+ this.data = data;
10
+ this.name = "RpcError";
11
+ }
12
+ }
13
+ /**
14
+ * JSON-RPC 2.0 over a pair of streams, one JSON object per line.
15
+ * Both sides can send requests and notifications.
16
+ */
17
+ export class RpcPeer {
18
+ output;
19
+ nextId = 1;
20
+ pending = new Map();
21
+ requestHandlers = new Map();
22
+ notificationHandlers = new Map();
23
+ closed = null;
24
+ constructor(input, output) {
25
+ this.output = output;
26
+ const rl = createInterface({ input, crlfDelay: Infinity });
27
+ rl.on("line", (line) => this.onLine(line));
28
+ // A write to a dead child must not crash the process; the exit handler closes us.
29
+ output.on("error", () => { });
30
+ }
31
+ request(method, params) {
32
+ if (this.closed)
33
+ return Promise.reject(this.closed);
34
+ const id = this.nextId++;
35
+ return new Promise((resolve, reject) => {
36
+ this.pending.set(id, { resolve, reject });
37
+ this.send({ jsonrpc: "2.0", id, method, params });
38
+ });
39
+ }
40
+ notify(method, params) {
41
+ if (this.closed)
42
+ return;
43
+ this.send({ jsonrpc: "2.0", method, params });
44
+ }
45
+ onRequest(method, fn) {
46
+ this.requestHandlers.set(method, fn);
47
+ }
48
+ onNotification(method, fn) {
49
+ this.notificationHandlers.set(method, fn);
50
+ }
51
+ /** Rejects every request in flight (and any later one) with `reason`. */
52
+ close(reason) {
53
+ if (this.closed)
54
+ return;
55
+ this.closed = reason;
56
+ const all = [...this.pending.values()];
57
+ this.pending.clear();
58
+ for (const p of all)
59
+ p.reject(reason);
60
+ }
61
+ send(msg) {
62
+ try {
63
+ this.output.write(JSON.stringify(msg) + "\n");
64
+ }
65
+ catch {
66
+ /* the stream is gone; close() settles the requests */
67
+ }
68
+ }
69
+ onLine(line) {
70
+ if (!line.trim())
71
+ return;
72
+ let msg;
73
+ try {
74
+ msg = JSON.parse(line);
75
+ }
76
+ catch {
77
+ return;
78
+ }
79
+ if (!msg || typeof msg !== "object")
80
+ return;
81
+ const hasId = msg.id !== undefined && msg.id !== null;
82
+ if (typeof msg.method === "string") {
83
+ if (hasId)
84
+ void this.answer(msg.id, msg.method, msg.params);
85
+ else
86
+ this.dispatchNotification(msg.method, msg.params);
87
+ return;
88
+ }
89
+ if (hasId) {
90
+ const p = this.pending.get(msg.id);
91
+ if (!p)
92
+ return;
93
+ this.pending.delete(msg.id);
94
+ if (msg.error)
95
+ p.reject(new RpcError(String(msg.error.message ?? "rpc error"), Number(msg.error.code ?? -32000), msg.error.data));
96
+ else
97
+ p.resolve(msg.result);
98
+ }
99
+ }
100
+ /**
101
+ * A throwing notification handler must neither crash the host nor wedge the peer.
102
+ * The error is reported once on stderr with the method name, then ignored.
103
+ */
104
+ dispatchNotification(method, params) {
105
+ try {
106
+ this.notificationHandlers.get(method)?.(params);
107
+ }
108
+ catch (err) {
109
+ console.error(`[rushes] notification handler for ${method} threw: ${err instanceof Error ? err.message : String(err)}`);
110
+ }
111
+ }
112
+ async answer(id, method, params) {
113
+ const fn = this.requestHandlers.get(method);
114
+ if (!fn) {
115
+ this.send({ jsonrpc: "2.0", id, error: { code: -32601, message: `Method not found: ${method}` } });
116
+ return;
117
+ }
118
+ try {
119
+ const result = await fn(params);
120
+ this.send({ jsonrpc: "2.0", id, result: result ?? null });
121
+ }
122
+ catch (err) {
123
+ this.send({ jsonrpc: "2.0", id, error: { code: -32603, message: err instanceof Error ? err.message : String(err) } });
124
+ }
125
+ }
126
+ }
@@ -0,0 +1,105 @@
1
+ // R10: what the agent may do without asking (permissions and Always rules) is kept per user, outside the project,
2
+ // so an agent working in the project can never grant itself a rule by editing a file there. So are the user's answer to
3
+ // the first-Send sheet (I1, `setUp`) and the agent they chose (`agent`): a project folder from someone else, or anything
4
+ // that writes the project, can't turn Send to AI on for an agent.
5
+ //
6
+ // <user config dir>/rushes/agent-rules/<key>.json
7
+ // user config dir: $XDG_CONFIG_HOME when it is an absolute path, else ~/.config
8
+ // key: the first 16 hex characters of sha256(realpath.native(project root)), the name as the volume stores it
9
+ //
10
+ // The folder is 0700 and the file 0600. Writes are serialised and atomic (tmp + rename), like the project's own files.
11
+ import { createHash } from "node:crypto";
12
+ import { realpathSync } from "node:fs";
13
+ import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
14
+ import { homedir } from "node:os";
15
+ import { dirname, isAbsolute, join } from "node:path";
16
+ import { AgentRulesReadSchema, AgentRulesSchema } from "../../core/schema.js";
17
+ import { InvalidError } from "../../core/errors.js";
18
+ /** $XDG_CONFIG_HOME when set to an absolute path (as the XDG spec asks), else ~/.config. Tests point it at a temp folder. */
19
+ export function userConfigDir(env = process.env) {
20
+ const x = env.XDG_CONFIG_HOME;
21
+ return x && isAbsolute(x) ? x : join(homedir(), ".config");
22
+ }
23
+ /**
24
+ * The first 16 hex characters of sha256 of the project root's real path. The native realpath gives the name as it is
25
+ * stored, so a case-variant path to the same folder on a case-insensitive volume names the same file.
26
+ */
27
+ export function rulesKey(root) {
28
+ let real = root;
29
+ try {
30
+ real = realpathSync.native(root);
31
+ }
32
+ catch {
33
+ /* not there (yet): its own path */
34
+ }
35
+ return createHash("sha256").update(real).digest("hex").slice(0, 16);
36
+ }
37
+ export function rulesPath(root, configDir = userConfigDir()) {
38
+ return join(configDir, "rushes", "agent-rules", `${rulesKey(root)}.json`);
39
+ }
40
+ /** No file yet: edits in the project unasked, no Always rules, and not set up (I1): the first Send asks. */
41
+ const DEFAULTS = () => ({ permissions: "project-edits", always: [], setUp: false, agent: null });
42
+ /** A file that can't be read as rules: nothing goes through unasked, and nothing is handed over, until it is written again. */
43
+ const FAIL_CLOSED = () => ({ permissions: "ask-all", always: [], setUp: false, agent: null });
44
+ let writes = 0;
45
+ export class AgentRulesFile {
46
+ path;
47
+ queue = Promise.resolve();
48
+ constructor(root, configDir = userConfigDir()) {
49
+ this.path = rulesPath(root, configDir);
50
+ }
51
+ /** The rules now. A missing file reads as the defaults; a damaged one as ask-all with no rules. */
52
+ async read() {
53
+ let raw;
54
+ try {
55
+ raw = await readFile(this.path, "utf8");
56
+ }
57
+ catch (e) {
58
+ if (e.code === "ENOENT")
59
+ return DEFAULTS();
60
+ console.error(`Rushes: couldn't read the agent's rules at ${this.path}: ${e.message}. Every action asks until they are saved again.`);
61
+ return FAIL_CLOSED();
62
+ }
63
+ let parsed;
64
+ try {
65
+ parsed = AgentRulesReadSchema.safeParse(JSON.parse(raw));
66
+ }
67
+ catch {
68
+ parsed = null;
69
+ }
70
+ if (!parsed?.success) {
71
+ console.error(`Rushes: the agent's rules at ${this.path} are damaged. Every action asks until they are saved again.`);
72
+ return FAIL_CLOSED();
73
+ }
74
+ return parsed.data;
75
+ }
76
+ /** Read, change and write the rules, one change at a time. `fn` mutates the draft and may return a value. */
77
+ update(fn) {
78
+ const run = this.queue.catch(() => undefined).then(async () => {
79
+ const draft = await this.read();
80
+ const result = fn(draft);
81
+ const checked = AgentRulesSchema.safeParse(draft);
82
+ if (!checked.success)
83
+ throw new InvalidError("Change to the agent's rules is invalid", checked.error.issues);
84
+ const dir = dirname(this.path);
85
+ await mkdir(dir, { recursive: true, mode: 0o700 });
86
+ await chmod(dir, 0o700);
87
+ const tmp = `${this.path}.${process.pid}.${Date.now()}.${++writes}.tmp`;
88
+ await writeFile(tmp, JSON.stringify(checked.data, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
89
+ await rename(tmp, this.path);
90
+ return { data: checked.data, result };
91
+ });
92
+ this.queue = run;
93
+ return run;
94
+ }
95
+ }
96
+ const files = new WeakMap();
97
+ /** The one rules file for `store`'s project, shared by the runner and the routes so their writes queue together. */
98
+ export function agentRulesFor(store) {
99
+ let f = files.get(store);
100
+ if (!f) {
101
+ f = new AgentRulesFile(store.root);
102
+ files.set(store, f);
103
+ }
104
+ return f;
105
+ }