kalshi-trading-bot-cli 2.1.0

package/src/gateway/access-control.ts

@@ -0,0 +1,253 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { randomInt } from 'node:crypto';
+import { isSelfChatMode, normalizeE164 } from './utils.js';
+import { appPath } from '../utils/paths.js';
+
+const PAIRING_REPLY_HISTORY_GRACE_MS = 30_000;
+
+type PairingRequest = {
+  phone: string;
+  code: string;
+  createdAt: number;
+};
+
+type PairingStore = Record<string, PairingRequest>;
+
+function pairingPath(): string {
+  return (
+    process.env.APP_PAIRING_PATH ??
+    appPath('pairing', 'whatsapp.json')
+  );
+}
+
+function loadPairingStore(): PairingStore {
+  const path = pairingPath();
+  if (!existsSync(path)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync(path, 'utf8')) as PairingStore;
+  } catch {
+    return {};
+  }
+}
+
+function savePairingStore(store: PairingStore): void {
+  const path = pairingPath();
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(path, JSON.stringify(store, null, 2), 'utf8');
+}
+
+export function createPairingCode(): string {
+  return String(randomInt(100000, 999999));
+}
+
+export function recordPairingRequest(phone: string): PairingRequest {
+  const normalized = normalizeE164(phone);
+  const store = loadPairingStore();
+  const existing = store[normalized];
+  if (existing) {
+    return existing;
+  }
+  const request: PairingRequest = {
+    phone: normalized,
+    code: createPairingCode(),
+    createdAt: Date.now(),
+  };
+  store[normalized] = request;
+  savePairingStore(store);
+  return request;
+}
+
+export function isAllowedPhone(params: {
+  from: string;
+  allowFrom: string[];
+}): { allowed: boolean; normalizedFrom: string } {
+  const normalizedFrom = normalizeE164(params.from);
+  const allowFrom = params.allowFrom.map(normalizeE164).filter(Boolean);
+  if (allowFrom.includes('+*') || params.allowFrom.includes('*')) {
+    return { allowed: true, normalizedFrom };
+  }
+  return { allowed: allowFrom.includes(normalizedFrom), normalizedFrom };
+}
+
+export function buildPairingReply(code: string, senderId: string): string {
+  return [
+    'Access request received.',
+    `Sender ID: ${senderId}`,
+    `Approval code: ${code}`,
+    'Ask the operator to approve this code in gateway config.',
+  ].join('\n');
+}
+
+export type InboundAccessControlResult = {
+  allowed: boolean;
+  shouldMarkRead: boolean;
+  isSelfChat: boolean;
+  resolvedAccountId: string;
+  denyReason?: string;
+};
+
+export async function checkInboundAccessControl(params: {
+  accountId: string;
+  from: string;
+  selfE164: string | null;
+  senderE164: string | null;
+  group: boolean;
+  pushName?: string;
+  isFromMe: boolean;
+  dmPolicy: 'pairing' | 'allowlist' | 'open' | 'disabled';
+  groupPolicy: 'open' | 'allowlist' | 'disabled';
+  allowFrom: string[];
+  groupAllowFrom: string[];
+  messageTimestampMs?: number;
+  connectedAtMs?: number;
+  pairingGraceMs?: number;
+  reply: (text: string) => Promise<void>;
+}): Promise<InboundAccessControlResult> {
+  const normalizedSelfE164 = params.selfE164 ? normalizeE164(params.selfE164) : null;
+  const normalizedFrom = normalizeE164(params.from);
+  const normalizedSenderE164 = params.senderE164 ? normalizeE164(params.senderE164) : null;
+  const isSamePhone = normalizedSelfE164 != null && normalizedFrom === normalizedSelfE164;
+  const isSelfChat = isSelfChatMode(params.selfE164, params.allowFrom);
+  const pairingGraceMs =
+    typeof params.pairingGraceMs === 'number' && params.pairingGraceMs > 0
+      ? params.pairingGraceMs
+      : PAIRING_REPLY_HISTORY_GRACE_MS;
+  const suppressPairingReply =
+    typeof params.connectedAtMs === 'number' &&
+    typeof params.messageTimestampMs === 'number' &&
+    params.messageTimestampMs < params.connectedAtMs - pairingGraceMs;
+
+  const dmHasWildcard = params.allowFrom.includes('*');
+  const normalizedAllowFrom = params.allowFrom.filter((entry) => entry !== '*').map(normalizeE164);
+  const groupHasWildcard = params.groupAllowFrom.includes('*');
+  const normalizedGroupAllowFrom = params.groupAllowFrom
+    .filter((entry) => entry !== '*')
+    .map(normalizeE164);
+
+  // Strict self-chat mode: only allow direct messages to/from the user's own number.
+  // This provides fail-closed behavior even if policies are accidentally broadened.
+  if (isSelfChat) {
+    if (params.group) {
+      return {
+        allowed: false,
+        shouldMarkRead: false,
+        isSelfChat,
+        resolvedAccountId: params.accountId,
+        denyReason: 'group_blocked_self_chat_mode',
+      };
+    }
+    const senderIsSelf =
+      normalizedSelfE164 != null &&
+      (normalizedFrom === normalizedSelfE164 || normalizedSenderE164 === normalizedSelfE164);
+    if (!senderIsSelf) {
+      return {
+        allowed: false,
+        shouldMarkRead: false,
+        isSelfChat,
+        resolvedAccountId: params.accountId,
+        denyReason: 'sender_not_self_in_self_chat_mode',
+      };
+    }
+    return {
+      allowed: true,
+      shouldMarkRead: true,
+      isSelfChat,
+      resolvedAccountId: params.accountId,
+    };
+  }
+
+  // Block group messages unless explicitly allowed via 'open' or 'allowlist' policy.
+  // Fail-safe: if groupPolicy is missing/invalid, groups are blocked.
+  if (params.group) {
+    if (params.groupPolicy !== 'open' && params.groupPolicy !== 'allowlist') {
+      return {
+        allowed: false,
+        shouldMarkRead: false,
+        isSelfChat,
+        resolvedAccountId: params.accountId,
+        denyReason: 'group_policy_not_permissive',
+      };
+    }
+  }
+
+  if (params.group && params.groupPolicy === 'allowlist') {
+    if (normalizedGroupAllowFrom.length === 0 && !groupHasWildcard) {
+      return {
+        allowed: false,
+        shouldMarkRead: false,
+        isSelfChat,
+        resolvedAccountId: params.accountId,
+        denyReason: 'group_allowlist_empty',
+      };
+    }
+    const senderAllowed =
+      groupHasWildcard ||
+      (normalizedSenderE164 != null && normalizedGroupAllowFrom.includes(normalizedSenderE164));
+    if (!senderAllowed) {
+      return {
+        allowed: false,
+        shouldMarkRead: false,
+        isSelfChat,
+        resolvedAccountId: params.accountId,
+        denyReason: 'group_sender_not_allowlisted',
+      };
+    }
+  }
+
+  if (!params.group) {
+    if (params.dmPolicy === 'disabled') {
+      return {
+        allowed: false,
+        shouldMarkRead: false,
+        isSelfChat,
+        resolvedAccountId: params.accountId,
+        denyReason: 'dm_policy_disabled',
+      };
+    }
+
+    // Skip outbound DMs to other people (messages I sent to others)
+    if (params.isFromMe && !isSamePhone) {
+      return {
+        allowed: false,
+        shouldMarkRead: false,
+        isSelfChat,
+        resolvedAccountId: params.accountId,
+        denyReason: 'outbound_dm_to_non_self',
+      };
+    }
+
+    // For DMs from others, check allowlist (unless policy is 'open')
+    if (params.dmPolicy !== 'open' && !isSamePhone) {
+      const allowed =
+        dmHasWildcard ||
+        (normalizedAllowFrom.length > 0 && normalizedAllowFrom.includes(normalizedFrom));
+      if (!allowed) {
+        if (params.dmPolicy === 'pairing' && !suppressPairingReply) {
+          const pairing = recordPairingRequest(normalizedFrom);
+          await params.reply(buildPairingReply(pairing.code, normalizedFrom));
+        }
+        return {
+          allowed: false,
+          shouldMarkRead: false,
+          isSelfChat,
+          resolvedAccountId: params.accountId,
+          denyReason: 'dm_sender_not_allowlisted',
+        };
+      }
+    }
+  }
+
+  return {
+    allowed: true,
+    shouldMarkRead: true,
+    isSelfChat,
+    resolvedAccountId: params.accountId,
+  };
+}
+

package/src/gateway/agent-runner.ts

@@ -0,0 +1,75 @@
+import { Agent } from '../agent/agent.js';
+import { InMemoryChatHistory } from '../utils/in-memory-chat-history.js';
+import { HEARTBEAT_OK_TOKEN } from './heartbeat/suppression.js';
+import type { AgentEvent } from '../agent/types.js';
+import type { GroupContext } from '../agent/prompts.js';
+
+type SessionState = {
+  history: InMemoryChatHistory;
+  tail: Promise<void>;
+};
+
+const sessions = new Map<string, SessionState>();
+
+function getSession(sessionKey: string, model: string): SessionState {
+  const existing = sessions.get(sessionKey);
+  if (existing) {
+    return existing;
+  }
+  const created: SessionState = {
+    history: new InMemoryChatHistory(model),
+    tail: Promise.resolve(),
+  };
+  sessions.set(sessionKey, created);
+  return created;
+}
+
+export type AgentRunRequest = {
+  sessionKey: string;
+  query: string;
+  model: string;
+  modelProvider: string;
+  maxIterations?: number;
+  signal?: AbortSignal;
+  onEvent?: (event: AgentEvent) => void | Promise<void>;
+  isHeartbeat?: boolean;
+  channel?: string;
+  groupContext?: GroupContext;
+};
+
+export async function runAgentForMessage(req: AgentRunRequest): Promise<string> {
+  const session = getSession(req.sessionKey, req.model);
+  let finalAnswer = '';
+
+  const run = async () => {
+    session.history.saveUserQuery(req.query);
+    const agent = await Agent.create({
+      model: req.model,
+      modelProvider: req.modelProvider,
+      maxIterations: req.maxIterations ?? 10,
+      signal: req.signal,
+      channel: req.channel,
+      groupContext: req.groupContext,
+    });
+    for await (const event of agent.run(req.query, session.history)) {
+      await req.onEvent?.(event);
+      if (event.type === 'done') {
+        finalAnswer = event.answer;
+      }
+    }
+    if (finalAnswer) {
+      await session.history.saveAnswer(finalAnswer);
+    }
+
+    // Prune HEARTBEAT_OK turns to avoid context pollution
+    if (req.isHeartbeat && finalAnswer.trim().toUpperCase().includes(HEARTBEAT_OK_TOKEN)) {
+      session.history.pruneLastTurn();
+    }
+  };
+
+  // Serialize per-session turns while allowing cross-session concurrency.
+  session.tail = session.tail.then(run, run);
+  await session.tail;
+  return finalAnswer;
+}
+

package/src/gateway/alerts/formatter.ts

@@ -0,0 +1,90 @@
+import type { AlertPayload } from '../../scan/alerter.js';
+
+function magnitudeBar(edge: number): string {
+  const absEdge = Math.abs(edge);
+  const pct = Math.min(absEdge * 100, 10);
+  const filled = Math.round(pct);
+  const empty = 10 - filled;
+  const sign = edge >= 0 ? '+' : '-';
+  return `[${`=`.repeat(filled)}${`-`.repeat(empty)}] ${sign}${(absEdge * 100).toFixed(1)}%`;
+}
+
+function formatEdgeAlert(alert: AlertPayload): string {
+  const lines: string[] = [];
+  lines.push(`🔔 *EDGE DETECTED*`);
+  lines.push('');
+  lines.push(`*${alert.ticker}*`);
+  lines.push(magnitudeBar(alert.edge));
+  lines.push('');
+  lines.push(alert.message);
+  lines.push('');
+  lines.push(`Reply *YES* to get a recommendation`);
+  return lines.join('\n');
+}
+
+function formatConvergenceAlert(alert: AlertPayload): string {
+  const lines: string[] = [];
+  lines.push(`⚠️ *CONVERGENCE*`);
+  lines.push('');
+  lines.push(`*${alert.ticker}*`);
+  lines.push(alert.message);
+  lines.push('');
+  lines.push(`Edge narrowed to ${(Math.abs(alert.edge) * 100).toFixed(1)}%`);
+  return lines.join('\n');
+}
+
+function formatAdverseMoveAlert(alert: AlertPayload): string {
+  const lines: string[] = [];
+  lines.push(`🚨 *ADVERSE MOVE*`);
+  lines.push('');
+  lines.push(`*${alert.ticker}*`);
+  lines.push(alert.message);
+  return lines.join('\n');
+}
+
+function formatExpiryAlert(alert: AlertPayload): string {
+  const lines: string[] = [];
+  lines.push(`⏰ *EXPIRY APPROACHING*`);
+  lines.push('');
+  lines.push(`*${alert.ticker}*`);
+  lines.push(alert.message);
+  return lines.join('\n');
+}
+
+function formatCatalystAlert(alert: AlertPayload): string {
+  const lines: string[] = [];
+  lines.push(`📅 *CATALYST APPROACHING*`);
+  lines.push('');
+  lines.push(`*${alert.ticker}*`);
+  lines.push(alert.message);
+  return lines.join('\n');
+}
+
+function formatCircuitBreakerAlert(alert: AlertPayload): string {
+  const lines: string[] = [];
+  lines.push(`🛑 *CIRCUIT BREAKER*`);
+  lines.push('');
+  lines.push(alert.message);
+  lines.push('');
+  lines.push(`All new positions paused until risk clears.`);
+  return lines.join('\n');
+}
+
+export function formatAlertForWhatsApp(alert: AlertPayload): string {
+  switch (alert.alertType) {
+    case 'EDGE_DETECTED':
+      return formatEdgeAlert(alert);
+    case 'CONVERGENCE':
+      return formatConvergenceAlert(alert);
+    case 'ADVERSE_MOVE':
+      return formatAdverseMoveAlert(alert);
+    case 'EXPIRY_APPROACHING':
+      return formatExpiryAlert(alert);
+    case 'CATALYST_APPROACHING':
+      return formatCatalystAlert(alert);
+    case 'CIRCUIT_BREAKER':
+      return formatCircuitBreakerAlert(alert);
+    default:
+      return `*ALERT* ${alert.ticker}: ${alert.message}`;
+  }
+}

package/src/gateway/alerts/index.ts

@@ -0,0 +1,4 @@
+export { AlertRouter } from './router.js';
+export { formatAlertForWhatsApp } from './formatter.js';
+export { formatAlertForTerminal } from './terminal.js';
+export type { AlertChannelHandler, AlertChannelDispatch, PendingApproval, AlertPayload, AlertType } from './types.js';

package/src/gateway/alerts/router.ts

@@ -0,0 +1,32 @@
+import type { AlertPayload } from '../../scan/alerter.js';
+import type { AlertChannelHandler, PendingApproval } from './types.js';
+
+export class AlertRouter {
+  private handlers = new Map<string, AlertChannelHandler>();
+  private pending = new Map<string, PendingApproval>();
+
+  registerChannel(name: string, handler: AlertChannelHandler): void {
+    this.handlers.set(name, handler);
+  }
+
+  async route(alert: AlertPayload, target?: string): Promise<void> {
+    for (const channel of alert.channels) {
+      const handler = this.handlers.get(channel);
+      if (handler) {
+        await handler(alert, target ?? '');
+      }
+    }
+  }
+
+  setPending(sessionKey: string, approval: PendingApproval): void {
+    this.pending.set(sessionKey, approval);
+  }
+
+  getPending(sessionKey: string): PendingApproval | undefined {
+    return this.pending.get(sessionKey);
+  }
+
+  clearPending(sessionKey: string): void {
+    this.pending.delete(sessionKey);
+  }
+}

package/src/gateway/alerts/terminal.ts

@@ -0,0 +1,16 @@
+import type { AlertPayload } from '../../scan/alerter.js';
+
+function magnitudeBar(edge: number): string {
+  const absEdge = Math.abs(edge);
+  const pct = Math.min(absEdge * 100, 10);
+  const filled = Math.round(pct);
+  const empty = 10 - filled;
+  const sign = edge >= 0 ? '+' : '-';
+  return `[${`=`.repeat(filled)}${`-`.repeat(empty)}] ${sign}${(absEdge * 100).toFixed(1)}%`;
+}
+
+export function formatAlertForTerminal(alert: AlertPayload): string {
+  const ts = new Date().toISOString().slice(11, 19);
+  const bar = magnitudeBar(alert.edge);
+  return `[${ts}] [${alert.alertType}] ${alert.ticker} ${bar} — ${alert.message}`;
+}

package/src/gateway/alerts/types.ts

@@ -0,0 +1,13 @@
+export type { AlertType, AlertPayload } from '../../scan/alerter.js';
+
+export type AlertChannelHandler = (alert: import('../../scan/alerter.js').AlertPayload, target: string) => Promise<void>;
+
+export type AlertChannelDispatch = (channel: string, alert: import('../../scan/alerter.js').AlertPayload) => Promise<void>;
+
+export interface PendingApproval {
+  ticker: string;
+  alertId: string;
+  edge: number;
+  createdAt: number;
+  sessionKey: string;
+}

package/src/gateway/channels/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Channel extension seam:
+ * - Add a new channel plugin that implements ChannelPlugin<TConfig, TAccount>.
+ * - Register it in gateway bootstrap alongside WhatsApp.
+ * - Reuse the same manager lifecycle (start/stop/status) without changing core gateway flow.
+ */
+export * from './types.js';
+export * from './manager.js';
+

package/src/gateway/channels/manager.ts

@@ -0,0 +1,153 @@
+import type { ChannelPlugin, ChannelRuntimeSnapshot } from './types.js';
+
+type RuntimeStore = {
+  aborts: Map<string, AbortController>;
+  tasks: Map<string, Promise<unknown>>;
+  runtimes: Map<string, ChannelRuntimeSnapshot>;
+};
+
+export type ChannelManager<TConfig, TAccount> = {
+  startAll: () => Promise<void>;
+  startAccount: (accountId: string) => Promise<void>;
+  stopAccount: (accountId: string) => Promise<void>;
+  stopAll: () => Promise<void>;
+  getSnapshot: () => Record<string, ChannelRuntimeSnapshot>;
+};
+
+function createRuntimeStore(): RuntimeStore {
+  return {
+    aborts: new Map(),
+    tasks: new Map(),
+    runtimes: new Map(),
+  };
+}
+
+export function createChannelManager<TConfig, TAccount>(params: {
+  plugin: ChannelPlugin<TConfig, TAccount>;
+  loadConfig: () => TConfig;
+}): ChannelManager<TConfig, TAccount> {
+  const { plugin, loadConfig } = params;
+  const store = createRuntimeStore();
+
+  const resolveRuntime = (accountId: string): ChannelRuntimeSnapshot =>
+    store.runtimes.get(accountId) ?? {
+      accountId,
+      running: false,
+      ...(plugin.status?.defaultRuntime ?? {}),
+    };
+
+  const setRuntime = (
+    accountId: string,
+    next: Partial<ChannelRuntimeSnapshot>,
+  ): ChannelRuntimeSnapshot => {
+    const current = resolveRuntime(accountId);
+    const merged = { ...current, ...next, accountId };
+    store.runtimes.set(accountId, merged);
+    return merged;
+  };
+
+  const startAccount = async (accountId: string): Promise<void> => {
+    if (store.tasks.has(accountId)) {
+      return;
+    }
+
+    const cfg = loadConfig();
+    const account = plugin.config.resolveAccount(cfg, accountId);
+    if (plugin.config.isEnabled?.(account, cfg) === false) {
+      setRuntime(accountId, { running: false, lastError: 'disabled' });
+      return;
+    }
+    if ((await plugin.config.isConfigured?.(account, cfg)) === false) {
+      setRuntime(accountId, { running: false, lastError: 'not configured' });
+      return;
+    }
+
+    const abort = new AbortController();
+    store.aborts.set(accountId, abort);
+    setRuntime(accountId, {
+      running: true,
+      lastError: null,
+      lastStartAt: Date.now(),
+    });
+
+    const task = Promise.resolve(
+      plugin.gateway.startAccount({
+        accountId,
+        account,
+        abortSignal: abort.signal,
+        getStatus: () => resolveRuntime(accountId),
+        setStatus: (patch) => setRuntime(accountId, patch),
+      }),
+    )
+      .catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        setRuntime(accountId, { running: false, lastError: message });
+      })
+      .finally(() => {
+        store.aborts.delete(accountId);
+        store.tasks.delete(accountId);
+        setRuntime(accountId, { running: false, lastStopAt: Date.now() });
+      });
+    store.tasks.set(accountId, task);
+  };
+
+  const stopAccount = async (accountId: string): Promise<void> => {
+    const abort = store.aborts.get(accountId);
+    const task = store.tasks.get(accountId);
+    abort?.abort();
+    if (plugin.gateway.stopAccount) {
+      const cfg = loadConfig();
+      const account = plugin.config.resolveAccount(cfg, accountId);
+      await plugin.gateway.stopAccount({
+        accountId,
+        account,
+        abortSignal: abort?.signal ?? new AbortController().signal,
+        getStatus: () => resolveRuntime(accountId),
+        setStatus: (patch) => setRuntime(accountId, patch),
+      });
+    }
+    if (task) {
+      await task.catch(() => undefined);
+    }
+  };
+
+  const startAll = async (): Promise<void> => {
+    const ids = plugin.config.listAccountIds(loadConfig());
+    for (const id of ids) {
+      await startAccount(id);
+    }
+  };
+
+  const stopAll = async (): Promise<void> => {
+    const ids = new Set([
+      ...plugin.config.listAccountIds(loadConfig()),
+      ...store.tasks.keys(),
+      ...store.aborts.keys(),
+    ]);
+    for (const id of ids) {
+      await stopAccount(id);
+    }
+  };
+
+  const getSnapshot = (): Record<string, ChannelRuntimeSnapshot> => {
+    const ids = new Set([
+      ...plugin.config.listAccountIds(loadConfig()),
+      ...store.runtimes.keys(),
+      ...store.tasks.keys(),
+    ]);
+    const snapshot: Record<string, ChannelRuntimeSnapshot> = {};
+    for (const id of ids) {
+      snapshot[id] = resolveRuntime(id);
+    }
+    return snapshot;
+  };
+
+  return {
+    startAll,
+    startAccount,
+    stopAccount,
+    stopAll,
+    getSnapshot,
+  };
+}
+

package/src/gateway/channels/types.ts

@@ -0,0 +1,48 @@
+export type ChannelId = 'whatsapp';
+
+export type ChannelRuntimeSnapshot = {
+  accountId: string;
+  running: boolean;
+  connected?: boolean;
+  lastError?: string | null;
+  lastStartAt?: number;
+  lastStopAt?: number;
+};
+
+export type ChannelStartContext<TAccount> = {
+  accountId: string;
+  account: TAccount;
+  abortSignal: AbortSignal;
+  getStatus: () => ChannelRuntimeSnapshot;
+  setStatus: (next: Partial<ChannelRuntimeSnapshot>) => ChannelRuntimeSnapshot;
+};
+
+export type ChannelStopContext<TAccount> = {
+  accountId: string;
+  account: TAccount;
+  abortSignal: AbortSignal;
+  getStatus: () => ChannelRuntimeSnapshot;
+  setStatus: (next: Partial<ChannelRuntimeSnapshot>) => ChannelRuntimeSnapshot;
+};
+
+export type ChannelConfigAdapter<TConfig, TAccount> = {
+  listAccountIds: (cfg: TConfig) => string[];
+  resolveAccount: (cfg: TConfig, accountId: string) => TAccount;
+  isEnabled?: (account: TAccount, cfg: TConfig) => boolean;
+  isConfigured?: (account: TAccount, cfg: TConfig) => Promise<boolean> | boolean;
+};
+
+export type ChannelGatewayAdapter<TAccount> = {
+  startAccount: (ctx: ChannelStartContext<TAccount>) => Promise<void>;
+  stopAccount?: (ctx: ChannelStopContext<TAccount>) => Promise<void>;
+};
+
+export type ChannelPlugin<TConfig, TAccount> = {
+  id: ChannelId;
+  config: ChannelConfigAdapter<TConfig, TAccount>;
+  gateway: ChannelGatewayAdapter<TAccount>;
+  status?: {
+    defaultRuntime?: ChannelRuntimeSnapshot;
+  };
+};
+