@inneranimalmedia/agentsam-sdk 2.6.1 → 2.6.3

package/src/local/migrations.js

@@ -37,6 +37,52 @@ function checksumSource(source) {
   return 'fnv1a32:' + (hash >>> 0).toString(16).padStart(8, '0');
 }
 
+// A naive source.split(';') breaks on ANY semicolon -- including one
+// inside a wrapped comment line's prose ("...available; standalone...")
+// and every semicolon inside a CREATE TRIGGER's BEGIN...END body. Both
+// happen in real migration files (this one has both). Comment-strip first,
+// then split statement-aware: only treat ';' as a terminator outside a
+// BEGIN/END block, so a trigger body survives as one statement instead of
+// fragmenting into pieces that don't individually look like anything.
+function stripSqlComments(source) {
+  return source
+    .split('\n')
+    .map((line) => (line.trim().startsWith('--') ? '' : line))
+    .join('\n');
+}
+
+function splitSqlStatements(source) {
+  const clean = stripSqlComments(source);
+  // CASE ... END is also closed by the bare keyword END (no BEGIN of its
+  // own) -- a trigger body containing a CASE expression has one more END
+  // than BEGIN. Track BEGIN and CASE as the same depth-increasing class so
+  // a CASE's END doesn't prematurely close the enclosing trigger's depth.
+  const tokens = clean.split(/(\bBEGIN\b|\bCASE\b|\bEND\b|;)/i);
+  const statements = [];
+  let current = '';
+  let depth = 0;
+  for (const token of tokens) {
+    if (/^(BEGIN|CASE)$/i.test(token)) { depth += 1; current += token; continue; }
+    if (/^END$/i.test(token)) { depth = Math.max(0, depth - 1); current += token; continue; }
+    if (token === ';' && depth === 0) {
+      const trimmed = current.trim();
+      if (trimmed) statements.push(trimmed);
+      current = '';
+      continue;
+    }
+    current += token;
+  }
+  const trimmed = current.trim();
+  if (trimmed) statements.push(trimmed);
+  return statements;
+}
+
+function isIdempotentSafe(source) {
+  const statements = splitSqlStatements(source);
+  const IDEMPOTENT_RE = /^(CREATE\s+TABLE\s+IF\s+NOT\s+EXISTS|CREATE\s+(UNIQUE\s+)?INDEX\s+IF\s+NOT\s+EXISTS|CREATE\s+TRIGGER\s+IF\s+NOT\s+EXISTS|PRAGMA)/i;
+  return statements.length > 0 && statements.every((stmt) => IDEMPOTENT_RE.test(stmt.trim()));
+}
+
 export async function listAppliedMigrations(db) {
   ensureLedger(db);
   const result = await db.prepare(
@@ -60,7 +106,23 @@ export async function applyRuntimeMigrations(db, options = {}) {
 
     if (previous) {
       if (previous.checksum && previous.checksum !== checksum) {
-        throw new Error('migration_checksum_mismatch:' + id);
+        if (!isIdempotentSafe(source)) throw new Error('migration_checksum_mismatch:' + id);
+        // File grew via additive, idempotent statements only (e.g. a new
+        // CREATE TABLE IF NOT EXISTS appended for a later feature). Safe to
+        // re-run and accept the new checksum rather than hard-lock the CLI.
+        db.exec('BEGIN IMMEDIATE');
+        try {
+          db.exec(source);
+          await db.prepare(
+            'UPDATE agentsam_schema_migrations SET checksum = ? WHERE id = ?'
+          ).bind(checksum, id).run();
+          db.exec('COMMIT');
+          results.push({ id, filename, status: 'repaired', checksum, previous_checksum: previous.checksum });
+          continue;
+        } catch (error) {
+          try { db.exec('ROLLBACK'); } catch {}
+          throw new Error('migration_repair_failed:' + id + ':' + (error?.message || error));
+        }
       }
       results.push({ id, filename, status: 'already_applied', checksum });
       continue;
@@ -88,6 +150,52 @@ export async function applyRuntimeMigrations(db, options = {}) {
   });
 }
 
+// Synchronous entry point for the interactive shell. Both runners consume the
+// same versioned SQL and checksums; schema ownership stays in migrations/runtime.
+export function applyRuntimeMigrationsSync(db, options = {}) {
+  const dir = path.resolve(options.migrationsDir || DEFAULT_MIGRATIONS_DIR);
+  ensureLedger(db);
+  const applied = new Map(db.prepare(
+    'SELECT id, applied_at_unix, checksum FROM agentsam_schema_migrations ORDER BY id'
+  ).all().map((row) => [String(row.id), row]));
+  const results = [];
+  for (const filename of migrationFiles(dir)) {
+    const id = filename.replace(/\.sql$/i, '');
+    const source = fs.readFileSync(path.join(dir, filename), 'utf8');
+    const checksum = checksumSource(source);
+    const previous = applied.get(id);
+    if (previous) {
+      if (previous.checksum && previous.checksum !== checksum) {
+        if (!isIdempotentSafe(source)) throw new Error('migration_checksum_mismatch:' + id);
+        db.exec('BEGIN IMMEDIATE');
+        try {
+          db.exec(source);
+          db.prepare('UPDATE agentsam_schema_migrations SET checksum = ? WHERE id = ?').run(checksum, id);
+          db.exec('COMMIT');
+          results.push({ id, filename, status: 'repaired', checksum, previous_checksum: previous.checksum });
+          continue;
+        } catch (error) {
+          try { db.exec('ROLLBACK'); } catch {}
+          throw new Error('migration_repair_failed:' + id + ':' + (error?.message || error));
+        }
+      }
+      results.push({ id, filename, status: 'already_applied', checksum });
+      continue;
+    }
+    db.exec('BEGIN IMMEDIATE');
+    try {
+      db.exec(source);
+      db.prepare('INSERT INTO agentsam_schema_migrations (id, checksum) VALUES (?, ?)').run(id, checksum);
+      db.exec('COMMIT');
+      results.push({ id, filename, status: 'applied', checksum });
+    } catch (error) {
+      try { db.exec('ROLLBACK'); } catch {}
+      throw new Error('migration_failed:' + id + ':' + (error?.message || error));
+    }
+  }
+  return Object.freeze({ migrationsDir: dir, total: results.length, applied: results.filter((row) => row.status === 'applied').length, results: Object.freeze(results) });
+}
+
 export function runtimeMigrationsDirectory() {
   return DEFAULT_MIGRATIONS_DIR;
 }

package/src/local/runtime-store.js

@@ -2,12 +2,28 @@ import path from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { createLocalSqliteDatabase } from './sqlite.js';
 import { applyRuntimeMigrations } from './migrations.js';
+import { findCliProjectRoot } from '../lib/cli-preferences.js';
+import { getLocalDatabasePath, tryReadProjectConfig } from '../lib/project-config.js';
 
 function clean(value) { return value == null ? '' : String(value).trim(); }
 function hash(value) { return createHash('sha256').update(String(value || '')).digest('hex'); }
 
-export function runtimeDatabasePath(cwd = process.cwd()) {
-  return path.join(path.resolve(cwd), '.agentsam', 'data', 'agentsam.sqlite');
+export const SQLITE_RUNTIME_CAPABILITIES = Object.freeze({
+  transactions: true,
+  relational_queries: true,
+  ttl_cleanup: 'application_managed',
+  remote_shared_state: false,
+  local_only: true,
+  concurrent_writers: 'sqlite_serialized',
+  migrations: true,
+  vector_search: false,
+  blob_storage: false,
+  distributed_actor_semantics: false,
+});
+
+export function runtimeDatabasePath(startDir = process.cwd()) {
+  const root = findCliProjectRoot(startDir);
+  return path.resolve(root, getLocalDatabasePath(tryReadProjectConfig(root)));
 }
 
 async function withStore(cwd, fn) {
@@ -26,7 +42,7 @@ export function createRuntimeRunId() {
 
 export async function startRuntimeRun(value = {}) {
   const id = clean(value.id) || createRuntimeRunId();
-  await withStore(value.cwd, async (db) => {
+  await withStore(value.projectRoot || value.cwd, async (db) => {
     await db.prepare(`
       INSERT INTO agentsam_agent_run (
         id, account_id, source_client, surface, mode, model_key,
@@ -46,7 +62,7 @@ export async function startRuntimeRun(value = {}) {
 
 export async function finishRuntimeRun(value = {}) {
   if (!clean(value.id)) return;
-  await withStore(value.cwd, async (db) => {
+  await withStore(value.projectRoot || value.cwd, async (db) => {
     const usage = value.usage || {};
     await db.prepare(`
       UPDATE agentsam_agent_run
@@ -87,7 +103,7 @@ export async function recordRuntimeCompaction(value = {}) {
   const after = Math.max(0, Math.round(Number(value.tokens_after || 0)));
   const sourceHash = hash(summary || JSON.stringify(value.metadata || {}));
 
-  await withStore(value.cwd, async (db) => {
+  await withStore(value.projectRoot || value.cwd, async (db) => {
     await db.prepare(`
       INSERT INTO agentsam_compaction_events (
         id, account_id, agent_run_id, compaction_type, compaction_scope,
@@ -139,3 +155,13 @@ export async function recordRuntimeCompaction(value = {}) {
   });
   return id;
 }
+
+export async function pruneExpiredRuntimeState(value = {}) {
+  const nowUnix = Number.isFinite(Number(value.nowUnix)) ? Math.floor(Number(value.nowUnix)) : Math.floor(Date.now() / 1000);
+  return withStore(value.projectRoot || value.cwd, async (db) => {
+    const digests = await db.prepare('DELETE FROM agentsam_context_digest WHERE expires_at_unix IS NOT NULL AND expires_at_unix <= ?').bind(nowUnix).run();
+    const compactions = await db.prepare('DELETE FROM agentsam_compaction_events WHERE expires_at_epoch IS NOT NULL AND expires_at_epoch <= ?').bind(nowUnix).run();
+    const approvals = await db.prepare("UPDATE agentsam_approval_queue SET status = 'expired' WHERE status = 'pending' AND expires_at IS NOT NULL AND expires_at <= ?").bind(nowUnix).run();
+    return { digests: Number(digests.changes || 0), compactions: Number(compactions.changes || 0), approvals_expired: Number(approvals.changes || 0) };
+  });
+}

package/src/local/sqlite.js

@@ -1,7 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { createRequire } from 'node:module';
 import { applyRuntimeMigrations } from './migrations.js';
 
+const require = createRequire(import.meta.url);
+
 async function loadSqlite() {
   try {
     return await import('node:sqlite');
@@ -18,11 +21,43 @@ function resolveFile(filePath) {
   return path.resolve(String(filePath || '.agentsam/data/agentsam.sqlite'));
 }
 
+function prepareDatabaseFile(resolved) {
+  const dir = path.dirname(resolved);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  if (process.platform !== 'win32') {
+    try { fs.chmodSync(dir, 0o700); } catch { /* platform policy may own directory mode */ }
+  }
+}
+
+function restrictDatabaseFile(resolved) {
+  if (process.platform !== 'win32') {
+    try { fs.chmodSync(resolved, 0o600); } catch { /* platform policy may own file mode */ }
+  }
+}
+
+// The shell's session API is synchronous. It uses the same database file and
+// migration directory as the async runtime store, with no second state store.
+export function createLocalSqliteDatabaseSync(filePath = '.agentsam/data/agentsam.sqlite') {
+  let DatabaseSync;
+  try { ({ DatabaseSync } = require('node:sqlite')); }
+  catch (error) {
+    const wrapped = new Error('Local SQLite requires Node 22.5+ (node:sqlite). Upgrade Node, then retry.');
+    wrapped.cause = error;
+    throw wrapped;
+  }
+  const resolved = resolveFile(filePath);
+  prepareDatabaseFile(resolved);
+  const db = new DatabaseSync(resolved);
+  restrictDatabaseFile(resolved);
+  return db;
+}
+
 export async function createLocalSqliteDatabase(filePath = '.agentsam/data/agentsam.sqlite') {
   const { DatabaseSync } = await loadSqlite();
   const resolved = resolveFile(filePath);
-  fs.mkdirSync(path.dirname(resolved), { recursive: true });
+  prepareDatabaseFile(resolved);
   const database = new DatabaseSync(resolved);
+  restrictDatabaseFile(resolved);
 
   return {
     filePath: resolved,

package/src/mcp/authority.js

@@ -0,0 +1,348 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export const MCP_AUTHORITY_SCHEMA = 'agentsam.mcp.authority.v1';
+export const SERVER_CATALOG_CACHE_SCHEMA = 'agentsam.mcp.server-catalog.v1';
+export const DEFAULT_SERVER_CATALOG_URL = 'https://mcp.inneranimalmedia.com/api/mcp/servers';
+
+/**
+ * Seed MCP server catalog snapshot derived directly from D1 table:
+ * `agentsam_mcp_servers`.
+ *
+ * Captures live server authority, authentication requirements, and live health metrics
+ * for offline and instantaneous CLI resolution.
+ */
+export const SEED_MCP_SERVER_CATALOG = Object.freeze([
+  {
+    name: 'inneranimalmedia',
+    display_name: 'InnerAnimalMedia Main MCP',
+    url: 'https://mcp.inneranimalmedia.com/mcp',
+    authUrl: 'https://mcp.inneranimalmedia.com/auth/connect',
+    auth_type: 'bearer',
+    protocol: 'sse',
+    defaultClients: ['cursor', 'claude'],
+    health_status: 'healthy',
+    avg_latency_ms: 443,
+    error_rate: 0,
+    description: 'Inner Animal Media canonical MCP server (~218 tools, D1 telemetry)',
+  },
+  {
+    name: 'agent_sam_bridge',
+    display_name: 'Agent Sam Bridge MCP',
+    url: 'https://mcp.inneranimalmedia.com/mcp',
+    auth_type: 'bearer',
+    protocol: 'sse',
+    defaultClients: ['cursor'],
+    health_status: 'healthy',
+    avg_latency_ms: 432,
+    error_rate: 0,
+    description: 'Agent Sam Bridge MCP',
+  },
+  {
+    name: 'cloudflare-api',
+    display_name: 'Cloudflare API',
+    url: 'https://mcp.cloudflare.com/mcp',
+    auth_type: 'bearer',
+    protocol: 'sse',
+    defaultClients: ['cursor'],
+    health_status: 'degraded',
+    avg_latency_ms: 9,
+    error_rate: 0,
+    description: 'Cloudflare API (Codex registered)',
+  },
+  {
+    name: 'cloudflare-docs',
+    display_name: 'Cloudflare Docs',
+    url: 'https://docs.mcp.cloudflare.com/mcp',
+    auth_type: 'none',
+    protocol: 'sse',
+    defaultClients: ['cursor'],
+    health_status: 'degraded',
+    avg_latency_ms: 10,
+    error_rate: 0,
+    description: 'Cloudflare documentation reference tools',
+  },
+  {
+    name: 'cloudflare-bindings',
+    display_name: 'Cloudflare Bindings',
+    url: 'https://bindings.mcp.cloudflare.com/mcp',
+    auth_type: 'user_oauth_cloudflare',
+    protocol: 'sse',
+    defaultClients: ['cursor'],
+    health_status: 'degraded',
+    avg_latency_ms: 8,
+    error_rate: 0,
+    description: 'Cloudflare Workers storage, AI, and compute bindings',
+  },
+  {
+    name: 'cloudflare-builds',
+    display_name: 'Cloudflare Builds',
+    url: 'https://builds.mcp.cloudflare.com/mcp',
+    auth_type: 'bearer',
+    protocol: 'sse',
+    defaultClients: ['cursor'],
+    health_status: 'degraded',
+    avg_latency_ms: 6,
+    error_rate: 0,
+    description: 'Cloudflare Workers Builds and CI/CD operations',
+  },
+  {
+    name: 'cloudflare-observability',
+    display_name: 'Cloudflare Observability',
+    url: 'https://observability.mcp.cloudflare.com/mcp',
+    auth_type: 'bearer',
+    protocol: 'sse',
+    defaultClients: ['cursor'],
+    health_status: 'degraded',
+    avg_latency_ms: 10,
+    error_rate: 0,
+    description: 'Cloudflare logs and analytics tools',
+  },
+  {
+    name: 'github-official',
+    display_name: 'GitHub (official)',
+    url: 'https://api.githubcopilot.com/mcp/',
+    auth_type: 'user_oauth_github',
+    protocol: 'sse',
+    defaultClients: ['cursor'],
+    health_status: 'degraded',
+    avg_latency_ms: 338,
+    error_rate: 0,
+    description: 'Official GitHub Copilot MCP server',
+  },
+  {
+    name: 'gmail-official',
+    display_name: 'Gmail (official Google MCP)',
+    url: 'https://gmailmcp.googleapis.com/mcp/v1',
+    auth_type: 'user_oauth_gmail',
+    protocol: 'sse',
+    defaultClients: ['cursor'],
+    health_status: 'degraded',
+    avg_latency_ms: 662,
+    error_rate: 0,
+    description: 'Official Google Gmail MCP server',
+  },
+  {
+    name: 'cf_builds',
+    display_name: 'Cloudflare Builds System',
+    url: 'internal',
+    auth_type: 'bearer',
+    protocol: 'sse',
+    defaultClients: ['cursor'],
+    health_status: 'unknown',
+    avg_latency_ms: null,
+    error_rate: 0,
+    description: 'Cloudflare internal builds system',
+  },
+]);
+
+/**
+ * Backward compatibility dictionary mapping server_key/name to preset definition.
+ */
+export const MCP_PRESETS = Object.freeze(
+  Object.fromEntries(SEED_MCP_SERVER_CATALOG.map((s) => [s.name, s])),
+);
+
+function clean(value) {
+  return value == null ? '' : String(value).trim();
+}
+
+export function homeDirectory(options = {}) {
+  return path.resolve(clean(options.home) || clean(options.env?.HOME) || clean(options.env?.USERPROFILE) || os.homedir());
+}
+
+export function getMcpDir(options = {}) {
+  return path.join(homeDirectory(options), '.agentsam', 'mcp');
+}
+
+export function getServerCatalogCachePath(options = {}) {
+  return path.join(getMcpDir(options), 'server-catalog-cache.json');
+}
+
+export function loadCachedServerCatalog(options = {}) {
+  try {
+    const cacheFile = getServerCatalogCachePath(options);
+    if (!fs.existsSync(cacheFile)) return null;
+    const raw = fs.readFileSync(cacheFile, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed && Array.isArray(parsed.servers)) {
+      return {
+        schema_version: parsed.schema_version,
+        fetched_at: parsed.fetched_at || null,
+        servers: parsed.servers.filter((s) => Number(s.is_active ?? 1) !== 0),
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function writeCachedServerCatalog(servers = [], options = {}) {
+  const cacheFile = getServerCatalogCachePath(options);
+  fs.mkdirSync(path.dirname(cacheFile), { recursive: true });
+  const payload = {
+    schema_version: SERVER_CATALOG_CACHE_SCHEMA,
+    fetched_at: new Date().toISOString(),
+    servers: Array.isArray(servers) ? servers : [],
+  };
+  fs.writeFileSync(cacheFile, JSON.stringify(payload, null, 2) + '\n', 'utf8');
+  return payload;
+}
+
+export async function fetchMcpServerCatalog(options = {}) {
+  const url = options.catalogUrl || DEFAULT_SERVER_CATALOG_URL;
+  const timeoutMs = options.timeoutMs || 5000;
+
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const res = await fetch(url, {
+      signal: controller.signal,
+      headers: { Accept: 'application/json' },
+    });
+    clearTimeout(timer);
+
+    if (res.ok) {
+      const body = await res.json();
+      if (body?.ok && Array.isArray(body.servers)) {
+        writeCachedServerCatalog(body.servers, options);
+        return body.servers.filter((s) => Number(s.is_active ?? 1) !== 0);
+      }
+    }
+  } catch {
+    // Network failure / timeout — fall through to cache
+  }
+
+  const cached = loadCachedServerCatalog(options);
+  if (cached?.servers?.length) {
+    return cached.servers;
+  }
+
+  return SEED_MCP_SERVER_CATALOG;
+}
+
+export function listKnownServers(options = {}) {
+  const cached = loadCachedServerCatalog(options);
+  if (cached?.servers?.length) {
+    return cached.servers;
+  }
+  return SEED_MCP_SERVER_CATALOG;
+}
+
+export function resolveServerPreset(name, options = {}) {
+  const cleanName = clean(name).toLowerCase();
+  if (!cleanName) return null;
+
+  const catalog = listKnownServers(options);
+  const found = catalog.find((s) => (s.name || s.server_key || '').toLowerCase() === cleanName);
+  if (found) {
+    return {
+      name: found.name || found.server_key,
+      display_name: found.display_name || found.name || found.server_key,
+      url: found.url,
+      authUrl: found.authUrl || (found.name === 'inneranimalmedia' ? 'https://mcp.inneranimalmedia.com/auth/connect' : null),
+      auth_type: found.auth_type || 'bearer',
+      protocol: found.protocol || 'sse',
+      defaultClients: found.defaultClients || ['cursor'],
+      health_status: found.health_status || 'unknown',
+      avg_latency_ms: found.avg_latency_ms ?? null,
+      error_rate: found.error_rate ?? 0,
+      description: found.description || found.display_name || '',
+    };
+  }
+
+  return MCP_PRESETS[cleanName] || null;
+}
+
+export function getMcpServerConfigPath(name, options = {}) {
+  const safeName = clean(name).toLowerCase().replace(/[^a-z0-9_-]/g, '-');
+  if (!safeName) throw new Error('mcp_server_name_required');
+  return path.join(getMcpDir(options), `${safeName}.json`);
+}
+
+function ensureSecureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  if (process.platform !== 'win32') {
+    try {
+      fs.chmodSync(dir, 0o700);
+    } catch {
+      // Best-effort permissions
+    }
+  }
+}
+
+export function readMcpServer(name, options = {}) {
+  try {
+    const filePath = getMcpServerConfigPath(name, options);
+    if (!fs.existsSync(filePath)) return null;
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === 'object') {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function writeMcpServer(name, serverConfig, options = {}) {
+  const dir = getMcpDir(options);
+  ensureSecureDir(dir);
+
+  const filePath = getMcpServerConfigPath(name, options);
+  const now = new Date().toISOString();
+  const existing = readMcpServer(name, options);
+
+  const record = {
+    schema_version: MCP_AUTHORITY_SCHEMA,
+    name: clean(name).toLowerCase(),
+    url: clean(serverConfig.url),
+    protocol: clean(serverConfig.protocol) || 'sse',
+    auth: serverConfig.auth || null,
+    clients: Array.isArray(serverConfig.clients) ? [...new Set(serverConfig.clients.map(clean).filter(Boolean))] : ['cursor'],
+    metadata: serverConfig.metadata || {},
+    created_at: existing?.created_at || now,
+    updated_at: now,
+  };
+
+  fs.writeFileSync(filePath, JSON.stringify(record, null, 2), {
+    mode: 0o600,
+  });
+
+  return record;
+}
+
+export function listMcpServers(options = {}) {
+  const dir = getMcpDir(options);
+  if (!fs.existsSync(dir)) return [];
+
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith('.json') && !f.endsWith('-cache.json'));
+  const servers = [];
+  for (const file of files) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'));
+      if (parsed && parsed.name && parsed.schema_version === MCP_AUTHORITY_SCHEMA) {
+        servers.push(parsed);
+      }
+    } catch {
+      // Ignore corrupt entries
+    }
+  }
+  return servers.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function deleteMcpServer(name, options = {}) {
+  try {
+    const filePath = getMcpServerConfigPath(name, options);
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}