ticlawk 0.1.12-dev.0

package/src/runtimes/pi/session.mjs

@@ -0,0 +1,423 @@
+/**
+ * pi local session helpers.
+ *
+ * pi exposes a JSONL RPC mode over stdin/stdout via `pi --mode rpc`. We spawn
+ * one RPC process per turn, stream text deltas while it runs, then read the
+ * final assistant message and session state before terminating the process.
+ */
+
+import { existsSync, mkdirSync, readFileSync, readdirSync } from 'node:fs';
+import { readFile, stat, writeFile } from 'node:fs/promises';
+import { spawn, spawnSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { extname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { buildRuntimeEnv } from '../../core/runtime-env.mjs';
+import { getRuntimeExecutableConfig } from '../../core/config.mjs';
+import { isExecutablePath, resolveExecutable } from '../../core/executables.mjs';
+
+export const DEFAULT_PI_COMMAND = 'pi';
+export const PI_AGENT_DIR = process.env.PI_CODING_AGENT_DIR || `${homedir()}/.pi/agent`;
+export const PI_SESSIONS_DIR = process.env.PI_SESSIONS_DIR || `${PI_AGENT_DIR}/sessions`;
+export const PI_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+export const DEFAULT_PI_RUN_TIMEOUT_MS = 7200 * 1000;
+
+const EXT_TO_MIME = {
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.png': 'image/png',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.bmp': 'image/bmp',
+  '.tiff': 'image/tiff',
+  '.tif': 'image/tiff',
+  '.heic': 'image/heic',
+  '.heif': 'image/heif',
+};
+
+function buildPiError(message, info) {
+  const wrapped = new Error(message);
+  wrapped.info = info;
+  return wrapped;
+}
+
+export function resolvePiPath(preferredPath = null) {
+  return resolveExecutable({
+    command: DEFAULT_PI_COMMAND,
+    preferredPath,
+    configuredPath: getRuntimeExecutableConfig('pi'),
+    envKey: 'PI_BIN',
+  });
+}
+
+export function requirePiPath(preferredPath = null) {
+  const requested = String(preferredPath || '').trim();
+  if (requested && requested.includes('/') && !isExecutablePath(requested)) {
+    throw new Error(`pi CLI is no longer available at: ${requested}. Reconnect this pi agent or set PI_BIN / \`ticlawk config set runtimes.pi.path <path>\`.`);
+  }
+  const piPath = resolvePiPath(preferredPath);
+  if (piPath) return piPath;
+  throw new Error('pi CLI not found. Install pi, ensure it is on PATH, or set PI_BIN / `ticlawk config set runtimes.pi.path <path>`.');
+}
+
+export function getPiRuntimeHealth(preferredPath = null) {
+  const piPath = resolvePiPath(preferredPath);
+  return {
+    available: Boolean(piPath),
+    path: piPath,
+    version: getPiVersion(piPath),
+  };
+}
+
+function getPiVersion(piPath) {
+  if (!piPath) return null;
+  const result = spawnSync(piPath, ['--version'], {
+    env: buildRuntimeEnv(),
+    encoding: 'utf8',
+    timeout: 15000,
+  });
+  if (result.error || result.status !== 0) return null;
+  const output = `${result.stdout || ''}${result.stderr || ''}`.trim();
+  return output.split('\n').map(line => line.trim()).find(Boolean) || null;
+}
+
+function encodeSessionDirName(cwd) {
+  return `--${String(cwd || '').replace(/^[/\\]/, '').replace(/[/\\:]/g, '-')}--`;
+}
+
+function walkJsonlFiles(rootDir) {
+  if (!existsSync(rootDir)) return [];
+  const files = [];
+  const stack = [rootDir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let entries = [];
+    try {
+      entries = readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+
+function readSessionHeader(filePath) {
+  try {
+    const firstLine = readFileSync(filePath, 'utf8').split('\n').find(line => line.trim());
+    const header = firstLine ? JSON.parse(firstLine) : null;
+    if (header?.type !== 'session' || !header.id) return null;
+    return {
+      sessionId: String(header.id),
+      cwd: header.cwd || '',
+      path: filePath,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function discoverPiSessions(cwd = null, rootDir = PI_SESSIONS_DIR) {
+  const searchRoot = cwd ? join(rootDir, encodeSessionDirName(cwd)) : rootDir;
+  return walkJsonlFiles(searchRoot)
+    .map(readSessionHeader)
+    .filter(Boolean);
+}
+
+export function findPiSessionById(sessionId, cwd = null) {
+  if (!sessionId) return null;
+  return discoverPiSessions(cwd).find((session) => {
+    return session.sessionId === sessionId || session.sessionId.startsWith(sessionId);
+  }) || null;
+}
+
+function buildPiRpcArgs({ sessionId }) {
+  const args = ['--mode', 'rpc'];
+  if (sessionId) args.push('--session', sessionId);
+  return args;
+}
+
+function serializeJsonLine(value) {
+  return `${JSON.stringify(value)}\n`;
+}
+
+function extractDeltaFromEvent(event) {
+  const messageEvent = event?.assistantMessageEvent || event?.messageEvent || event?.event || event;
+  if (!messageEvent || typeof messageEvent !== 'object') return '';
+  if (messageEvent.type === 'text_delta') {
+    return typeof messageEvent.delta === 'string' ? messageEvent.delta : '';
+  }
+  for (const key of ['delta', 'textDelta', 'text', 'content']) {
+    if (typeof messageEvent[key] === 'string') return messageEvent[key];
+  }
+  return '';
+}
+
+function extractFinalTextFromEvent(event) {
+  if (!event || typeof event !== 'object') return '';
+  if (Array.isArray(event.messages)) {
+    const assistant = [...event.messages].reverse().find((message) => message?.role === 'assistant');
+    const content = assistant?.content;
+    if (typeof content === 'string') return content;
+    if (Array.isArray(content)) {
+      return content
+        .map((part) => typeof part === 'string' ? part : (part?.text || part?.content || ''))
+        .filter(Boolean)
+        .join('');
+    }
+  }
+  return '';
+}
+
+function shouldAnswerExtensionRequest(event) {
+  return event?.type === 'extension_ui_request'
+    && event.id
+    && ['select', 'confirm', 'input', 'editor'].includes(event.method);
+}
+
+function extensionCancelResponse(event) {
+  if (event.method === 'confirm') {
+    return { type: 'extension_ui_response', id: event.id, confirmed: false };
+  }
+  return { type: 'extension_ui_response', id: event.id, cancelled: true };
+}
+
+export function runPiPrompt({
+  sessionId,
+  cwd,
+  message,
+  images = [],
+  piPath = null,
+  timeoutMs = Number(process.env.PI_RUN_TIMEOUT_MS || DEFAULT_PI_RUN_TIMEOUT_MS),
+  onEvent,
+}) {
+  return new Promise((resolve, reject) => {
+    const startedAt = Date.now();
+    const piCommand = requirePiPath(piPath);
+    const child = spawn(piCommand, buildPiRpcArgs({ sessionId }), {
+      cwd,
+      env: buildRuntimeEnv(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    let nextId = 1;
+    let lineBuffer = '';
+    let stderr = '';
+    let activeSessionId = sessionId || null;
+    let activeSessionFile = null;
+    let finalText = '';
+    let settled = false;
+    let eventChain = Promise.resolve();
+    const pending = new Map();
+
+    const emit = (event) => {
+      if (typeof onEvent !== 'function') return;
+      eventChain = eventChain.then(() => onEvent(event)).catch(() => {});
+    };
+
+    const settle = (fn, value) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      for (const { reject: rejectPending } of pending.values()) {
+        try { rejectPending(new Error('pi RPC process closed')); } catch {}
+      }
+      pending.clear();
+      try { child.kill('SIGTERM'); } catch {}
+      eventChain.catch(() => {}).finally(() => fn(value));
+    };
+
+    const sendRaw = (payload) => {
+      child.stdin.write(serializeJsonLine(payload));
+    };
+
+    const send = (command, responseTimeoutMs = 30000) => {
+      const id = `req_${nextId++}`;
+      const payload = { ...command, id };
+      return new Promise((resolvePending, rejectPending) => {
+        const responseTimeout = setTimeout(() => {
+          pending.delete(id);
+          rejectPending(new Error(`timeout waiting for pi response to ${command.type}`));
+        }, responseTimeoutMs);
+        responseTimeout.unref?.();
+        pending.set(id, {
+          resolve: (response) => {
+            clearTimeout(responseTimeout);
+            if (response?.success === false) {
+              rejectPending(new Error(response.error || `pi ${command.type} failed`));
+              return;
+            }
+            resolvePending(response?.data);
+          },
+          reject: rejectPending,
+        });
+        sendRaw(payload);
+      });
+    };
+
+    const completion = new Promise((resolveCompletion, rejectCompletion) => {
+      child.on('error', (err) => {
+        rejectCompletion(buildPiError(err.message || 'pi spawn failed', {
+          ok: false,
+          code: null,
+          signal: null,
+          durationMs: Date.now() - startedAt,
+          kind: 'spawn-failed',
+          error: err.message,
+        }));
+      });
+
+      child.on('exit', (code, signal) => {
+        if (settled) return;
+        rejectCompletion(buildPiError(`pi exited before turn completion${code !== null ? ` (code ${code})` : ''}${signal ? ` (${signal})` : ''}`, {
+          ok: false,
+          code,
+          signal,
+          durationMs: Date.now() - startedAt,
+          kind: signal ? 'killed' : 'exit-error',
+          errorMessage: stderr.trim() || 'pi exited before turn completion',
+        }));
+      });
+
+      const handleEvent = (event) => {
+        if (shouldAnswerExtensionRequest(event)) {
+          sendRaw(extensionCancelResponse(event));
+          return;
+        }
+        if (event?.type === 'agent_start') {
+          emit({ type: 'turn.started', sessionId: activeSessionId });
+          return;
+        }
+        if (event?.type === 'message_update') {
+          const delta = extractDeltaFromEvent(event);
+          if (delta) {
+            finalText += delta;
+            emit({ type: 'message.delta', sessionId: activeSessionId, text: delta });
+          }
+          return;
+        }
+        if (event?.type === 'agent_end') {
+          finalText = extractFinalTextFromEvent(event) || finalText;
+          resolveCompletion();
+        }
+      };
+
+      child.stdout.on('data', (chunk) => {
+        lineBuffer += chunk.toString('utf8');
+        const lines = lineBuffer.split('\n');
+        lineBuffer = lines.pop() || '';
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          let msg;
+          try { msg = JSON.parse(trimmed); } catch { continue; }
+          if (msg?.type === 'response' && msg.id && pending.has(msg.id)) {
+            pending.get(msg.id).resolve(msg);
+            pending.delete(msg.id);
+            continue;
+          }
+          handleEvent(msg);
+        }
+      });
+    });
+
+    child.stderr.on('data', (chunk) => {
+      stderr = (stderr + chunk.toString('utf8')).slice(-4000);
+    });
+
+    let timeout = null;
+    if (timeoutMs > 0) {
+      timeout = setTimeout(() => {
+        settle(reject, buildPiError('pi turn timed out', {
+          ok: false,
+          code: null,
+          signal: 'SIGTERM',
+          durationMs: Date.now() - startedAt,
+          kind: 'killed',
+          errorMessage: 'pi turn timed out',
+        }));
+      }, timeoutMs);
+      timeout.unref();
+    }
+
+    (async () => {
+      try {
+        await send({ type: 'prompt', message, images });
+        await completion;
+        const state = await send({ type: 'get_state' }).catch(() => null);
+        const lastAssistant = await send({ type: 'get_last_assistant_text' }).catch(() => null);
+        activeSessionId = state?.sessionId || activeSessionId;
+        activeSessionFile = state?.sessionFile || activeSessionFile;
+        const text = lastAssistant?.text || finalText;
+        if (!activeSessionId) {
+          throw buildPiError('pi session id missing from output', {
+            ok: false,
+            code: 0,
+            signal: null,
+            durationMs: Date.now() - startedAt,
+            kind: 'invalid-output',
+            errorMessage: 'pi session id missing from output',
+          });
+        }
+        settle(resolve, {
+          sessionId: activeSessionId,
+          cwd,
+          path: activeSessionFile,
+          text,
+          durationMs: Date.now() - startedAt,
+        });
+      } catch (err) {
+        settle(reject, buildPiError(err?.message || 'pi failed', {
+          ok: false,
+          code: null,
+          signal: null,
+          durationMs: Date.now() - startedAt,
+          kind: err?.info?.kind || 'gateway-error',
+          errorMessage: err?.info?.errorMessage || err?.message || stderr.trim() || 'pi failed',
+        }));
+      }
+    })();
+  });
+}
+
+async function readLocalMedia(path) {
+  const stats = await stat(path).catch(() => null);
+  if (!stats?.isFile() || stats.size === 0) return null;
+  const data = await readFile(path);
+  const mimeType = EXT_TO_MIME[extname(path).toLowerCase()] || 'application/octet-stream';
+  return { type: 'image', mimeType, data: data.toString('base64') };
+}
+
+async function downloadRemoteMedia(url, mime = null) {
+  const mediaDir = '/tmp/ticlawk/pi-media';
+  mkdirSync(mediaDir, { recursive: true });
+  const guessedExt = extname(String(url).split('?')[0] || '').toLowerCase() || '.jpg';
+  const localPath = join(mediaDir, `${randomUUID()}${guessedExt}`);
+  const res = await fetch(url);
+  const buf = Buffer.from(await res.arrayBuffer());
+  await writeFile(localPath, buf);
+  const mimeType = mime || EXT_TO_MIME[guessedExt] || res.headers.get('content-type') || 'application/octet-stream';
+  return { type: 'image', mimeType, data: buf.toString('base64') };
+}
+
+export async function buildPiImagesFromInbound(inbound) {
+  const images = [];
+  for (const item of inbound?.media || []) {
+    try {
+      if (item.kind === 'local_path' && item.value && existsSync(item.value)) {
+        const image = await readLocalMedia(item.value);
+        if (image) images.push(image);
+      } else if (item.kind === 'remote_url' && item.value) {
+        images.push(await downloadRemoteMedia(item.value, item.mime));
+      }
+    } catch {}
+  }
+  return images;
+}

package/ticlawk.mjs

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+
+/**
+ * ticlawk.mjs
+ *
+ * Connects local runtimes to a selected adapter.
+ *
+ * The daemon owns runtime lifecycle, local config, and the local control
+ * HTTP surface. Each adapter owns its own setup/auth semantics,
+ * inbound loop, outbound write path, and any backend-specific metadata.
+ */
+
+// IMPORTANT: import ./src/core/config.mjs FIRST so dotenv runs before any
+// other import reads process.env at module-eval time.
+import {
+  AF_HOME,
+  AF_CONFIG_PATH,
+  AF_LOG_PATH,
+  AF_CRASH_LOG_PATH,
+  getConfiguredAdapter,
+  loadPersistentConfig,
+  persistConfig,
+} from './src/core/config.mjs';
+import { startLocalHttpServer } from './src/core/http.mjs';
+import { installProcessDiagnostics } from './src/core/diagnostics.mjs';
+import * as logger from './src/core/logger.mjs';
+import { Bus } from './src/core/bus.mjs';
+import { createAdapter } from './src/core/adapter-registry.mjs';
+import { getBinding, listBindings, upsertBinding, deleteBinding, findBindingByTarget } from './src/core/bindings/store.mjs';
+import { buildRuntimeContext, normalizeServiceType } from './src/core/runtime-registry.mjs';
+import { belongsToRuntimeHost, getBindingRuntimeHostId, getHostId } from './src/core/host-id.mjs';
+import { readPkgVersion } from './src/core/update.mjs';
+import { buildImageMessageFromInbound } from './src/core/media/inbound.mjs';
+
+// Re-export the config-owned paths so local tooling can inspect the
+// ticlawk home/config/log locations without reaching into src/.
+export {
+  AF_HOME,
+  AF_CONFIG_PATH,
+  AF_LOG_PATH,
+  AF_CRASH_LOG_PATH,
+  loadPersistentConfig,
+  persistConfig,
+};
+
+// ── Daemon ──────────────────────────────────────────────────────────────
+
+const HTTP_PORT = process.env.FEED_RELAY_PORT || 8741;
+
+// Single Bus instance for the daemon. Adapters and the inbound poller
+// dispatch through it; the Bus enforces per-(runtime, channelId)
+// serialization.
+const bus = new Bus();
+
+// ── Main ────────────────────────────────────────────────────────────────
+
+let started = false;
+
+function createResolveRuntimeBinding(runtimes) {
+  return async (payload) => {
+    const requested = normalizeServiceType(payload?.serviceType);
+    const runtime = runtimes[requested];
+    if (!runtime?.resolveBinding) {
+      throw new Error(`runtime does not support binding resolution: ${requested}`);
+    }
+    return runtime.resolveBinding(payload);
+  };
+}
+
+function createUpsertBindingWithSync(runtimes, adapter) {
+  return async (binding) => {
+    const nextBinding = await upsertBinding(binding);
+    const runtime = nextBinding?.runtime ? runtimes[nextBinding.runtime] : null;
+    if (typeof runtime?.onBindingUpdated === 'function') {
+      await runtime.onBindingUpdated(nextBinding, { adapter, logger });
+    }
+    if (typeof adapter.syncBinding === 'function') {
+      await adapter.syncBinding(nextBinding);
+    }
+    return nextBinding;
+  };
+}
+
+function createCacheBinding(runtimes, getAdapter) {
+  return async (binding) => {
+    const nextBinding = await upsertBinding(binding);
+    if (!belongsToRuntimeHost(nextBinding)) {
+      logger.debugError('core', 'binding.cache-host-mismatch', {
+        bindingId: nextBinding.id,
+        adapter: nextBinding.adapter,
+        hostId: getHostId(),
+        runtime_host_id: getBindingRuntimeHostId(nextBinding),
+      });
+      return nextBinding;
+    }
+    const runtime = nextBinding?.runtime ? runtimes[nextBinding.runtime] : null;
+    const adapter = getAdapter();
+    if (typeof runtime?.onBindingUpdated === 'function') {
+      await runtime.onBindingUpdated(nextBinding, { adapter, logger });
+    }
+    return nextBinding;
+  };
+}
+
+function createBaseRuntimeCtx(runtimes, cacheBinding, upsertBindingWithSync) {
+  return {
+    runtimes,
+    getBinding,
+    listBindings,
+    deleteBinding,
+    cacheBinding,
+    upsertBinding: upsertBindingWithSync,
+    buildImageMessageFromInbound,
+    logger,
+  };
+}
+
+function createAdapterContext(baseRuntimeCtx, resolveRuntimeBinding) {
+  return {
+    bus,
+    ...baseRuntimeCtx,
+    findBindingByTarget,
+    resolveRuntimeBinding,
+  };
+}
+
+function printBanner(adapter) {
+  const version = readPkgVersion() || 'unknown';
+  console.log('╔══════════════════════════════════════╗');
+  console.log(`║  ticlawk  v${version.padEnd(15).slice(0, 15)}║`);
+  console.log('╚══════════════════════════════════════╝');
+  console.log(`[ticlawk] adapter: ${adapter.id}`);
+  if (adapter.id === 'ticlawk') {
+    console.log(`[ticlawk] API: ${process.env.TICLAWK_API_URL || 'https://ticlawk.com'}`);
+  }
+}
+
+function registerRuntimeHandlers(runtimeList, baseRuntimeCtx, adapter) {
+  for (const runtime of runtimeList) {
+    bus.registerRuntime(runtime.name, async (inbound) => {
+      return runtime.deliverTurn(inbound, {
+        adapter,
+        ...baseRuntimeCtx,
+      });
+    });
+  }
+}
+
+async function replayBindings(runtimes, adapter) {
+  const hostId = getHostId();
+  for (const binding of listBindings()) {
+    if (!belongsToRuntimeHost(binding, hostId)) {
+      logger.debugError('core', 'binding.replay-host-mismatch', {
+        bindingId: binding.id,
+        adapter: binding.adapter,
+        hostId,
+        runtime_host_id: getBindingRuntimeHostId(binding),
+      });
+      continue;
+    }
+    const runtime = binding.runtime ? runtimes[binding.runtime] : null;
+    if (typeof runtime?.onBindingUpdated !== 'function') continue;
+    try {
+      await runtime.onBindingUpdated(binding, { adapter, logger });
+    } catch (err) {
+      logger.debugError('startup', 'replayBindings.failed', {
+        runtime: binding.runtime,
+        bindingId: binding.id,
+        error: err?.message || String(err),
+      });
+    }
+  }
+}
+
+async function recoverAllRuntimes(runtimeList, adapter) {
+  for (const runtime of runtimeList) {
+    if (typeof runtime.recoverInFlight !== 'function') continue;
+    try {
+      await runtime.recoverInFlight({
+        adapter,
+        getBinding,
+      });
+    } catch (err) {
+      logger.debugError('startup', 'recoverInFlight.failed', {
+        runtime: runtime.name,
+        error: err?.message || String(err),
+      });
+    }
+  }
+}
+
+async function reconcileBindingsAfterRestart(runtimes, adapter) {
+  const hostId = getHostId();
+  for (const binding of listBindings({ adapter: adapter.id })) {
+    if (!belongsToRuntimeHost(binding, hostId)) {
+      logger.debugError('core', 'binding.reconcile-host-mismatch', {
+        bindingId: binding.id,
+        adapter: binding.adapter,
+        hostId,
+        runtime_host_id: getBindingRuntimeHostId(binding),
+      });
+      continue;
+    }
+    const runtime = binding.runtime ? runtimes[binding.runtime] : null;
+    if (typeof runtime?.reconcileAfterRestart !== 'function') continue;
+    try {
+      await runtime.reconcileAfterRestart(binding, {
+        adapter,
+        logger,
+      });
+    } catch (err) {
+      logger.debugError('startup', 'reconcileAfterRestart.failed', {
+        runtime: binding.runtime,
+        bindingId: binding.id,
+        error: err?.message || String(err),
+      });
+    }
+  }
+}
+
+export async function startTiclawk() {
+  if (started) return;
+  started = true;
+  installProcessDiagnostics();
+
+  const { runtimeList, runtimes } = await buildRuntimeContext();
+  const resolveRuntimeBinding = createResolveRuntimeBinding(runtimes);
+  const configuredAdapter = getConfiguredAdapter();
+  let adapter;
+  const cacheBinding = createCacheBinding(runtimes, () => adapter);
+  let baseRuntimeCtx;
+  let syncBinding = async (binding) => {
+    if (!adapter) {
+      throw new Error('adapter not initialized');
+    }
+    return upsertBinding(binding);
+  };
+  baseRuntimeCtx = createBaseRuntimeCtx(runtimes, cacheBinding, (binding) => syncBinding(binding));
+  adapter = createAdapter(
+    configuredAdapter,
+    createAdapterContext(baseRuntimeCtx, resolveRuntimeBinding)
+  );
+  syncBinding = createUpsertBindingWithSync(runtimes, adapter);
+  baseRuntimeCtx = createBaseRuntimeCtx(runtimes, cacheBinding, (binding) => syncBinding(binding));
+
+  printBanner(adapter);
+  if (typeof adapter.refreshBindings === 'function') {
+    await adapter.refreshBindings();
+  }
+  registerRuntimeHandlers(runtimeList, baseRuntimeCtx, adapter);
+  await replayBindings(runtimes, adapter);
+  startLocalHttpServer({ port: HTTP_PORT, adapter });
+  await recoverAllRuntimes(runtimeList, adapter);
+  await reconcileBindingsAfterRestart(runtimes, adapter);
+  await adapter.start();
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  startTiclawk();
+}