@cordfuse/crosstalkd 7.0.0-alpha.1

package/src/channel.ts

@@ -0,0 +1,202 @@
+// crosstalkd channel — channel operations.
+//
+// Three operations on one subcommand (V7-SPEC §7):
+//   crosstalkd channel <name>                            — create
+//   crosstalkd channel <name-or-uuid> --rename <new>     — rename
+//   crosstalkd channel <name-or-uuid> --delete           — hard delete (typed-name confirmation)
+//
+// No archive, no restore, no purge, no --force. History stays in git log
+// if recovery is ever needed.
+
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'fs';
+import { resolve, join } from 'path';
+import { randomUUID } from 'crypto';
+import { spawnSync } from 'child_process';
+import { parseFrontmatter, serializeFrontmatter } from './frontmatter.js';
+import { gitCommitAndPush, discoverChannels } from './transport.js';
+
+const transportRoot = resolve(process.cwd());
+const argv = process.argv.slice(2);
+
+function flag(name: string): string | undefined {
+  const i = argv.indexOf(name);
+  if (i === -1 || i === argv.length - 1) return undefined;
+  return argv[i + 1];
+}
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+
+interface ChannelMeta {
+  uuid: string;
+  name: string | null;
+  parent: string | null;
+}
+
+function readChannelMeta(uuid: string): ChannelMeta {
+  const chPath = join(transportRoot, 'data', 'channels', uuid, 'CHANNEL.md');
+  if (!existsSync(chPath)) return { uuid, name: null, parent: null };
+  const raw = readFileSync(chPath, 'utf-8');
+  const { data } = parseFrontmatter<{ name?: unknown; parent?: unknown }>(raw);
+  return {
+    uuid,
+    name: typeof data.name === 'string' ? data.name : null,
+    parent: typeof data.parent === 'string' ? data.parent : null,
+  };
+}
+
+function allChannelMeta(): ChannelMeta[] {
+  return discoverChannels(transportRoot).map(readChannelMeta);
+}
+
+function resolveChannel(input: string): ChannelMeta | null {
+  if (UUID_RE.test(input)) {
+    const path = join(transportRoot, 'data', 'channels', input);
+    if (!existsSync(path)) return null;
+    return readChannelMeta(input);
+  }
+  for (const meta of allChannelMeta()) {
+    if (meta.name === input) return meta;
+  }
+  return null;
+}
+
+function nameExists(name: string): boolean {
+  return allChannelMeta().some((m) => m.name === name);
+}
+
+function commit(message: string): void {
+  const r = gitCommitAndPush(transportRoot, message);
+  if (!r.ok && r.error) {
+    console.error(`git ${r.committed ? 'push' : 'commit'} FAILED: ${r.error.slice(0, 300)}`);
+    process.exit(3);
+  }
+}
+
+function create(name: string): void {
+  if (UUID_RE.test(name)) {
+    console.error(`crosstalkd channel: '${name}' looks like a UUID — channel names cannot be UUID-shaped.`);
+    process.exit(1);
+  }
+  if (nameExists(name)) {
+    console.error(`crosstalkd channel: a channel named '${name}' already exists.`);
+    process.exit(1);
+  }
+  const uuid = randomUUID();
+  const dir = join(transportRoot, 'data', 'channels', uuid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, 'CHANNEL.md'), serializeFrontmatter({ name }, ''));
+  commit(`channel(create): ${name} (${uuid.slice(0, 8)})`);
+  console.log(`Created channel: ${uuid}`);
+  console.log(`  name: ${name}`);
+}
+
+function rename(input: string, newName: string): void {
+  if (UUID_RE.test(newName)) {
+    console.error(`crosstalkd channel: '${newName}' looks like a UUID — channel names cannot be UUID-shaped.`);
+    process.exit(1);
+  }
+  const meta = resolveChannel(input);
+  if (!meta) {
+    console.error(`crosstalkd channel: '${input}' not found.`);
+    process.exit(1);
+  }
+  if (meta.name === newName) {
+    console.log(`crosstalkd channel: '${meta.name}' already has that name — no-op.`);
+    return;
+  }
+  if (nameExists(newName)) {
+    console.error(`crosstalkd channel: a channel named '${newName}' already exists.`);
+    process.exit(1);
+  }
+  const chPath = join(transportRoot, 'data', 'channels', meta.uuid, 'CHANNEL.md');
+  const fm: Record<string, unknown> = { name: newName };
+  if (meta.parent) fm['parent'] = meta.parent;
+  writeFileSync(chPath, serializeFrontmatter(fm, ''));
+  commit(`channel(rename): ${meta.name ?? '(unnamed)'} -> ${newName} (${meta.uuid.slice(0, 8)})`);
+  console.log(`Renamed: ${meta.name ?? '(unnamed)'} -> ${newName}`);
+}
+
+function readStdinLine(): string {
+  try {
+    const raw = readFileSync(0, 'utf-8');
+    return raw.split('\n')[0]!.trim();
+  } catch {
+    return '';
+  }
+}
+
+function del(input: string): void {
+  const meta = resolveChannel(input);
+  if (!meta) {
+    console.error(`crosstalkd channel: '${input}' not found.`);
+    process.exit(1);
+  }
+  const displayName = meta.name ?? '(unnamed)';
+  const confirmTarget = meta.name ?? meta.uuid;
+
+  // If stdin is a TTY, prompt; otherwise read one line of piped input.
+  // Either way, the user/script must type the name back to confirm.
+  if (process.stdin.isTTY) {
+    process.stderr.write(
+      `type "${confirmTarget}" to confirm deletion of channel ${displayName} (${meta.uuid}): `,
+    );
+    // Naive blocking read of one line via spawnSync — bun + tsx don't
+    // expose a clean blocking readline in pure ESM.
+    const r = spawnSync('sh', ['-c', 'IFS= read -r line; echo "$line"'], { stdio: ['inherit', 'pipe', 'inherit'] });
+    const typed = (r.stdout?.toString() ?? '').trim();
+    if (typed !== confirmTarget) {
+      console.error('crosstalkd channel: confirmation mismatch; nothing deleted.');
+      process.exit(1);
+    }
+  } else {
+    const typed = readStdinLine();
+    if (typed !== confirmTarget) {
+      console.error(`crosstalkd channel: confirmation mismatch (expected '${confirmTarget}', got '${typed}'); nothing deleted.`);
+      process.exit(1);
+    }
+  }
+
+  const dir = join(transportRoot, 'data', 'channels', meta.uuid);
+  rmSync(dir, { recursive: true, force: true });
+  commit(`channel(delete): ${displayName} (${meta.uuid.slice(0, 8)})`);
+  console.log(`Deleted channel: ${displayName} (${meta.uuid})`);
+}
+
+// arg parsing — find the positional (first arg not starting with --, not the
+// value of a flag we recognise).
+const flagsTakingValue = new Set(['--rename']);
+let positional: string | undefined;
+for (let i = 0; i < argv.length; i++) {
+  const a = argv[i]!;
+  if (a.startsWith('--')) {
+    if (flagsTakingValue.has(a)) i++;
+    continue;
+  }
+  positional = a;
+  break;
+}
+
+const renameTarget = flag('--rename');
+const deleteMode = argv.includes('--delete');
+
+if (!positional) {
+  console.error('Usage:');
+  console.error('  crosstalkd channel <name>                            # create');
+  console.error('  crosstalkd channel <name-or-uuid> --rename <new>     # rename');
+  console.error('  crosstalkd channel <name-or-uuid> --delete           # hard delete (typed-name confirmation)');
+  process.exit(1);
+}
+
+const channelsDir = join(transportRoot, 'data', 'channels');
+if (!existsSync(channelsDir)) mkdirSync(channelsDir, { recursive: true });
+
+if (renameTarget && deleteMode) {
+  console.error('crosstalkd channel: --rename and --delete are mutually exclusive.');
+  process.exit(1);
+} else if (renameTarget) {
+  rename(positional, renameTarget);
+} else if (deleteMode) {
+  del(positional);
+} else {
+  create(positional);
+}

package/src/dispatch.ts

@@ -0,0 +1,430 @@
+// crosstalkd dispatch — the v7 loop.
+//
+// Tick: pull → scan channels for messages past the global cursor → for each
+// addressed message that wakes a claimed model, invoke the model CLI →
+// write reply (success body or failed:true + error) → commit + push.
+//
+// v7 changes vs v6 dispatch:
+//  - No host file. Machine identity is the --alias flag; claimed models
+//    come from data/models.yaml + PATH self-selection (models.ts).
+//  - Single global cursor (state.ts), not per-actor-per-channel.
+//  - No DLQ. Failures land in the channel as normal messages with
+//    failed:true + error: in frontmatter — wake-loud.
+//  - No turnq. Git rebase-retry is the correctness mechanism; turnq was
+//    a churn-reducer that didn't earn its weight.
+//  - No host-file commit / waterline logic. Cursors seed to HEAD on first
+//    boot; pre-join history is ignored (same effect as v6 waterline).
+
+import { resolve, join, dirname } from 'path';
+import { readFileSync, existsSync, appendFileSync } from 'fs';
+import { watch } from 'fs/promises';
+import { fileURLToPath } from 'url';
+
+import { loadRegistry, type ModelEntry } from './models.js';
+import {
+  discoverChannels,
+  listChannelMessages,
+  gitPull,
+  gitCommitAndPush,
+  cursorBaseline,
+  newFilesSince,
+  type ChannelMessage,
+} from './transport.js';
+import {
+  stateDir,
+  readCursor,
+  writeCursor,
+  writeHeartbeat,
+  writePidfile,
+  removePidfile,
+  logError,
+} from './state.js';
+import {
+  recipients,
+  reList,
+  extractActor,
+  decideWake,
+} from './activation.js';
+import {
+  loadProtocolPrompt,
+  loadActorPersona,
+  composeSystemPrompt,
+  invokeModelCli,
+  formatBatchedUserMessage,
+  messageSender,
+  writeReply,
+} from './invoke.js';
+import { workflowTick } from './workflow.js';
+import { writeRegistryEntry, removeRegistryEntry } from './dispatchers.js';
+import { startApi } from './api.js';
+import type { Server as HttpServer } from 'http';
+
+const RUNTIME_VERSION: string = (() => {
+  try {
+    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+    return (JSON.parse(readFileSync(pkgPath, 'utf-8')) as { version?: string }).version ?? 'unknown';
+  } catch {
+    return 'unknown';
+  }
+})();
+
+const transportRoot = resolve(process.cwd());
+const argv = process.argv.slice(2);
+
+function flag(name: string): string | undefined {
+  const i = argv.indexOf(name);
+  if (i === -1 || i === argv.length - 1) return undefined;
+  return argv[i + 1];
+}
+
+const alias = flag('--alias');
+const onceMode = argv.includes('--once');
+const jsonMode = argv.includes('--json');
+const pollSeconds = Number(flag('--poll')) || 30;
+const logFile = flag('--log-file');
+
+if (!alias) {
+  console.error('crosstalkd dispatch: --alias <name> is required (machine identity in the bus).');
+  process.exit(1);
+}
+
+function log(event: string, fields: Record<string, unknown> = {}): void {
+  let line: string;
+  if (jsonMode) {
+    line = JSON.stringify({ ts: new Date().toISOString(), event, ...fields });
+  } else {
+    const tail = Object.entries(fields)
+      .map(([k, v]) => `${k}=${typeof v === 'string' ? v : JSON.stringify(v)}`)
+      .join(' ');
+    line = `[${new Date().toISOString()}] ${event}${tail ? ' ' + tail : ''}`;
+  }
+  console.log(line);
+  if (logFile) {
+    try { appendFileSync(logFile, line + '\n'); } catch { /* best-effort */ }
+  }
+}
+
+// One pending dispatch = one message → one CLI invocation → one reply.
+// v6 grouped by (channel, model) into batches; v7 doesn't (see V7-SPEC
+// post-M2 fanout note). Each fanout sibling, each operator-piled-up
+// request, each fan-in reply gets its own invocation in parallel — N
+// model calls, N replies, fanout works as designed.
+interface PendingDispatch {
+  channelUuid: string;
+  modelName: string;
+  model: ModelEntry;
+  msg: ChannelMessage;
+  // Persona resolved by dispatchTick: prefers msg.as, falls back to the
+  // re:'d message's wake_as (workflow persona continuity).
+  invokeAs?: string;
+}
+
+async function dispatchOne(d: PendingDispatch, protocolPrompt: string): Promise<boolean> {
+  const childChannel = typeof d.msg.data['child_channel'] === 'string'
+    ? (d.msg.data['child_channel'] as string)
+    : undefined;
+  const actorName = d.invokeAs;
+  const persona = loadActorPersona(transportRoot, actorName);
+  const systemPrompt = composeSystemPrompt([protocolPrompt, persona]);
+  const fromIdentity = `${d.modelName}@${alias}`;
+  const sender = messageSender(d.msg);
+
+  log('dispatch', {
+    model: d.modelName,
+    alias,
+    channel: d.channelUuid.slice(0, 8),
+    actor: actorName ?? null,
+    child_channel: childChannel ? childChannel.slice(0, 8) : null,
+    msg: d.msg.relPath,
+  });
+
+  const env: Record<string, string> = {
+    CROSSTALK_DISPATCH_ACTOR: fromIdentity,
+    CROSSTALK_DISPATCH_CHANNEL: d.channelUuid,
+    CROSSTALK_DISPATCH_RE: d.msg.relPath,
+  };
+  if (childChannel) env['CROSSTALK_CHILD_CHANNEL'] = childChannel;
+
+  const result = await invokeModelCli(d.model, systemPrompt, d.msg.body, env);
+
+  if (result.status !== 0) {
+    writeReply({
+      transportRoot,
+      channelUuid: d.channelUuid,
+      fromModel: fromIdentity,
+      to: sender === 'unknown' ? messageSender(d.msg) : sender,
+      re: d.msg.relPath,
+      body: result.stderr.slice(0, 4000) || `(no stderr captured)`,
+      failed: { error: `model exit=${result.status}\n${result.stderr.slice(0, 1000)}` },
+    });
+    log('dispatch_failed', {
+      model: d.modelName,
+      channel: d.channelUuid.slice(0, 8),
+      msg: d.msg.relPath,
+      exit: result.status,
+    });
+    return true;
+  }
+
+  const reply = result.stdout.trim();
+  if (reply.length === 0) {
+    // Actor routed its answer via `crosstalkd run` (which auto-links re:).
+    // If it truly did nothing, the asker's `crosstalkd replies` stays
+    // PENDING — visible, never silently lost.
+    log('dispatch_silent', { model: d.modelName, channel: d.channelUuid.slice(0, 8), msg: d.msg.relPath });
+    return true;
+  }
+
+  writeReply({
+    transportRoot,
+    channelUuid: d.channelUuid,
+    fromModel: fromIdentity,
+    to: sender,
+    re: d.msg.relPath,
+    body: reply,
+  });
+  log('dispatch_done', { model: d.modelName, channel: d.channelUuid.slice(0, 8), msg: d.msg.relPath });
+  return true;
+}
+
+async function dispatchTick(claimed: Map<string, ModelEntry>, protocolPrompt: string): Promise<boolean> {
+  writeHeartbeat(transportRoot, RUNTIME_VERSION, alias!);
+
+  const pullResult = gitPull(transportRoot);
+  if (!pullResult.ok) {
+    logError(transportRoot, `git pull failed: ${pullResult.error}`);
+    log('git_pull_failed', { error: (pullResult.error ?? '').slice(0, 200) });
+    return false;
+  }
+
+  const head = cursorBaseline(transportRoot);
+  if (!head) {
+    logError(transportRoot, 'git rev-parse failed for origin/HEAD and HEAD — skipping tick');
+    return false;
+  }
+
+  let cursor = readCursor(transportRoot);
+  if (cursor === null) {
+    // First-boot seed to HEAD: pre-join history is ignored. Operators
+    // sending messages BEFORE this dispatcher first booted are not
+    // delivered — symmetric with v6's host-file-commit waterline.
+    writeCursor(transportRoot, head);
+    cursor = head;
+    log('cursor_seeded', { commit: head.slice(0, 12) });
+  }
+  const channels = discoverChannels(transportRoot);
+  const activationDue = cursor !== head;
+
+  let didWork = false;
+  if (activationDue) {
+    didWork = await runActivationPass(claimed, protocolPrompt, channels, cursor, head);
+  }
+
+  // Workflow tick runs unconditionally — an open workflow may need to
+  // advance (e.g. compile a freshly-committed marker, or progress to the
+  // synthesize phase now that all fanout replies have landed) regardless
+  // of whether the activation pass had new messages this tick.
+  const workflowProgressed = await workflowTick({ transportRoot, alias: alias!, claimed, log }, channels);
+
+  // Advance cursor regardless of per-batch success: at-least-once was
+  // attempted; failure replies are committed alongside successes. A
+  // crash mid-tick leaves the cursor where it was — next tick replays.
+  writeCursor(transportRoot, head);
+
+  const writeNeeded = didWork || workflowProgressed;
+  if (writeNeeded) {
+    const push = gitCommitAndPush(transportRoot, `dispatch(${alias}): replies ${new Date().toISOString()}`);
+    if (!push.ok && push.error) {
+      logError(transportRoot, `${push.committed ? 'push' : 'commit'} failed: ${push.error}`);
+      log('git_push_failed', { committed: push.committed, error: push.error.slice(0, 200) });
+    }
+  }
+
+  return writeNeeded;
+}
+
+async function runActivationPass(
+  claimed: Map<string, ModelEntry>,
+  protocolPrompt: string,
+  channels: string[],
+  cursor: string,
+  head: string,
+): Promise<boolean> {
+  const addedList = newFilesSince(transportRoot, cursor);
+  if (addedList === null) {
+    logError(transportRoot, `cursor ${cursor.slice(0, 12)} unknown — re-scanning all channels`);
+  }
+  const added: Set<string> | null = addedList === null ? null : new Set(addedList);
+
+  void head;  // head is the diff's upper bound implicitly (newFilesSince uses HEAD).
+  const pending: PendingDispatch[] = [];
+
+  for (const channelUuid of channels) {
+    const messages = listChannelMessages(transportRoot, channelUuid);
+    const senderByRelPath = new Map(messages.map((m) => [m.relPath, messageSender(m)]));
+    // Normalize asker identity the same way self-suppression does: strip
+    // the @machine suffix before comparing against actorName. Without
+    // this, an actor that sent a sub-message never wakes for its reply,
+    // because asker='alice@cachy' never matches actorName='alice'. The
+    // bug was masked by the workflow smoke test, which used direct
+    // stdout replies — fan-out + fan-in is the case that surfaces it.
+    const senderOf = (relPath: string) => {
+      const raw = senderByRelPath.get(relPath);
+      return raw === undefined ? undefined : extractActor(raw);
+    };
+
+    let post: ChannelMessage[];
+    if (added === null) {
+      post = messages;
+    } else {
+      const prefix = `data/channels/${channelUuid}/`;
+      post = messages.filter((m) => added.has(prefix + m.relPath));
+    }
+
+    for (const msg of post) {
+      const recipientList = recipients(msg.data['to']);
+      for (const [modelName, model] of claimed) {
+        const decision = decideWake(
+          {
+            from: extractActor(messageSender(msg)),   // self-suppression: model name, not model@alias
+            to: recipientList,
+            re: reList(msg.data['re']),
+          },
+          modelName,
+          alias!,
+          senderOf,
+        );
+        if (decision === 'wake') {
+          const invokeAs: string | undefined = typeof msg.data['as'] === 'string'
+            ? (msg.data['as'] as string)
+            : undefined;
+          pending.push({ channelUuid, modelName, model, msg, invokeAs });
+        }
+      }
+    }
+  }
+
+  // Fire all pending dispatches in parallel. Each is one model CLI call,
+  // captured by detached spawn with SIGKILL timeout (invoke.ts). N parallel
+  // claude/gemini/etc. invocations comfortably saturate one machine; if it
+  // ever becomes a problem, dispatch.ts can grow a per-model concurrency
+  // semaphore — for now KISS wins, every message gets its own dispatch.
+  const results = pending.length === 0
+    ? []
+    : await Promise.all(pending.map((d) => dispatchOne(d, protocolPrompt)));
+  return results.some(Boolean);
+}
+
+async function waitForWakeOrTimeout(ms: number): Promise<void> {
+  const dir = stateDir(transportRoot);
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), ms);
+  try {
+    const watcher = watch(dir, { signal: ac.signal });
+    for await (const ev of watcher) {
+      if (ev.filename === 'wake.signal') return;
+    }
+  } catch {
+    /* abort = timeout */
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function main(): Promise<void> {
+  writePidfile(transportRoot);
+  // Regular exit: drop the pidfile only. Do NOT drop the registry entry —
+  // (a) `--once` mode exits cleanly every tick and would churn the file
+  // between tick runs, and (b) an uncommitted local delete breaks the
+  // next `git pull --rebase` until something else commits. Registry
+  // entries should live until explicit shutdown.
+  process.on('exit', () => removePidfile(transportRoot));
+  // Explicit shutdown signals: remove pidfile + registry entry, commit
+  // the deregistration so other machines stop routing to us. Hard crash
+  // skips this and leaves a stale entry — operator-cleanup concern,
+  // not runtime correctness.
+  let apiServer: HttpServer | null = null;
+  const cleanupShutdown = () => {
+    if (apiServer) {
+      try { apiServer.close(); } catch { /* best-effort */ }
+    }
+    removePidfile(transportRoot);
+    if (alias) removeRegistryEntry(transportRoot, alias);
+    const push = gitCommitAndPush(transportRoot, `dispatch(${alias}): deregister entry`);
+    if (!push.ok && push.error) {
+      logError(transportRoot, `registry deregister failed: ${push.error}`);
+    }
+  };
+  process.on('SIGTERM', () => { cleanupShutdown(); process.exit(0); });
+  process.on('SIGINT',  () => { cleanupShutdown(); process.exit(0); });
+
+  let registry;
+  try {
+    registry = loadRegistry(transportRoot);
+  } catch (err) {
+    console.error(`crosstalkd dispatch: ${(err as Error).message}`);
+    process.exit(1);
+  }
+
+  const protocolPrompt = loadProtocolPrompt(transportRoot);
+
+  // Publish our registry entry so workflow.ts (running on this or any
+  // other machine) can scope fanout sub-primitives to specific dispatchers
+  // instead of broadcasting bare-recipient fanouts that every claimant
+  // races to duplicate. Commit+push immediately so cross-machine
+  // visibility doesn't wait for first reply traffic.
+  writeRegistryEntry(transportRoot, alias!, [...registry.claimed.keys()], RUNTIME_VERSION);
+  const registryPush = gitCommitAndPush(transportRoot, `dispatch(${alias}): register entry`);
+  if (!registryPush.ok && registryPush.error) {
+    logError(transportRoot, `registry publish failed: ${registryPush.error}`);
+  }
+
+  log('dispatch_start', {
+    transport: transportRoot,
+    alias,
+    version: RUNTIME_VERSION,
+    state_dir: stateDir(transportRoot),
+    claimed_models: [...registry.claimed.keys()],
+    total_models: registry.all.size,
+  });
+
+  // Start the HTTP API on 127.0.0.1 so the host-side `crosstalk` client
+  // can talk to us. --once mode skips this — short-lived processes don't
+  // serve, and the test harnesses that invoke --once would conflict on
+  // the port. Operators get the API when running the continuous loop.
+  if (!onceMode) {
+    apiServer = startApi(
+      {
+        transportRoot,
+        alias: alias!,
+        version: RUNTIME_VERSION,
+        claimed: registry.claimed,
+      },
+      { log },
+    );
+  }
+
+  if (onceMode) {
+    await dispatchTick(registry.claimed, protocolPrompt);
+    process.exit(0);
+  }
+  log('dispatch_running', { poll_s: pollSeconds });
+
+  while (true) {
+    try {
+      const didWork = await dispatchTick(registry.claimed, protocolPrompt);
+      if (didWork) {
+        await new Promise((res) => setTimeout(res, 1_000));
+      } else {
+        await waitForWakeOrTimeout(pollSeconds * 1_000);
+      }
+    } catch (err) {
+      const msg = (err as Error).message;
+      logError(transportRoot, `tick error: ${msg}`);
+      log('tick_error', { message: msg });
+      await new Promise((res) => setTimeout(res, pollSeconds * 1_000));
+    }
+  }
+}
+
+main();