@scp-dev/cli 0.0.0-stage → 0.1.2

package/dist/chunk-6UFMKYPH.js

@@ -0,0 +1,255 @@
+import {
+  activeRelay,
+  checkRelayUrl,
+  configDir,
+  relayCredential,
+  writePrivateJson
+} from "./chunk-4QYUPPGV.js";
+import {
+  RelayUsage
+} from "./chunk-7KP6TAJW.js";
+import {
+  note,
+  printTable
+} from "./chunk-DA3EB2YF.js";
+
+// src/remote.ts
+import { existsSync, readFileSync, rmSync } from "fs";
+import { join } from "path";
+import { CLI_NAME, parsePolicy, PROTOCOL, RelayError } from "@scp-dev/core";
+import { MACHINE_NAME } from "@scp-dev/hub";
+import { relaySocketUrl, thisHostname } from "@scp-dev/broker";
+var CloudUsage = class extends RelayUsage {
+};
+var CloudRelayClient = class _CloudRelayClient {
+  constructor(ws) {
+    this.ws = ws;
+  }
+  ws;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  listeners = [];
+  closedError;
+  static async connect(origin, token) {
+    const url = relaySocketUrl(origin);
+    const ws = new WebSocket(url, { headers: { Authorization: `Bearer ${token}` } });
+    const client = new _CloudRelayClient(ws);
+    await new Promise((resolve, reject) => {
+      ws.addEventListener("open", () => resolve());
+      ws.addEventListener("error", () => reject(new RelayError("unavailable", `could not connect to the relay at ${url} (check SCP_RELAY and your login)`)));
+    });
+    ws.addEventListener("message", (event) => client.onFrame(String(event.data)));
+    ws.addEventListener("close", (event) => {
+      const reason = event.reason ? `: ${event.reason}` : "";
+      client.fail(
+        event.code === 1008 ? new RelayError("unauthorized", `the relay closed the connection${reason}`) : new RelayError("unavailable", `the relay closed the connection (${event.code}${reason})`)
+      );
+    });
+    return client;
+  }
+  onNotification(fn) {
+    this.listeners.push(fn);
+  }
+  request(method, params = {}) {
+    if (this.closedError) return Promise.reject(this.closedError);
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.ws.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
+    });
+  }
+  close() {
+    this.fail(new RelayError("unavailable", "the connection is closed"));
+    if (this.ws.readyState <= 1) this.ws.close(1e3, "done");
+  }
+  onFrame(text) {
+    let frame;
+    try {
+      frame = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (frame.method) {
+      for (const fn of this.listeners) fn(frame.method, frame.params);
+      return;
+    }
+    const waiter = frame.id !== void 0 ? this.pending.get(frame.id) : void 0;
+    if (!waiter) return;
+    this.pending.delete(frame.id);
+    if (frame.error) waiter.reject(new RelayError(frame.error.data?.code ?? "invalid_params", frame.error.message, frame.error.data?.retry_after));
+    else waiter.resolve(frame.result);
+  }
+  fail(error) {
+    if (this.closedError) return;
+    this.closedError = error;
+    for (const waiter of this.pending.values()) waiter.reject(error);
+    this.pending.clear();
+  }
+};
+function hostMachine() {
+  const name = thisHostname().split(".")[0].toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
+  return MACHINE_NAME.test(name) && name !== "me" ? name : "machine";
+}
+function machineName(flag, env = process.env) {
+  const name = flag ?? env.SCP_MACHINE ?? hostMachine();
+  if (!MACHINE_NAME.test(name) || name === "me")
+    throw new CloudUsage(`machine ${JSON.stringify(name)} is not valid: lowercase letters, digits and -, at most 32, not "me"`);
+  return name;
+}
+async function openCloud(options) {
+  const machine = machineName(options.machine);
+  const { url } = activeRelay();
+  const { token, problem } = relayCredential(process.env, url);
+  if (!token) throw new CloudUsage(problem);
+  const client = await CloudRelayClient.connect(url, token);
+  try {
+    const hello = await client.request(
+      "hello",
+      options.handle ? { protocol: PROTOCOL, machine, claim: options.claim } : options.observe ? { protocol: PROTOCOL, observe: true, machine } : { protocol: PROTOCOL, machine, human: true, tty: options.tty }
+    );
+    return { client, me: hello.endpoint ?? null, where: `the relay at ${url}, account ${hello.account}, machine ${machine}` };
+  } catch (error) {
+    client.close();
+    throw error;
+  }
+}
+var out = (line = "") => process.stdout.write(`${line}
+`);
+var json = (value) => out(JSON.stringify(value, null, 2));
+async function machinesVerb(client, positionals, asJson) {
+  const [action, name] = positionals;
+  if (action === "rm") {
+    if (!name || positionals.length !== 2) throw new CloudUsage(`${CLI_NAME} machines rm needs one machine name`);
+    const result = await client.request("machines_rm", { name });
+    if (asJson) json(result);
+    else out(`released ${result.removed} (${result.endpoints} endpoints dropped)`);
+    return 0;
+  }
+  if (action !== void 0) throw new CloudUsage(`${CLI_NAME} machines takes no argument, or rm NAME`);
+  const { machines } = await client.request("machines");
+  if (asJson) json({ machines });
+  else
+    printTable([
+      ["MACHINE", "KIND", "ONLINE", "BRIDGE", "LAST SEEN"],
+      ...machines.map((m) => [m.name, m.kind, m.online ? "yes" : "no", m.bridge ? "yes" : "no", m.last_seen ?? ""])
+    ]);
+  return 0;
+}
+function cloudFilePath(env = process.env) {
+  return join(configDir(env), "cloud.json");
+}
+function readCloudFile(path, env = process.env) {
+  const value = JSON.parse(readFileSync(path, "utf8"));
+  if (value.bridge !== true) throw new Error(`${path}: bridge is not true`);
+  if (typeof value.machine !== "string" || !MACHINE_NAME.test(value.machine) || value.machine === "me") throw new Error(`${path}: machine is not a valid name`);
+  if (value.url !== void 0 && typeof value.url !== "string") throw new Error(`${path}: url must be a URL`);
+  const url = value.url === void 0 ? activeRelay(env).url : checkRelayUrl(value.url, `url in ${path}`);
+  if (value.mirror !== void 0) {
+    if (!Array.isArray(value.mirror)) throw new Error(`${path}: mirror is a list of selectors`);
+    const scoped = value.mirror.find((sel) => typeof sel === "string" && /^(?:group|fleet|tree|machine|org):/.test(sel));
+    if (scoped) throw new Error(`${path}: mirror selectors match by handle, harness, kind and label; ${JSON.stringify(scoped)} is a scope selector`);
+    parsePolicy({ rules: value.mirror.map((match) => ({ match })) });
+  }
+  if (value.redact !== void 0 && typeof value.redact !== "boolean") throw new Error(`${path}: redact is true or false`);
+  if (value.private_ok !== void 0 && typeof value.private_ok !== "boolean") throw new Error(`${path}: private_ok is true or false`);
+  return {
+    bridge: true,
+    machine: value.machine,
+    url,
+    ...value.mirror ? { mirror: value.mirror } : {},
+    ...value.redact !== void 0 ? { redact: value.redact } : {},
+    ...value.private_ok !== void 0 ? { private_ok: value.private_ok } : {}
+  };
+}
+async function daemonBridge(env = process.env, log = console.error) {
+  const path = cloudFilePath(env);
+  if (!path || !existsSync(path)) return void 0;
+  let file;
+  try {
+    file = readCloudFile(path, env);
+  } catch (error) {
+    log(`relay broker: ${error instanceof Error ? error.message : String(error)}; running local-only`);
+    return void 0;
+  }
+  let credentials;
+  try {
+    credentials = relayCredential(env, file.url);
+  } catch (error) {
+    credentials = { token: null, problem: error instanceof Error ? error.message : String(error) };
+  }
+  if (credentials.problem) log(`relay broker: ${credentials.problem}; running local-only`);
+  return {
+    url: file.url,
+    token: credentials.token,
+    ...credentials.problem ? { tokenError: `${credentials.problem}; running local-only` } : {},
+    credentials: async () => relayCredential(env, file.url).token,
+    machine: file.machine,
+    mirror: file.mirror,
+    redact: file.redact,
+    privateOk: file.private_ok
+  };
+}
+async function cloudMain(positionals, values, brokerStatus) {
+  const [action] = positionals;
+  if (positionals.length !== 1) throw new CloudUsage(`${CLI_NAME} cloud takes enable [--machine NAME], disable or status`);
+  const path = cloudFilePath();
+  if (!path) throw new CloudUsage("neither XDG_CONFIG_HOME nor HOME is set, so there is no place for the relay's cloud.json");
+  if (action === "enable") {
+    const machine = machineName(values.machine);
+    const { url } = activeRelay();
+    const { problem } = relayCredential(process.env, url);
+    const file = { bridge: true, machine, url };
+    writePrivateJson(path, file);
+    if (values.json) json({ file: path, ...file, token: problem ? "missing" : "found" });
+    else {
+      out(`the relay broker links to ${url} as machine ${machine} the next time it starts (${path})`);
+      if (problem) note(problem);
+    }
+    return 0;
+  }
+  if (values.machine !== void 0) throw new CloudUsage(`${CLI_NAME} cloud ${action ?? ""} does not take --machine`);
+  if (action === "disable") {
+    const had = existsSync(path);
+    rmSync(path, { force: true });
+    if (values.json) json({ file: path, removed: had });
+    else out(had ? `removed ${path}; the running broker keeps its link until it exits` : `no ${path}; the broker is local-only`);
+    return 0;
+  }
+  if (action === "status") {
+    let file = null;
+    let fileError = null;
+    if (existsSync(path)) {
+      try {
+        file = readCloudFile(path);
+      } catch (error) {
+        fileError = error instanceof Error ? error.message : String(error);
+      }
+    }
+    const broker = await brokerStatus();
+    if (values.json) {
+      json({ file: path, config: file, ...fileError ? { config_error: fileError } : {}, broker });
+      return 0;
+    }
+    out(file ? `${path}: machine ${file.machine} at ${file.url}` : fileError ? fileError : `no ${path}: the broker is local-only`);
+    if (!broker.enabled) out(file ? "the running broker started before this file existed and is local-only until it restarts" : "the broker is local-only");
+    else
+      out(
+        `broker: ${broker.connected ? "connected" : "not connected"} to ${broker.url} as ${broker.machine} since ${broker.since}${broker.last_error ? `; ${broker.last_error}` : ""}`
+      );
+    return 0;
+  }
+  throw new CloudUsage(`${CLI_NAME} cloud takes enable [--machine NAME], disable or status`);
+}
+
+export {
+  CloudUsage,
+  CloudRelayClient,
+  hostMachine,
+  machineName,
+  openCloud,
+  machinesVerb,
+  cloudFilePath,
+  readCloudFile,
+  daemonBridge,
+  cloudMain
+};

package/dist/chunk-7KP6TAJW.js

@@ -0,0 +1,336 @@
+import {
+  SELF,
+  harnessLineage,
+  hiddenHarness,
+  labelsFor,
+  lineage,
+  parseSeconds,
+  readPsTable
+} from "./chunk-DA3EB2YF.js";
+
+// src/common.ts
+import { spawn } from "child_process";
+import { closeSync, openSync, statSync, truncateSync } from "fs";
+import { join } from "path";
+import { CLI_NAME } from "@scp-dev/core";
+import { connectBroker, privateDir, relayDir } from "@scp-dev/broker";
+var RelayUsage = class extends Error {
+};
+var OPTIONS = {
+  cloud: { type: "boolean" },
+  machine: { type: "string" },
+  token: { type: "string" },
+  label: { type: "string" },
+  "no-browser": { type: "boolean" },
+  json: { type: "boolean" },
+  channels: { type: "boolean" },
+  write: { type: "boolean" },
+  print: { type: "boolean" },
+  "block-stop-on-unread": { type: "boolean" },
+  "push-wait": { type: "string" },
+  all: { type: "boolean" },
+  as: { type: "string" },
+  harness: { type: "string" },
+  wait: { type: "string" },
+  ack: { type: "boolean" },
+  keep: { type: "boolean" },
+  "reply-to": { type: "string" },
+  "require-reply": { type: "boolean" },
+  thread: { type: "string" },
+  private: { type: "boolean" },
+  attach: { type: "string", multiple: true },
+  tool: { type: "string" },
+  summary: { type: "string" },
+  since: { type: "string" },
+  limit: { type: "string" },
+  idle: { type: "string" },
+  policy: { type: "string" },
+  human: { type: "boolean" },
+  help: { type: "boolean", short: "h" },
+  scope: { type: "string" },
+  tree: { type: "boolean" },
+  roots: { type: "boolean" },
+  contacts: { type: "boolean" },
+  activity: { type: "boolean" },
+  in: { type: "string" },
+  out: { type: "string" },
+  allow: { type: "string", multiple: true },
+  rules: { type: "string" },
+  group: { type: "string" },
+  under: { type: "string" },
+  ttl: { type: "string" },
+  labels: { type: "string" },
+  "handback-bytes": { type: "string" },
+  "no-push": { type: "boolean" },
+  bg: { type: "boolean" },
+  fg: { type: "boolean" },
+  name: { type: "string" },
+  title: { type: "string" },
+  judge: { type: "boolean" },
+  redacted: { type: "boolean" },
+  reason: { type: "string" },
+  turns: { type: "string" },
+  full: { type: "boolean" },
+  who: { type: "boolean" },
+  peek: { type: "string" }
+};
+var SPAWN_OPTIONS = [
+  "as",
+  "harness",
+  "human",
+  "name",
+  "title",
+  "scope",
+  "rules",
+  "in",
+  "out",
+  "allow",
+  "group",
+  "under",
+  "ttl",
+  "labels",
+  "peek",
+  "handback-bytes",
+  "no-push",
+  "bg",
+  "fg"
+];
+var OBSERVE = /* @__PURE__ */ new Set([
+  "list",
+  "status",
+  "watch",
+  "log",
+  "policy",
+  "machines",
+  "rules",
+  "group",
+  "admin",
+  "spawn-env",
+  "spawn",
+  "why",
+  "peek",
+  "set-peek"
+]);
+var CLOUD_OBSERVE = /* @__PURE__ */ new Set(["list", "status", "watch", "log", "machines"]);
+var GRANT_TOKEN = /^krt_[0-9a-f]{64}$/;
+var DAEMON_ENV = [
+  "PATH",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "TZ",
+  "TMPDIR",
+  "USER",
+  "LOGNAME",
+  "SCP_IDLE",
+  "HOME",
+  "XDG_CONFIG_HOME",
+  "SCP_TOKEN",
+  "SCP_RELAY",
+  "SCP_MACHINE"
+];
+var LOG_MAX_BYTES = 1024 * 1024;
+function startDaemon(dir) {
+  privateDir(dir);
+  const logFile = join(dir, "broker.log");
+  if ((statSync(logFile, { throwIfNoEntry: false })?.size ?? 0) > LOG_MAX_BYTES) truncateSync(logFile, 0);
+  const log = openSync(logFile, "a", 384);
+  try {
+    const env = { SCP_DIR: dir };
+    for (const key of DAEMON_ENV) if (process.env[key] !== void 0) env[key] = process.env[key];
+    const child = spawn(SELF[0], [...SELF.slice(1), "daemon"], {
+      detached: true,
+      stdio: ["ignore", log, log],
+      env,
+      cwd: dir
+    });
+    child.unref();
+  } finally {
+    closeSync(log);
+  }
+}
+function terminalAttached(streams, bodyFromStdin) {
+  if (streams.stdin.isTTY === true) return true;
+  return !bodyFromStdin && (streams.stdout.isTTY === true || streams.stderr.isTTY === true);
+}
+function localHandle(raw) {
+  const handle = raw.startsWith("me/") ? raw.slice(3) : raw;
+  if (!handle) throw new RelayUsage("--as me/ names your own human inbox: use --human");
+  if (handle.includes("/")) throw new RelayUsage(`--as names a local handle, not ${JSON.stringify(raw)}`);
+  return handle;
+}
+function walkNow() {
+  const table = readPsTable();
+  return { keys: lineage(process.ppid, table), self: harnessLineage(process.ppid, table) };
+}
+async function open(verb, values, cwd, bodyFromStdin, walk) {
+  const named = values.as ?? process.env.SCP_NAME;
+  const tty = terminalAttached(process, bodyFromStdin);
+  if (named && values.human) throw new RelayUsage("--human and --as (or $SCP_NAME) name two identities; pick one");
+  const grant = process.env.SCP_GRANT || void 0;
+  const cloud = values.cloud || process.env.SCP_TRANSPORT === "cloud" || verb === "machines";
+  if (grant !== void 0) {
+    if (!GRANT_TOKEN.test(grant)) {
+      throw new RelayUsage(
+        `$SCP_GRANT is not one spawn-env grant: pass spawn-env's lines as separate words: env $(${CLI_NAME} spawn-env ...) cmd; in zsh env \${=G} cmd`
+      );
+    }
+    if (values.human) throw new RelayUsage("--human and $SCP_GRANT name two identities: unset the grant to act as me/");
+    if (cloud) throw new RelayUsage("a spawn-env grant is for this machine's relay broker, not the cloud transport");
+  }
+  if (cloud) {
+    if (!named && !values.human && !tty && !OBSERVE.has(verb)) {
+      throw new RelayUsage(
+        `${CLI_NAME} ${verb} needs an identity: --as HANDLE (or $SCP_NAME) for an agent, or --human for your own inbox me/ (no terminal is attached, so me/ is not assumed)`
+      );
+    }
+    const { machineName, openCloud } = await import("./remote-3BWFISXJ.js");
+    const handle2 = named ? localHandle(named) : void 0;
+    const claim = handle2 ? {
+      handle: handle2,
+      harness: values.harness ?? process.env.SCP_HARNESS ?? "cli",
+      cwd,
+      ...process.env.SCP_PARENT ? { parent: process.env.SCP_PARENT } : {},
+      labels: labelsFor(process.env, machineName(values.machine))
+    } : void 0;
+    const observe = !handle2 && !values.human && CLOUD_OBSERVE.has(verb);
+    return {
+      ...await openCloud({
+        ...values.machine !== void 0 ? { machine: values.machine } : {},
+        ...handle2 ? { handle: handle2 } : {},
+        ...claim ? { claim } : {},
+        tty,
+        observe
+      }),
+      broker: null,
+      bound: handle2 ? "as" : observe ? null : "human"
+    };
+  }
+  if (values.machine !== void 0) throw new RelayUsage("--machine names the machine of the cloud transport: add --cloud");
+  const handle = named ? localHandle(named) : void 0;
+  const { keys, self } = walk ?? walkNow();
+  const harnessPid = self.length ? Number(/^pid:(\d+)/.exec(self.at(-1))?.[1]) : void 0;
+  const lineageClaim = keys.length ? { lineage: keys } : {};
+  const dir = relayDir();
+  const client = await connectBroker(dir, () => startDaemon(dir));
+  try {
+    let bound;
+    let hello;
+    if (handle) {
+      bound = "as";
+      hello = await client.hello({
+        claim: {
+          handle,
+          exact: true,
+          harness: values.harness ?? process.env.SCP_HARNESS ?? "cli",
+          cwd,
+          ...process.env.SCP_PARENT ? { parent: process.env.SCP_PARENT } : {},
+          labels: labelsFor(process.env),
+          ...lineageClaim,
+          ...grant ? { grant } : {}
+        },
+        ...self.length ? { self } : {},
+        brief: true
+      });
+    } else if (grant) {
+      hello = await client.hello({ observe: true, ...lineageClaim, ...self.length ? { self } : {}, grant, cwd, brief: true });
+      if (!hello.grant_bound) throw new RelayUsage(`the running ${CLI_NAME} broker does not check spawn-env grants: let it exit (it stops when idle) and retry`);
+      bound = "lineage";
+    } else if (values.human || tty) {
+      hello = await client.hello({ human: true, tty, cwd, brief: true, ...lineageClaim });
+      bound = hello.endpoint?.kind === "human" ? "human" : "lineage";
+    } else {
+      hello = await client.hello({ observe: true, ...lineageClaim, ...self.length ? { self } : {}, cwd, brief: true });
+      bound = hello.endpoint ? "lineage" : null;
+      if (!hello.endpoint && !OBSERVE.has(verb)) {
+        if (hiddenHarness(process.ppid, readPsTable()))
+          throw new RelayUsage(`${CLI_NAME} ${verb}: sandbox pid namespace: this shell cannot see its harness; use the scp MCP tools`);
+        throw new RelayUsage(
+          `${CLI_NAME} ${verb}: no relay agent runs this shell's harness process (${harnessPid ? `pid ${harnessPid}` : "none found"}); pass --as HANDLE or --human (no terminal is attached, so me/ is not assumed)`
+        );
+      }
+    }
+    return { client, me: hello.endpoint, broker: hello.broker, where: brokerLine(hello.broker), bound, harnessPid };
+  } catch (error) {
+    client.close();
+    throw error;
+  }
+}
+function localClient(client, broker, verb) {
+  if (!broker) throw new RelayUsage(`${CLI_NAME} ${verb} is the local broker's; it has no --cloud form`);
+  return client;
+}
+function brokerLine(broker) {
+  const policy = broker.policy.state === "open" ? `no policy at ${broker.policy.file}, open` : broker.policy.state === "loaded" ? `policy ${broker.policy.file}` : `policy ${broker.policy.file} unusable, sends refused`;
+  return `broker ${broker.socket} (pid ${broker.pid}); ${policy}`;
+}
+function selectorList(value) {
+  if (value === void 0 || typeof value === "boolean") return void 0;
+  return (Array.isArray(value) ? value : [value]).flatMap((v) => v.split(",")).map((v) => v.trim()).filter(Boolean);
+}
+var PRESETS = /* @__PURE__ */ new Set(["open", "tree", "parent", "none"]);
+function preset(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !PRESETS.has(value)) throw new RelayUsage("--scope takes open, tree, parent or none");
+  return value;
+}
+function peekGrant(value) {
+  if (value === void 0) return {};
+  if (value !== "local") throw new RelayUsage(`--peek takes local (peekable on this machine from its start), not ${JSON.stringify(value)}`);
+  return { peek: "local" };
+}
+function grantParams(values) {
+  const rules = selectorList(values.rules);
+  if (rules && values.scope !== void 0) throw new RelayUsage("--rules and --scope both set a preset; pick one");
+  const allow = [...rules ?? [], ...selectorList(values.allow) ?? []];
+  const scope = rules ? "none" : preset(values.scope);
+  const groups = selectorList(values.group);
+  const incoming = selectorList(values.in);
+  const outgoing = selectorList(values.out);
+  return {
+    ...values.name ? { name: values.name } : {},
+    ...values.title !== void 0 ? { title: values.title } : {},
+    ...values.under ? { under: values.under } : {},
+    ...scope ? { scope } : {},
+    ...incoming ? { in: incoming } : {},
+    ...outgoing ? { out: outgoing } : {},
+    ...allow.length ? { allow } : {},
+    ...groups?.length ? { groups } : {},
+    ...values.ttl !== void 0 ? { ttl_s: ttlSeconds(values.ttl) } : {},
+    ...values["no-push"] === true ? { no_push: true } : {},
+    ...peekGrant(values.peek)
+  };
+}
+function ttlSeconds(text) {
+  try {
+    return parseSeconds(text, "--ttl");
+  } catch (error) {
+    throw new RelayUsage(error instanceof Error ? error.message : String(error));
+  }
+}
+var pad = (n) => String(n).padStart(2, "0");
+function time(iso) {
+  const at = new Date(iso);
+  return Number.isNaN(at.getTime()) ? iso : `${pad(at.getHours())}:${pad(at.getMinutes())}:${pad(at.getSeconds())}`;
+}
+function stamp(iso) {
+  const at = new Date(iso);
+  return Number.isNaN(at.getTime()) ? iso : `${at.getFullYear()}-${pad(at.getMonth() + 1)}-${pad(at.getDate())} ${time(iso)}`;
+}
+
+export {
+  RelayUsage,
+  OPTIONS,
+  SPAWN_OPTIONS,
+  startDaemon,
+  walkNow,
+  open,
+  localClient,
+  brokerLine,
+  selectorList,
+  preset,
+  peekGrant,
+  grantParams,
+  time,
+  stamp
+};