@botcord/daemon 0.2.5 → 0.2.8

package/dist/system-context.d.ts

@@ -6,10 +6,11 @@
  * `RuntimeRunOptions.systemContext`. This module composes the daemon's
  * system-context string from:
  *
- *   1. `[BotCord Scene: Owner Chat]` (owner-trust turns only)
- *   2. `[BotCord Working Memory]`
- *   3. `[BotCord Room Context]` (group rooms, via optional async fetcher)
- *   4. `[BotCord Cross-Room Awareness]` (optional activity tracker)
+ *   1. `[BotCord Identity]` (read fresh from workspace/identity.md each turn)
+ *   2. `[BotCord Scene: Owner Chat]` (owner-trust turns only)
+ *   3. `[BotCord Working Memory]`
+ *   4. `[BotCord Room Context]` (group rooms, via optional async fetcher)
+ *   5. `[BotCord Cross-Room Awareness]` (optional activity tracker)
  *
  * Behavior:
  *   - Working memory is loaded fresh per turn, so a `memory set` from another

package/dist/system-context.js

@@ -1,5 +1,6 @@
 import { buildCrossRoomDigest } from "./cross-room.js";
 import { buildWorkingMemoryPrompt, readWorkingMemory } from "./working-memory.js";
+import { readIdentity } from "./agent-workspace.js";
 import { classifyActivitySender } from "./sender-classify.js";
 import { log } from "./log.js";
 /**
@@ -25,6 +26,32 @@ function safeReadWorkingMemory(agentId) {
         return null;
     }
 }
+/**
+ * Read identity.md and wrap it as a system-context block. Placed before
+ * every other block so the agent answers "who are you" from this file
+ * rather than from the underlying CLI's default persona ("I am Claude
+ * Code"). Re-read every turn so dashboard reconcile (`applyAgentIdentity`)
+ * and self-edits take effect immediately, mirroring working-memory
+ * semantics.
+ */
+function buildIdentityPrompt(agentId) {
+    let raw = null;
+    try {
+        raw = readIdentity(agentId);
+    }
+    catch (err) {
+        log.warn("identity read failed", { agentId, err: String(err) });
+        return null;
+    }
+    if (!raw)
+        return null;
+    return [
+        "[BotCord Identity]",
+        "Your persistent identity card. The fields below are the source of truth — when asked who you are, what you do, or what you will / will not do, answer from this block, not from the underlying CLI's default persona.",
+        "",
+        raw.trim(),
+    ].join("\n");
+}
 /**
  * Build a {@link SystemContextBuilder} for the gateway dispatcher.
  *
@@ -34,6 +61,7 @@ function safeReadWorkingMemory(agentId) {
  */
 export function createDaemonSystemContextBuilder(deps) {
     const gatherSyncBlocks = (message) => {
+        const identity = buildIdentityPrompt(deps.agentId);
         const ownerScene = classifyActivitySender(message).kind === "owner"
             ? buildOwnerChatSceneContext()
             : null;
@@ -47,7 +75,7 @@ export function createDaemonSystemContextBuilder(deps) {
                 currentTopic: message.conversation.threadId ?? null,
             }) || null
             : null;
-        return { ownerScene, memory, digest };
+        return { identity, ownerScene, memory, digest };
     };
     const assemble = (parts) => {
         const filtered = parts.filter((p) => typeof p === "string" && p.length > 0);
@@ -70,11 +98,12 @@ export function createDaemonSystemContextBuilder(deps) {
     };
     if (!deps.roomContextBuilder) {
         const syncBuilder = (message) => {
-            const { ownerScene, memory, digest } = gatherSyncBlocks(message);
+            const { identity, ownerScene, memory, digest } = gatherSyncBlocks(message);
             // Loop-risk sits at the end so its "reply NO_REPLY unless…" guidance
             // is the last thing the model sees before the user turn body.
+            // Identity sits at the very front so it frames every other block.
             const loopRisk = runLoopRisk(message);
-            return assemble([ownerScene, memory, digest, loopRisk]);
+            return assemble([identity, ownerScene, memory, digest, loopRisk]);
         };
         // Compile-time witness that the narrower sync signature still satisfies
         // `SystemContextBuilder` (which allows async). Prevents the two contracts
@@ -85,11 +114,12 @@ export function createDaemonSystemContextBuilder(deps) {
     }
     const roomBuilder = deps.roomContextBuilder;
     const asyncBuilder = async (message) => {
-        const { ownerScene, memory, digest } = gatherSyncBlocks(message);
+        const { identity, ownerScene, memory, digest } = gatherSyncBlocks(message);
         // Room context landing order: after owner-scene / memory, before digest —
         // "what room am I in" belongs with the session's own identity, while the
         // cross-room digest deliberately describes OTHER rooms and should stay
         // last so it doesn't get confused with the current room.
+        // Identity stays at the very front; see syncBuilder for rationale.
         let roomBlock = null;
         try {
             roomBlock = await roomBuilder(message);
@@ -102,7 +132,7 @@ export function createDaemonSystemContextBuilder(deps) {
             });
         }
         const loopRisk = runLoopRisk(message);
-        return assemble([ownerScene, memory, roomBlock, digest, loopRisk]);
+        return assemble([identity, ownerScene, memory, roomBlock, digest, loopRisk]);
     };
     const _typecheck = asyncBuilder;
     void _typecheck;

package/dist/url-utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Append a `next` query param to a URL. Used by the device-code flow to
+ * encode a post-auth redirect target into the Hub-issued verification URL,
+ * so the dashboard knows where to send the user after they click Authorize.
+ *
+ * Falls back to returning the original URL string if parsing fails — the
+ * device-code flow keeps working, just without the redirect convenience.
+ */
+export declare function appendNextParam(url: string, next: string): string;

package/dist/url-utils.js

@@ -0,0 +1,18 @@
+/**
+ * Append a `next` query param to a URL. Used by the device-code flow to
+ * encode a post-auth redirect target into the Hub-issued verification URL,
+ * so the dashboard knows where to send the user after they click Authorize.
+ *
+ * Falls back to returning the original URL string if parsing fails — the
+ * device-code flow keeps working, just without the redirect convenience.
+ */
+export function appendNextParam(url, next) {
+    try {
+        const u = new URL(url);
+        u.searchParams.set("next", next);
+        return u.toString();
+    }
+    catch {
+        return url;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.5",
+  "version": "0.2.8",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {
@@ -27,7 +27,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@botcord/protocol-core": "^0.2.0",
+    "@botcord/cli": "^0.1.7",
+    "@botcord/protocol-core": "^0.2.2",
     "ws": "^8.18.0"
   },
   "devDependencies": {

package/src/__tests__/agent-workspace.test.ts

@@ -15,6 +15,7 @@ import {
   agentHomeDir,
   agentStateDir,
   agentWorkspaceDir,
+  applyAgentIdentity,
   ensureAgentWorkspace,
 } from "../agent-workspace.js";
 
@@ -134,6 +135,98 @@ describe("ensureAgentWorkspace", () => {
     });
   });
 
+  describe("applyAgentIdentity", () => {
+    it("rewrites display name + bio while preserving Role/Boundaries", () => {
+      ensureAgentWorkspace("ag_edit", {
+        displayName: "Old",
+        bio: "Old bio",
+        runtime: "claude-code",
+      });
+      const identityPath = path.join(agentWorkspaceDir("ag_edit"), "identity.md");
+      const original = readFileSync(identityPath, "utf8");
+      // User personalises Role/Boundaries — must survive identity sync.
+      const customised = original
+        .replace("_(Describe what you do and for whom. Edit this section.)_", "I write poetry.")
+        .replace("_(What you will and will not do. Edit this section.)_", "No financial advice.");
+      writeFileSync(identityPath, customised);
+
+      const result = applyAgentIdentity("ag_edit", {
+        displayName: "New Name",
+        bio: "Refreshed bio.",
+      });
+      expect(result.changed).toBe(true);
+
+      const updated = readFileSync(identityPath, "utf8");
+      expect(updated).toContain("- **Display name**: New Name");
+      expect(updated).toContain("Refreshed bio.");
+      expect(updated).not.toContain("Old bio");
+      expect(updated).toContain("I write poetry.");
+      expect(updated).toContain("No financial advice.");
+    });
+
+    it("clears bio back to placeholder when null is passed", () => {
+      ensureAgentWorkspace("ag_clearbio", { bio: "Some bio" });
+      const result = applyAgentIdentity("ag_clearbio", { bio: null });
+      expect(result.changed).toBe(true);
+      const updated = readFileSync(
+        path.join(agentWorkspaceDir("ag_clearbio"), "identity.md"),
+        "utf8",
+      );
+      expect(updated).not.toContain("Some bio");
+      expect(updated).toContain("_(none provided at provision time");
+    });
+
+    it("returns no-change when patch matches current values", () => {
+      ensureAgentWorkspace("ag_idempotent", { displayName: "Same", bio: "Same bio" });
+      const result = applyAgentIdentity("ag_idempotent", {
+        displayName: "Same",
+        bio: "Same bio",
+      });
+      expect(result.changed).toBe(false);
+      expect(result.skipped).toBe("no-change");
+    });
+
+    it("skips when identity.md is missing", () => {
+      const result = applyAgentIdentity("ag_missing", { displayName: "X" });
+      expect(result.changed).toBe(false);
+      expect(result.skipped).toBe("missing-file");
+    });
+
+    it("rewrites correctly when identity.md has no trailing sections after Bio", () => {
+      ensureAgentWorkspace("ag_eofbio", { displayName: "Old", bio: "Old bio" });
+      const identityPath = path.join(agentWorkspaceDir("ag_eofbio"), "identity.md");
+      // Strip everything after `## Bio` so the Bio section runs to EOF.
+      const truncated =
+        readFileSync(identityPath, "utf8").replace(/(## Bio\n\nOld bio)[\s\S]*$/, "$1\n");
+      writeFileSync(identityPath, truncated);
+
+      const result = applyAgentIdentity("ag_eofbio", { bio: "New bio" });
+      expect(result.changed).toBe(true);
+      const updated = readFileSync(identityPath, "utf8");
+      expect(updated).toContain("New bio");
+      expect(updated).not.toContain("Old bio");
+    });
+
+    it("returns unparseable when the canonical metadata header is missing", () => {
+      ensureAgentWorkspace("ag_corrupt", {});
+      const identityPath = path.join(agentWorkspaceDir("ag_corrupt"), "identity.md");
+      writeFileSync(identityPath, "# Identity\n\nThis file was rewritten by a user.\n");
+
+      const result = applyAgentIdentity("ag_corrupt", { displayName: "X" });
+      expect(result.changed).toBe(false);
+      expect(result.skipped).toBe("unparseable");
+    });
+
+    it("treats display names containing regex specials literally", () => {
+      ensureAgentWorkspace("ag_specials", { displayName: "old" });
+      const identityPath = path.join(agentWorkspaceDir("ag_specials"), "identity.md");
+      const result = applyAgentIdentity("ag_specials", { displayName: "$1 backref $&" });
+      expect(result.changed).toBe(true);
+      const updated = readFileSync(identityPath, "utf8");
+      expect(updated).toContain("- **Display name**: $1 backref $&");
+    });
+  });
+
   it("tightens perms on a pre-existing agent home with looser mode", () => {
     // Simulate a home dir created by an older daemon with mode 0o755.
     const home = agentHomeDir("ag_upgrade");

package/src/__tests__/daemon-config-map.test.ts

@@ -400,6 +400,27 @@ describe("buildManagedRoutes", () => {
     });
   });
 
+  it("inherits defaultRoute.extraArgs (e.g. --permission-mode bypassPermissions)", () => {
+    const withExtraArgs: GatewayRoute = {
+      runtime: "claude-code",
+      cwd: "/home/default",
+      extraArgs: ["--permission-mode", "bypassPermissions"],
+    };
+    const map = buildManagedRoutes(["ag_one"], {}, withExtraArgs);
+    expect(map.get("ag_one")?.extraArgs).toEqual([
+      "--permission-mode",
+      "bypassPermissions",
+    ]);
+    // Ensure it's a copy, not the same reference — caller should not be able
+    // to mutate the defaultRoute by editing a managed route's extraArgs.
+    expect(map.get("ag_one")?.extraArgs).not.toBe(withExtraArgs.extraArgs);
+  });
+
+  it("omits extraArgs when defaultRoute has none", () => {
+    const map = buildManagedRoutes(["ag_one"], {}, defaultRoute);
+    expect(map.get("ag_one")).not.toHaveProperty("extraArgs");
+  });
+
   it("preserves agentIds insertion order in the returned map", () => {
     const map = buildManagedRoutes(
       ["ag_b", "ag_a", "ag_c"],
@@ -414,3 +435,61 @@ describe("buildManagedRoutes", () => {
     expect(map.size).toBe(0);
   });
 });
+
+describe("openclawGateways resolution", () => {
+  it("resolves a route gateway profile name into ResolvedOpenclawGateway", () => {
+    const cfg = baseConfig({
+      defaultRoute: { adapter: "claude-code", cwd: "/home/alice" },
+      openclawGateways: [
+        { name: "local", url: "ws://127.0.0.1:1", token: "t1", defaultAgent: "main" },
+      ],
+      routes: [
+        { match: { conversationId: "rm_x" }, adapter: "openclaw-acp", cwd: "/home/alice", gateway: "local" },
+      ],
+    });
+    const gw = toGatewayConfig(cfg);
+    expect(gw.routes[0].gateway).toEqual({
+      name: "local",
+      url: "ws://127.0.0.1:1",
+      token: "t1",
+      openclawAgent: "main",
+    });
+  });
+
+  it("route.openclawAgent overrides profile.defaultAgent", () => {
+    const cfg = baseConfig({
+      openclawGateways: [{ name: "p1", url: "ws://x", defaultAgent: "main" }],
+      routes: [{ match: {}, adapter: "openclaw-acp", cwd: "/home/alice", gateway: "p1", openclawAgent: "design" }],
+    });
+    const gw = toGatewayConfig(cfg);
+    expect(gw.routes[0].gateway?.openclawAgent).toBe("design");
+  });
+
+  it("buildManagedRoutes uses credentials openclawGateway / openclawAgent", () => {
+    const cfg = baseConfig({
+      agents: ["ag_one"],
+      openclawGateways: [{ name: "p1", url: "ws://x", defaultAgent: "main" }],
+    });
+    const gw = toGatewayConfig(cfg, {
+      agentIds: ["ag_one"],
+      agentRuntimes: { ag_one: { runtime: "openclaw-acp", openclawGateway: "p1", openclawAgent: "qa" } },
+    });
+    const managed = gw.managedRoutes?.find((r) => r.match?.accountId === "ag_one");
+    expect(managed?.runtime).toBe("openclaw-acp");
+    expect(managed?.gateway?.name).toBe("p1");
+    expect(managed?.gateway?.openclawAgent).toBe("qa");
+  });
+
+  it("buildManagedRoutes skips an openclaw-acp managed route when its gateway is unknown", () => {
+    const cfg = baseConfig({
+      agents: ["ag_one"],
+      openclawGateways: [{ name: "p1", url: "ws://x" }],
+    });
+    const gw = toGatewayConfig(cfg, {
+      agentIds: ["ag_one"],
+      agentRuntimes: { ag_one: { runtime: "openclaw-acp", openclawGateway: "missing" } },
+    });
+    expect(gw.managedRoutes).toEqual([]);
+  });
+});
+

package/src/__tests__/openclaw-acp.test.ts

@@ -0,0 +1,234 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+import {
+  OpenclawAcpAdapter,
+  __resetOpenclawAcpPoolForTests,
+  buildAcpSessionKey,
+} from "../gateway/runtimes/openclaw-acp.js";
+import type { ResolvedOpenclawGateway } from "../gateway/types.js";
+
+class FakeChild extends EventEmitter {
+  stdin = new PassThrough();
+  stdout = new PassThrough();
+  stderr = new PassThrough();
+  killed = false;
+  kill(): void {
+    this.killed = true;
+  }
+}
+
+function makeSpawn(child: FakeChild): any {
+  return () => child as unknown as ReturnType<typeof import("node:child_process").spawn>;
+}
+
+function readFrames(child: FakeChild): Promise<any[]> {
+  return new Promise((resolve) => {
+    const frames: any[] = [];
+    child.stdin.on("data", (chunk: Buffer) => {
+      const lines = chunk.toString("utf8").split("\n").filter(Boolean);
+      for (const line of lines) frames.push(JSON.parse(line));
+    });
+    setTimeout(() => resolve(frames), 50);
+  });
+}
+
+afterEach(() => {
+  __resetOpenclawAcpPoolForTests();
+});
+
+describe("buildAcpSessionKey", () => {
+  it("includes accountId so two daemon agents can't collide on a gateway key", () => {
+    const a = buildAcpSessionKey({
+      openclawAgent: "main",
+      accountId: "ag_alice",
+      conversationKey: "rm_x",
+    });
+    const b = buildAcpSessionKey({
+      openclawAgent: "main",
+      accountId: "ag_bob",
+      conversationKey: "rm_x",
+    });
+    expect(a).not.toBe(b);
+    expect(a).toContain("ag_alice");
+    expect(b).toContain("ag_bob");
+  });
+});
+
+describe("OpenclawAcpAdapter.run", () => {
+  it("fails fast when gateway is not provided", async () => {
+    const adapter = new OpenclawAcpAdapter({ spawnFn: makeSpawn(new FakeChild()) });
+    const res = await adapter.run({
+      text: "hi",
+      sessionId: null,
+      cwd: "/tmp",
+      accountId: "ag_alice",
+      signal: new AbortController().signal,
+      trustLevel: "owner",
+    });
+    expect(res.error).toMatch(/missing gateway/);
+  });
+
+  it("fails when gateway has no openclawAgent resolved", async () => {
+    const adapter = new OpenclawAcpAdapter({ spawnFn: makeSpawn(new FakeChild()) });
+    const gateway: ResolvedOpenclawGateway = {
+      name: "local",
+      url: "ws://127.0.0.1:1",
+    };
+    const res = await adapter.run({
+      text: "hi",
+      sessionId: null,
+      cwd: "/tmp",
+      accountId: "ag_alice",
+      signal: new AbortController().signal,
+      trustLevel: "owner",
+      gateway,
+    });
+    expect(res.error).toMatch(/openclawAgent/);
+  });
+
+  it("performs initialize → newSession → prompt and returns final text", async () => {
+    const child = new FakeChild();
+    const spawnFn = vi.fn().mockReturnValue(child);
+    const adapter = new OpenclawAcpAdapter({ spawnFn: spawnFn as any });
+    const gateway: ResolvedOpenclawGateway = {
+      name: "local",
+      url: "ws://127.0.0.1:1",
+      openclawAgent: "main",
+    };
+
+    // Seed the child stdout with replies as soon as stdin is written.
+    let nextSessionId = "acp-uuid-1";
+    let promptId: number | null = null;
+    child.stdin.on("data", (chunk: Buffer) => {
+      for (const line of chunk.toString("utf8").split("\n").filter(Boolean)) {
+        const frame = JSON.parse(line);
+        if (frame.method === "initialize") {
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { protocolVersion: 1 } }) + "\n");
+        } else if (frame.method === "session/new") {
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { sessionId: nextSessionId } }) + "\n");
+        } else if (frame.method === "session/prompt") {
+          promptId = frame.id;
+          // Stream a chunk then resolve.
+          child.stdout.write(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              method: "session/update",
+              params: {
+                sessionId: nextSessionId,
+                update: { sessionUpdate: "agent_message_chunk", content: { text: "hello world" } },
+              },
+            }) + "\n",
+          );
+          setTimeout(() => {
+            child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: promptId, result: { text: "hello world" } }) + "\n");
+          }, 5);
+        }
+      }
+    });
+
+    const blocks: any[] = [];
+    const res = await adapter.run({
+      text: "hi",
+      sessionId: null,
+      cwd: "/tmp",
+      accountId: "ag_alice",
+      signal: new AbortController().signal,
+      trustLevel: "owner",
+      gateway,
+      onBlock: (b) => blocks.push(b),
+    });
+
+    expect(res.error).toBeUndefined();
+    expect(res.text).toBe("hello world");
+    expect(res.newSessionId).toBe("acp-uuid-1");
+    expect(blocks.length).toBeGreaterThan(0);
+    expect(blocks[0].kind).toBe("assistant_text");
+    expect(spawnFn).toHaveBeenCalledTimes(1);
+    expect(spawnFn.mock.calls[0][1]).toEqual(["acp", "--url", "ws://127.0.0.1:1"]);
+  });
+
+  it("respawns the pooled child when gateway.url or gateway.token changes under the same name", async () => {
+    function newChild(): FakeChild {
+      const c = new FakeChild();
+      c.stdin.on("data", (chunk: Buffer) => {
+        for (const line of chunk.toString("utf8").split("\n").filter(Boolean)) {
+          const frame = JSON.parse(line);
+          if (frame.method === "initialize") {
+            c.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: {} }) + "\n");
+          } else if (frame.method === "session/new") {
+            c.stdout.write(
+              JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { sessionId: "s" } }) + "\n",
+            );
+          } else if (frame.method === "session/prompt") {
+            c.stdout.write(
+              JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { text: "ok" } }) + "\n",
+            );
+          }
+        }
+      });
+      return c;
+    }
+    const children = [newChild(), newChild(), newChild()];
+    const spawnFn = vi.fn().mockImplementation(() => children.shift()! as any);
+    const adapter = new OpenclawAcpAdapter({ spawnFn: spawnFn as any });
+    const baseOpts = {
+      text: "hi",
+      sessionId: null,
+      cwd: "/tmp",
+      accountId: "ag_alice",
+      signal: new AbortController().signal,
+      trustLevel: "owner" as const,
+    };
+    await adapter.run({
+      ...baseOpts,
+      gateway: { name: "p1", url: "ws://a", token: "t1", openclawAgent: "main" },
+    });
+    await adapter.run({
+      ...baseOpts,
+      gateway: { name: "p1", url: "ws://b", token: "t1", openclawAgent: "main" },
+    });
+    await adapter.run({
+      ...baseOpts,
+      gateway: { name: "p1", url: "ws://b", token: "t2", openclawAgent: "main" },
+    });
+    expect(spawnFn).toHaveBeenCalledTimes(3);
+  });
+
+  it("reuses the pooled child for the same (accountId, gateway)", async () => {
+    const child = new FakeChild();
+    const spawnFn = vi.fn().mockReturnValue(child);
+    const adapter = new OpenclawAcpAdapter({ spawnFn: spawnFn as any });
+    const gateway: ResolvedOpenclawGateway = {
+      name: "local",
+      url: "ws://127.0.0.1:1",
+      openclawAgent: "main",
+    };
+
+    child.stdin.on("data", (chunk: Buffer) => {
+      for (const line of chunk.toString("utf8").split("\n").filter(Boolean)) {
+        const frame = JSON.parse(line);
+        if (frame.method === "initialize") {
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { protocolVersion: 1 } }) + "\n");
+        } else if (frame.method === "session/new") {
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { sessionId: "s1" } }) + "\n");
+        } else if (frame.method === "session/prompt") {
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { text: "ok" } }) + "\n");
+        }
+      }
+    });
+
+    const opts = {
+      text: "hi",
+      sessionId: null,
+      cwd: "/tmp",
+      accountId: "ag_alice",
+      signal: new AbortController().signal,
+      trustLevel: "owner" as const,
+      gateway,
+    };
+    await adapter.run(opts);
+    await adapter.run({ ...opts, sessionId: "s1" });
+    expect(spawnFn).toHaveBeenCalledTimes(1);
+  });
+});