@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/gateway/connectors/kilo-cli.ts

@@ -0,0 +1,434 @@
+// Gateway connector for Kilo CLI (`kilo`, Kilo-Org/kilocode, an OpenCode fork). Checked against Kilo CLI 7.8.28 (the copy
+// in ~/.cache/brain-wire/kilo-code, `kilo --version`), its source at Kilo-Org/kilocode main (package version 7.8.28) and
+// https://kilo.ai/docs/code-with-ai/platforms/cli. The Kilo Code VS Code extension (7.x) runs this same CLI and reads the
+// same file: its connector (kilo-code.ts) is built from the factory below.
+//
+// Where Kilo reads its settings:
+//   ~/.config/kilo/ (`kilo debug paths`: config = $XDG_CONFIG_HOME/kilo, else ~/.config/kilo; macOS too). Every one of
+//   config.json, kilo.json, kilo.jsonc, opencode.json, opencode.jsonc found there is read and merged, a later one winning
+//   (the binary's GLOBAL_CONFIG_FILES list; checked by running `kilo debug config` with a different "model" in each:
+//   opencode.jsonc wins, then opencode.json, kilo.jsonc, kilo.json). Each is JSON with comments and trailing commas
+//   (jsonc-parser, allowTrailingComma). Kilo writes ~/.config/kilo/kilo.jsonc on its first run ({"$schema": ...}), and its
+//   own settings writer (Config.updateGlobal) edits the first of kilo.jsonc, kilo.json, opencode.jsonc, opencode.json,
+//   config.json that exists. A project's kilo.json(c), opencode.json(c) or .kilo/ folder outranks all of these.
+//   Docs: "Global: ~/.config/kilo/kilo.json[c] or legacy opencode.json[c]"; "Project-level configuration takes precedence".
+//
+// What is written, in the global file with the highest rank that exists (so the model set there is the one Kilo uses; a
+// new kilo.jsonc when there is none), or in the one that already holds brain's provider (so disconnect finds it again):
+//   provider.brain-gateway   {"npm": "@ai-sdk/openai-compatible", "name": "100xprompt gateway",
+//                             "options": {"baseURL": "<route>/v1", "apiKey": "{file:<keyPath>}", "headers": {...}},
+//                             "models": {"<model id>": {"name": "100xprompt Pro"}}}
+//                            the shape the Kilo Code extension itself saves for a custom provider (kilo-vscode
+//                            src/provider-actions.ts saveCustomProvider writes provider.<id> to the global config).
+//                            OpenAI Chat Completions with Authorization: Bearer; the openai-compatible SDK is bundled in
+//                            the binary (no download). A model list is given, so /v1/models (403 at the gateway) is not
+//                            needed. options.headers is sent with every model request (x-100x-context-edit: on).
+//   model                    "brain-gateway/<model id>": the default model of `kilo run`, the TUI and new Kilo Code
+//                            sessions (kilo-vscode provider-actions.ts computeDefaultSelection: config.model first, the
+//                            VS Code setting kilo-code.new.model.* only when the config names none).
+// The key: {file:<path>} in a global (trusted) config is replaced with that file's text, trimmed, when Kilo loads it
+// (docs: "{env:VAR} (and {file:...}) references are resolved only in trusted config"; the binary's config substitution). So
+// the key is read from brain's key file at each start and never copied. If that file is missing (after `brain gateway
+// logout`), Kilo refuses the whole config ("Configuration is invalid ... bad file reference") until the next sign-in or a
+// disconnect: checked with the binary.
+//
+// Checked end to end with the 7.8.28 binary against the local stand-in gateway (scripts/gateway-real/kilo-cli.ts): the
+// request came in on /flash/v1/chat/completions with "Authorization: Bearer <key>", x-100x-context-edit: on and the
+// gateway's model id.
+//
+// The core's JSON handling refuses comments, and Kilo's files have them, so this file has its own codec (jsoncInPlace):
+// it reads JSON with comments and trailing commas, and changes only the members brain owns, in place; every other byte
+// stays, and a member brain added is removed with exactly the text it brought, so disconnect gives back the exact bytes.
+// Before any change it makes a trial edit and refuses a file where that would not land exactly on brain's members.
+import { existsSync, readFileSync } from "node:fs"
+import { isAbsolute, join, resolve } from "node:path"
+import { type Codec, type Connector, EDIT_HEADER, type Env, getAt, type Json, keyPath, modelName, routeUrl } from "../common.ts"
+
+// ---- JSON with comments, edited in place --------------------------------------------------------------------------------
+
+interface Member {
+  key: string
+  keyStart: number
+  valueStart: number
+  valueEnd: number
+  /** The comma after the value (a separator or a trailing comma), or -1. */
+  comma: number
+  value: Node
+}
+type ObjectNode = { kind: "object"; start: number; end: number; members: Member[] }
+type Node = ObjectNode | { kind: "array" | "value"; start: number; end: number }
+
+const WS = /[ \t\n\r\v\f\u00a0\ufeff\u2028\u2029]/
+
+/** Positions and value of a JSON-with-comments text (comments, trailing commas; throws on anything else). */
+function scan(text: string): { node: Node; value: unknown } {
+  let i = 0
+  const fail = (what: string): never => {
+    throw new Error(`${what} at offset ${i}`)
+  }
+  const skip = () => {
+    for (;;) {
+      if (i < text.length && WS.test(text[i]!)) i++
+      else if (text.startsWith("//", i)) {
+        const n = text.indexOf("\n", i)
+        i = n < 0 ? text.length : n
+      } else if (text.startsWith("/*", i)) {
+        const n = text.indexOf("*/", i + 2)
+        if (n < 0) fail("unclosed comment")
+        i = n + 2
+      } else return
+    }
+  }
+  const string = (): string => {
+    const start = i
+    i++
+    while (i < text.length && text[i] !== '"') i += text[i] === "\\" ? 2 : 1
+    if (i >= text.length) fail("unclosed string")
+    i++
+    try {
+      return JSON.parse(text.slice(start, i)) as string
+    } catch {
+      return fail("bad string")
+    }
+  }
+  const value = (): { node: Node; value: unknown } => {
+    skip()
+    const start = i
+    const c = text[i]
+    if (c === "{") {
+      i++
+      const members: Member[] = []
+      const obj: Json = {}
+      for (;;) {
+        skip()
+        if (text[i] === "}") break
+        if (text[i] !== '"') fail("expected a key")
+        const keyStart = i
+        const key = string()
+        skip()
+        if (text[i] !== ":") fail("expected ':'")
+        i++
+        skip()
+        const valueStart = i
+        const v = value()
+        const m: Member = { key, keyStart, valueStart, valueEnd: i, comma: -1, value: v.node }
+        members.push(m)
+        obj[key] = v.value
+        skip()
+        if (text[i] === ",") {
+          m.comma = i
+          i++
+          continue
+        }
+        if (text[i] !== "}") fail("expected ',' or '}'")
+      }
+      i++
+      return { node: { kind: "object", start, end: i, members }, value: obj }
+    }
+    if (c === "[") {
+      i++
+      const arr: unknown[] = []
+      for (;;) {
+        skip()
+        if (text[i] === "]") break
+        arr.push(value().value)
+        skip()
+        if (text[i] === ",") {
+          i++
+          continue
+        }
+        if (text[i] !== "]") fail("expected ',' or ']'")
+      }
+      i++
+      return { node: { kind: "array", start, end: i }, value: arr }
+    }
+    if (c === '"') {
+      const s = string()
+      return { node: { kind: "value", start, end: i }, value: s }
+    }
+    const lit = /^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)/.exec(text.slice(i, i + 400))
+    if (!lit) fail("unexpected character")
+    i += lit![0].length
+    return { node: { kind: "value", start, end: i }, value: JSON.parse(lit![0]) }
+  }
+  const out = value()
+  skip()
+  if (i < text.length) fail("text after the value")
+  return out
+}
+
+const lineStart = (text: string, pos: number) => text.lastIndexOf("\n", pos - 1) + 1
+const indentAt = (text: string, pos: number) => /^[ \t]*/.exec(text.slice(lineStart(text, pos)))![0]
+const startsLine = (text: string, pos: number) => /^[ \t]*$/.test(text.slice(lineStart(text, pos), pos))
+const unitOf = (text: string) => /\n([ \t]+)["/]/.exec(text)?.[1] ?? "  "
+const eolOf = (text: string) => (text.includes("\r\n") ? "\r\n" : "\n")
+/** `value` as JSON: on one line inside a one-line object, else spread over lines under `indent`. */
+const render = (text: string, v: unknown, indent: string, oneLine: boolean) =>
+  oneLine ? JSON.stringify(v) : JSON.stringify(v, null, unitOf(text)).replace(/\n/g, eolOf(text) + indent)
+/** Where a key appears twice, JSON readers keep the last: that is the one brain reads and changes. */
+const lastIndex = (o: ObjectNode, key: string) => {
+  for (let j = o.members.length - 1; j >= 0; j--) if (o.members[j]!.key === key) return j
+  return -1
+}
+const lastMember = (o: ObjectNode, key: string) => o.members[lastIndex(o, key)]
+const oneLineObject = (text: string, o: ObjectNode) => !text.slice(o.start, o.end).includes("\n")
+
+function insert(text: string, o: ObjectNode, key: string, v: unknown): string {
+  const eol = eolOf(text)
+  const last = o.members[o.members.length - 1]
+  if (!last) {
+    const outer = indentAt(text, o.start)
+    const inner = outer + unitOf(text)
+    const interior = text.slice(o.start + 1, o.end - 1)
+    // A file written on one line stays on one line.
+    if (!text.trim().includes("\n")) return `${text.slice(0, o.start + 1)}${JSON.stringify(key)}: ${JSON.stringify(v)}${text.slice(o.start + 1)}`
+    const member = `${JSON.stringify(key)}: ${render(text, v, inner, false)}`
+    // An empty object: `{}` becomes `{\n  "key": value\n}`; one holding only comments keeps them after the new member.
+    if (/^\s*$/.test(interior)) return `${text.slice(0, o.start + 1)}${eol}${inner}${member}${eol}${outer}${text.slice(o.end - 1)}`
+    return `${text.slice(0, o.start + 1)}${eol}${inner}${member}${text.slice(o.start + 1)}`
+  }
+  const flat = !startsLine(text, last.keyStart) || oneLineObject(text, o)
+  const indent = indentAt(text, last.keyStart)
+  const member = `${JSON.stringify(key)}: ${render(text, v, indent, flat)}`
+  // After a trailing comma the new member keeps that style (`"b": 2,`); otherwise it gets the comma before it. Either
+  // way the text added is exactly what remove() takes out again.
+  if (last.comma >= 0) return `${text.slice(0, last.comma + 1)}${flat ? " " : eol + indent}${member},${text.slice(last.comma + 1)}`
+  return `${text.slice(0, last.valueEnd)},${flat ? " " : eol + indent}${member}${text.slice(last.valueEnd)}`
+}
+
+function remove(text: string, o: ObjectNode, at: number): string {
+  const m = o.members[at]!
+  const prev = o.members[at - 1]
+  const next = o.members[at + 1]
+  const end = m.comma >= 0 ? m.comma + 1 : m.valueEnd
+  if (prev) {
+    // The last member with a trailing comma: the comma before it stays as the trailing comma of the one before.
+    if (!next && m.comma >= 0) return text.slice(0, prev.comma + 1) + text.slice(end)
+    return text.slice(0, prev.comma) + text.slice(m.valueEnd)
+  }
+  if (next) {
+    let j = end
+    while (j < next.keyStart && WS.test(text[j]!)) j++
+    return text.slice(0, m.keyStart) + text.slice(j)
+  }
+  const before = text.slice(o.start + 1, m.keyStart)
+  const after = text.slice(end, o.end - 1)
+  if (/^\s*$/.test(before) && /^\s*$/.test(after)) return text.slice(0, o.start + 1) + text.slice(o.end - 1)
+  if (/^\s*$/.test(before)) return text.slice(0, o.start + 1) + text.slice(end)
+  return text.slice(0, m.keyStart) + text.slice(end)
+}
+
+/** The object at `path` (each step the last member of that name), or undefined. */
+function objectAt(root: ObjectNode, path: string[]): ObjectNode | undefined {
+  let o: ObjectNode = root
+  for (const p of path) {
+    const m = lastMember(o, p)
+    if (!m || m.value.kind !== "object") return undefined
+    o = m.value
+  }
+  return o
+}
+
+function setPath(text: string, path: string[], v: unknown): string {
+  const root = scan(text).node as ObjectNode
+  if (v === undefined) {
+    const parent = objectAt(root, path.slice(0, -1))
+    const at = parent ? lastIndex(parent, path[path.length - 1]!) : -1
+    if (!parent || at < 0) return text
+    let out = remove(text, parent, at)
+    // Objects this left empty (nothing in them, not even a comment) go too, as JSON connectors drop them; never the root.
+    for (let d = path.length - 1; d >= 1; d--) {
+      const r = scan(out).node as ObjectNode
+      const o = objectAt(r, path.slice(0, d))
+      const holder = objectAt(r, path.slice(0, d - 1))
+      if (!o || !holder || o.members.length || !/^\s*$/.test(out.slice(o.start + 1, o.end - 1))) break
+      out = remove(out, holder, lastIndex(holder, path[d - 1]!))
+    }
+    return out
+  }
+  let o = root
+  for (let d = 0; d < path.length; d++) {
+    const m = lastMember(o, path[d]!)
+    // What is still missing below this point is added as one nested value.
+    const rest = path.slice(d + 1).reduceRight<unknown>((acc, k) => ({ [k]: acc }), v)
+    if (d === path.length - 1 || !m || m.value.kind !== "object") {
+      if (!m) return insert(text, o, path[d]!, rest)
+      const flat = oneLineObject(text, o) || !startsLine(text, m.keyStart)
+      return text.slice(0, m.valueStart) + render(text, rest, indentAt(text, m.keyStart), flat) + text.slice(m.valueEnd)
+    }
+    o = m.value
+  }
+  return text
+}
+
+const parse = (text: string): unknown => (text.trim() ? scan(text).value : {})
+const same = (a: unknown, b: unknown) => JSON.stringify(a) === JSON.stringify(b)
+/**
+ * What `parse` gives after `key` is set to `v`; undefined removes it, and with `dropEmpty` also the objects that leaves
+ * empty (setPath keeps one that still holds a comment).
+ */
+function expected(obj: Json, path: string[], v: unknown, dropEmpty = true): Json {
+  const o = structuredClone(obj)
+  let cur: any = o
+  if (v === undefined) {
+    const chain: any[] = [o]
+    for (const p of path.slice(0, -1)) {
+      cur = cur?.[p]
+      chain.push(cur)
+    }
+    if (cur && typeof cur === "object") delete cur[path[path.length - 1]!]
+    for (let d = path.length - 1; dropEmpty && d >= 1; d--) {
+      const c = chain[d]
+      if (c && typeof c === "object" && !Array.isArray(c) && !Object.keys(c).length) delete chain[d - 1][path[d - 1]!]
+      else break
+    }
+    return o
+  }
+  for (const p of path.slice(0, -1)) {
+    if (!cur[p] || typeof cur[p] !== "object" || Array.isArray(cur[p])) cur[p] = {}
+    cur = cur[p]
+  }
+  cur[path[path.length - 1]!] = v
+  return o
+}
+
+/**
+ * A codec for a JSON file that may hold comments and trailing commas, edited in place: keys are paths with "/"
+ * (provider/brain-gateway). `trial` lists keys with a value like the one that will be written: check() refuses a file
+ * where setting or removing them would not give exactly the expected result.
+ */
+export function jsoncInPlace(trial: Record<string, unknown> = {}, extraCheck?: (obj: Json) => string | undefined): Codec {
+  const codec: Codec = {
+    check(text) {
+      if (!text.trim()) return undefined
+      let obj: unknown
+      try {
+        obj = scan(text).value
+      } catch (e) {
+        return `it is not valid JSON with comments (${(e as Error).message}); left as it is`
+      }
+      if (!obj || typeof obj !== "object" || Array.isArray(obj)) return "it is not a JSON object; left as it is"
+      const more = extraCheck?.(obj as Json)
+      if (more) return more
+      // A trial edit of every key brain owns, and its undoing, must land exactly where expected.
+      for (const [key, v] of Object.entries(trial)) {
+        const path = key.split("/")
+        const shown = key.replace(/\//g, ".")
+        try {
+          const set = setPath(text, path, v)
+          const after = parse(set) as Json
+          if (!same(after, expected(obj as Json, path, v))) return `brain could not place ${shown} in it safely; left as it is`
+          const was = getAt(obj as Json, key)
+          const back = parse(setPath(set, path, was))
+          const ok = was === undefined ? same(back, expected(after, path, undefined)) || same(back, expected(after, path, undefined, false)) : same(back, obj)
+          if (!ok) return `brain could not undo a change to ${shown} in it safely; left as it is`
+        } catch {
+          return `brain could not edit ${shown} in it safely; left as it is`
+        }
+      }
+      return undefined
+    },
+    get(text, key) {
+      return getAt(parse(text) as Json, key)
+    },
+    set(text, key, value) {
+      const bom = text.startsWith("\ufeff") ? "\ufeff" : ""
+      const body = bom ? text.slice(1) : text
+      if (!body.trim()) {
+        if (value === undefined) return text
+        return `${bom}${setPath("{\n}", key.split("/"), value)}\n`
+      }
+      return bom + setPath(body, key.split("/"), value)
+    },
+  }
+  return codec
+}
+
+// ---- Kilo -------------------------------------------------------------------------------------------------------------
+
+/** The global config files, lowest rank first: a later one wins where two set the same key. */
+export const KILO_CONFIG_FILES = ["config.json", "kilo.json", "kilo.jsonc", "opencode.json", "opencode.jsonc"]
+const PROVIDER = "brain-gateway"
+
+/** Kilo's global config folder, as Kilo resolves it; $XDG_CONFIG_HOME describes the person's real home, so it counts only there. */
+export function kiloConfigDir(home: string, env: Env): string {
+  const own = !!env.HOME && resolve(env.HOME) === resolve(home)
+  const x = env.XDG_CONFIG_HOME
+  return own && x && isAbsolute(x) ? join(x, "kilo") : join(home, ".config", "kilo")
+}
+
+function holdsProvider(path: string): boolean {
+  try {
+    return getAt(parse(readFileSync(path, "utf8")) as Json, `provider/${PROVIDER}`) !== undefined
+  } catch {
+    return false
+  }
+}
+
+/**
+ * The file brain edits: the one that already holds brain's provider (connected earlier), else the global file with the
+ * highest rank that exists (its "model" is the one Kilo uses), else a new kilo.jsonc (the file Kilo itself creates).
+ */
+export function kiloConfigFile(home: string, env: Env): string {
+  const dir = kiloConfigDir(home, env)
+  const present = KILO_CONFIG_FILES.map((n) => join(dir, n)).filter((p) => existsSync(p))
+  return present.find(holdsProvider) ?? present[present.length - 1] ?? join(dir, "kilo.jsonc")
+}
+
+/**
+ * A config that would keep brain's provider from loading: disabled by name, or left out of an allow-list. Asked only
+ * before brain's provider is there (a disconnect must still be able to take it out).
+ */
+function providerAllowed(obj: Json): string | undefined {
+  if (getAt(obj, `provider/${PROVIDER}`) !== undefined) return undefined
+  const off = obj.disabled_providers
+  if (Array.isArray(off) && off.includes(PROVIDER)) return `its disabled_providers turns off "${PROVIDER}"; left as it is`
+  const on = obj.enabled_providers
+  if (Array.isArray(on) && !on.includes(PROVIDER)) return `its enabled_providers allows only the providers it names (not "${PROVIDER}"); add "${PROVIDER}" there to connect`
+  return undefined
+}
+
+const kiloCodec = jsoncInPlace(
+  {
+    [`provider/${PROVIDER}`]: { npm: "@ai-sdk/openai-compatible", name: "100xprompt gateway", options: { baseURL: "https://x/v1", apiKey: "{file:/x}", headers: { [EDIT_HEADER]: "on" } }, models: { m: { name: "m" } } },
+    model: `${PROVIDER}/m`,
+  },
+  providerAllowed,
+)
+
+/** One Kilo connector: Kilo CLI and the Kilo Code extension read the same file, so both are built here. */
+export function kiloConnector(id: string, label: string, notes: string[]): Connector {
+  return {
+    id,
+    label,
+    file: kiloConfigFile,
+    // Kilo's data folder (sessions, auth.json): made by the CLI and by the extension's bundled CLI on their first run.
+    probe: [".local/share/kilo"],
+    authHeader: "authorization",
+    edits: (home, s, env) => [
+      {
+        path: kiloConfigFile(home, env),
+        format: "custom",
+        codec: kiloCodec,
+        values: {
+          [`provider/${PROVIDER}`]: {
+            npm: "@ai-sdk/openai-compatible",
+            name: "100xprompt gateway",
+            options: { baseURL: `${routeUrl(s)}/v1`, apiKey: `{file:${keyPath(home)}}`, ...(s.contextEdit ? { headers: { [EDIT_HEADER]: "on" } } : {}) },
+            models: { [s.model]: { name: modelName(s.model) } },
+          },
+          model: `${PROVIDER}/${s.model}`,
+        },
+      },
+    ],
+    notes,
+  }
+}
+
+export const KILO_SHARED_NOTE =
+  "Kilo CLI and the Kilo Code extension (7.x, which runs the same CLI) read this one file: connecting either points both at the gateway, and disconnect puts back what was there before."
+export const KILO_KEY_NOTE =
+  "Kilo reads the key from the brain's key file each time it starts ({file:...}); nothing is copied. Without that file (after brain gateway logout) Kilo will not start until you sign in again or disconnect."
+const KILO_PROJECT_NOTE = "A project's own kilo.json(c), opencode.json(c) or .kilo/ config outranks this file there; sessions already open keep the model they started with."
+
+export const connectors: Connector[] = [kiloConnector("kilo-cli", "Kilo CLI", [KILO_KEY_NOTE, KILO_SHARED_NOTE, KILO_PROJECT_NOTE])]

package/src/gateway/connectors/kilo-code.ts

@@ -0,0 +1,32 @@
+// Gateway connector for Kilo Code, the VS Code extension (kilocode.kilo-code; also installable in Cursor and Windsurf).
+// Checked against Kilo Code 7.8.28: its source at Kilo-Org/kilocode main (packages/kilo-vscode/package.json version
+// 7.8.28) and the Kilo CLI binary of the same version that the extension bundles (~/.cache/brain-wire/kilo-code, the
+// copy the wire harness drives as the extension's <extension>/bin/kilo).
+//
+// Since 7.x the extension is a client of the Kilo CLI: it starts its bundled `bin/kilo serve` and the agent runs there
+// (https://kilo.ai/docs/contributing/architecture/vscode-extension: "Agent runtime behavior belongs in CLI config so TUI,
+// Console, VS Code, and JetBrains can share it"). Providers, models and keys therefore live in the Kilo CLI's global
+// config, ~/.config/kilo/kilo.jsonc and its siblings; the extension's own "Custom provider" dialog writes provider.<id>
+// there too (kilo-vscode src/provider-actions.ts saveCustomProvider -> client.global.config.update). Its VS Code settings
+// are only kilo-code.new.* (UI, autocomplete, and a fallback default model); 7.8.28 has no autoImportSettingsPath. A new
+// session starts on the config's "model" (provider-actions.ts computeDefaultSelection: config.model, then the VS Code
+// setting kilo-code.new.model.providerID/modelID, then Kilo's own auto model; KiloProvider.ts fetchAndSendProviders).
+//
+// So this connector edits exactly what the Kilo CLI connector edits (kilo-cli.ts: provider.brain-gateway reading the key
+// from brain's key file with {file:...}, and model), in the same file: nothing goes into VS Code's settings, state or
+// keychain, and disconnect gives back the file's exact bytes. Connecting one of the two also points the other at the
+// gateway; connecting both is fine (each records what it found and puts that back).
+//
+// Older Kilo Code releases (the Roo Code-based extension, before 7) keep providers in VS Code's own storage and keys in its
+// keychain, like Roo Code (see roo.ts for why brain does not write those); they do not create ~/.config/kilo, so connect
+// refuses there ("has not been run on this machine").
+import type { Connector } from "../common.ts"
+import { KILO_KEY_NOTE, KILO_SHARED_NOTE, kiloConnector } from "./kilo-cli.ts"
+
+export const connectors: Connector[] = [
+  kiloConnector("kilo-code", "Kilo Code", [
+    "Kilo Code 7 runs the Kilo CLI it bundles, which reads this file: nothing goes into VS Code's settings or keychain. New chats start on the gateway's model (this file's model comes before the extension's default-model setting); open chats keep theirs.",
+    KILO_KEY_NOTE,
+    KILO_SHARED_NOTE,
+  ]),
+]