@otskit/mcp 0.6.4 → 0.7.0

package/README.md

@@ -8,16 +8,16 @@
 [![npm version](https://img.shields.io/npm/v/@otskit/mcp.svg)](https://www.npmjs.com/package/@otskit/mcp)
 [![npm downloads](https://img.shields.io/npm/dt/@otskit/mcp.svg)](https://www.npmjs.com/package/@otskit/mcp)
 [![TypeScript](https://img.shields.io/badge/TypeScript-6-blue.svg)](https://www.typescriptlang.org/)
-[![Node ≥20](https://img.shields.io/badge/node-%3E%3D20-brightgreen)](https://nodejs.org)
+[![Node >=20](https://img.shields.io/badge/node-%3E%3D20-brightgreen)](https://nodejs.org)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![Glama](https://glama.ai/mcp/servers/OTSkit/OTSkit-MCP/badges/score.svg)](https://glama.ai/mcp/servers/OTSkit/OTSkit-MCP)
 [![OTSkit-MCP MCP server](https://glama.ai/mcp/servers/OTSkit/OTSkit-MCP/badges/card.svg)](https://glama.ai/mcp/servers/OTSkit/OTSkit-MCP)
 
-OpenTimestamps MCP server — stamp, upgrade, and verify Bitcoin timestamps via AI agents.
+OpenTimestamps MCP server - stamp, upgrade, and verify Bitcoin timestamps via AI agents.
 
-Exposes a set of tools to any MCP-compatible agent so it can timestamp documents, monitor confirmation status, and verify proofs against the Bitcoin blockchain — all from a conversation.
+Exposes a set of tools to any MCP-compatible agent so it can timestamp documents, monitor confirmation status, and verify proofs against the Bitcoin blockchain - all from a conversation.
 
-> **Note on confirmation times:** After stamping, a proof is `pending` until Bitcoin confirms it. This typically takes **10–60 minutes** but can take **several hours** during network congestion. Use `ots-mcp watch` or `upgrade_timestamp` to monitor. A pending status is not an error.
+> **Note on confirmation times:** After stamping, a proof is `pending` until Bitcoin confirms it. This typically takes **~60 minutes** but can take **several hours** during network congestion. Use `ots-mcp watch` or `upgrade_timestamp` to monitor. A pending status is not an error.
 
 ## Install
 
@@ -44,7 +44,7 @@ Each command writes the MCP entry into the agent's config file, makes a `.bak` b
 | `ots-mcp upgrade <id>` | Check if a pending stamp has been confirmed |
 | `ots-mcp verify <id>` | Verify a stamp against Bitcoin |
 | `ots-mcp list [status]` | List stamps (`pending` / `confirmed` / `failed`) |
-| `ots-mcp watch [minutes]` | Poll pending stamps in real-time (default: 5 min) |
+| `ots-mcp watch [minutes]` | Monitor pending stamps and attempt due upgrades (default: 30 min, minimum: 15 min) |
 | `ots-mcp check-pending` | Run one upgrade pass over all pending stamps |
 | `ots-mcp scheduler install\|remove\|status` | Manage OS-level scheduler for auto-upgrades |
 | `ots-mcp backup [dest]` | Backup the SQLite database |
@@ -56,10 +56,10 @@ Each command writes the MCP entry into the agent's config file, makes a `.bak` b
 |---|---|
 | `create_timestamp` | Stamp a SHA-256 hash against 4 public OTS calendars |
 | `upgrade_timestamp` | Check if a pending stamp has been confirmed in Bitcoin |
-| `verify_timestamp` | Verify a stamp — proves hash existed before a given Bitcoin block |
+| `verify_timestamp` | Verify a stamp - proves hash existed before a given Bitcoin block |
 | `inspect_timestamp` | Inspect a stored proof file without network calls |
 | `list_pending` | List stamps with status, retry count, and filters |
-| `watch` | Open a terminal window monitoring pending stamps in real-time |
+| `watch` | Open a terminal window monitoring pending stamps and attempting due upgrades |
 | `hash_file` | Compute the SHA-256 of a local file and return it as a 64-char hex string (no network calls) |
 | `stamp_file` | Compute SHA-256 of a local file and stamp it on Bitcoin in one step |
 
@@ -67,7 +67,7 @@ Each command writes the MCP entry into the agent's config file, makes a `.bak` b
 
 All data is stored in `~/.ots-mcp/`:
 
-```
+```text
 ~/.ots-mcp/
   ots-mcp.db       # SQLite database (stamps, proof files)
   config.json      # Optional config overrides
@@ -104,7 +104,7 @@ npm test         # run tests
 
 ## Dependencies
 
-- [`@otskit/core`](https://github.com/AlexAlves87/otskit-core) — OpenTimestamps core logic
-- [`@otskit/client`](https://github.com/AlexAlves87/otskit-client) — OTS calendar client
-- [`@modelcontextprotocol/sdk`](https://github.com/modelcontextprotocol/typescript-sdk) — MCP SDK
-- `node-sqlite3-wasm` — local database (pure WASM, no native compilation)
+- [`@otskit/core`](https://github.com/AlexAlves87/otskit-core) - OpenTimestamps core logic
+- [`@otskit/client`](https://github.com/AlexAlves87/otskit-client) - OTS calendar client
+- [`@modelcontextprotocol/sdk`](https://github.com/modelcontextprotocol/typescript-sdk) - MCP SDK
+- `node-sqlite3-wasm` - local database (pure WASM, no native compilation)

package/dist/chunk-KSFL3INC.js

@@ -0,0 +1,79 @@
+import {
+  getDb,
+  loadConfig,
+  upgradeTimestamp
+} from "./chunk-ZQUFY5MM.js";
+
+// src/tools/watch.ts
+var DEFAULT_WATCH_INTERVAL_MINUTES = 30;
+var MIN_WATCH_INTERVAL_MINUTES = 15;
+var MAX_UPGRADES_PER_TICK = 20;
+function normalizeWatchInterval(intervalMinutes = DEFAULT_WATCH_INTERVAL_MINUTES) {
+  if (!Number.isFinite(intervalMinutes)) return DEFAULT_WATCH_INTERVAL_MINUTES;
+  return Math.max(MIN_WATCH_INTERVAL_MINUTES, Math.floor(intervalMinutes));
+}
+async function watchPending(intervalMinutes = DEFAULT_WATCH_INTERVAL_MINUTES) {
+  const config = loadConfig();
+  const db = getDb();
+  const minutes = normalizeWatchInterval(intervalMinutes);
+  process.stdout.write(`Watching pending stamps and upgrading due proofs every ${minutes} min. Ctrl+C to stop.
+
+`);
+  async function tick() {
+    const dueRows = db.all(
+      `SELECT id FROM stamps
+       WHERE status = 'pending'
+         AND (next_retry_at IS NULL OR next_retry_at <= ?)
+       ORDER BY created_at ASC
+       LIMIT ?`,
+      [(/* @__PURE__ */ new Date()).toISOString(), MAX_UPGRADES_PER_TICK]
+    );
+    if (dueRows.length > 0) {
+      process.stdout.write(`${now()} - upgrading ${dueRows.length} due stamp(s)
+`);
+    }
+    for (const row of dueRows) {
+      const result = await upgradeTimestamp({ id: row.id }, db, config);
+      const status = "status" in result ? result.status : `error:${result.error}`;
+      process.stdout.write(`  upgrade ${row.id.slice(0, 8)} -> ${status}
+`);
+    }
+    const rows = db.all(
+      `SELECT id, hash, status, attempt_count, bitcoin_block, confirmed_at, next_retry_at
+       FROM stamps
+       WHERE status != 'confirmed'
+       ORDER BY created_at DESC`
+    );
+    const confirmed = db.get(`SELECT COUNT(*) as n FROM stamps WHERE status = 'confirmed'`);
+    process.stdout.write(`${now()} - ${rows.length} pending, ${confirmed.n} confirmed
+`);
+    for (const row of rows) {
+      const next = row.next_retry_at ? ` next ${row.next_retry_at.replace("T", " ").slice(0, 19)}` : "";
+      process.stdout.write(`  ${row.id.slice(0, 8)}  ${row.status}  (${row.attempt_count} attempts)${next}
+`);
+    }
+    if (rows.length === 0) {
+      process.stdout.write(`  (no pending stamps)
+`);
+    }
+    process.stdout.write("\n");
+  }
+  function now() {
+    return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+  }
+  async function loop() {
+    try {
+      await tick();
+    } catch (e) {
+      process.stderr.write(`watch error: ${String(e)}
+`);
+    }
+    setTimeout(loop, minutes * 60 * 1e3);
+  }
+  await loop();
+}
+
+export {
+  normalizeWatchInterval,
+  watchPending
+};

package/dist/chunk-V4ONBNWS.js

@@ -0,0 +1,120 @@
+import {
+  getDataDir,
+  getStamp,
+  insertStamp,
+  listStamps,
+  logOperation
+} from "./chunk-ZQUFY5MM.js";
+import {
+  writeAtomic
+} from "./chunk-YFSUDT24.js";
+
+// src/tools/create-timestamp.ts
+import { mkdirSync } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { OpenTimestampsClient } from "@otskit/client";
+var HEX64 = /^[0-9a-f]{64}$/i;
+async function createTimestamp(input, db, config) {
+  if (!HEX64.test(input.hash)) {
+    return { error: "invalid_hash", details: "hash must be 64 hex characters (SHA-256)" };
+  }
+  const normalizedHash = input.hash.toLowerCase();
+  const client = new OpenTimestampsClient({
+    calendars: config.calendars,
+    resilience: { timeout: config.calendar_timeout_ms }
+  });
+  const t0 = Date.now();
+  let proofBuffer;
+  try {
+    proofBuffer = await client.stamp(normalizedHash);
+  } catch (e) {
+    return { error: "calendar_error", details: String(e) };
+  }
+  const responseTimeMs = Date.now() - t0;
+  const id = randomUUID();
+  const proofDir = join(getDataDir(), "proofs");
+  mkdirSync(proofDir, { recursive: true });
+  const proofPath = join(proofDir, `${id}.ots`);
+  try {
+    writeAtomic(proofPath, proofBuffer);
+  } catch (e) {
+    return { error: "storage_error", details: String(e) };
+  }
+  const record = insertStamp(db, { id, hash: normalizedHash, proof_path: proofPath });
+  logOperation(db, { stamp_id: id, action: "stamp", result: "success", response_time_ms: responseTimeMs });
+  return {
+    id: record.id,
+    hash: record.hash,
+    status: "pending",
+    calendars: config.calendars,
+    created_at: record.created_at,
+    proof_path: proofPath
+  };
+}
+
+// src/tools/verify-timestamp.ts
+import { readFileSync } from "fs";
+import { OpenTimestampsClient as OpenTimestampsClient2 } from "@otskit/client";
+async function verifyTimestamp(input, db, config) {
+  const record = getStamp(db, input.id);
+  if (!record) return { error: "not_found", details: `No stamp with id ${input.id}` };
+  if (!record.proof_path) return { error: "storage_error", details: "No proof_path on record" };
+  let proofBytes;
+  try {
+    proofBytes = readFileSync(record.proof_path);
+  } catch (e) {
+    return { error: "storage_error", details: String(e) };
+  }
+  const client = new OpenTimestampsClient2({
+    calendars: config.calendars,
+    resilience: { timeout: config.calendar_timeout_ms }
+  });
+  let result;
+  try {
+    result = await client.verify(proofBytes, record.hash);
+  } catch (e) {
+    logOperation(db, { stamp_id: input.id, action: "verify", result: "failed", error_msg: String(e) });
+    return { status: "network_error", hash: record.hash, details: String(e) };
+  }
+  if (!result.valid) {
+    if (result.error?.includes("No Bitcoin attestation")) {
+      logOperation(db, { stamp_id: input.id, action: "verify", result: "pending" });
+      return { status: "pending", hash: record.hash, calendars: config.calendars };
+    }
+    if (result.error?.toLowerCase().includes("invalid") || result.error?.toLowerCase().includes("corrupt")) {
+      logOperation(db, { stamp_id: input.id, action: "verify", result: "failed", error_msg: result.error });
+      return { status: "invalid", hash: record.hash, reason: result.error ?? "unknown" };
+    }
+    logOperation(db, { stamp_id: input.id, action: "verify", result: "failed", error_msg: result.error });
+    return { status: "unknown", hash: record.hash };
+  }
+  logOperation(db, { stamp_id: input.id, action: "verify", result: "success" });
+  return {
+    status: "confirmed",
+    hash: record.hash,
+    bitcoin_block: result.blockHeight,
+    bitcoin_time: new Date(result.timestamp * 1e3).toISOString()
+  };
+}
+
+// src/tools/list-pending.ts
+function toPublic({ attempt_count: _, last_attempt_at: __, next_retry_at: ___, ...rest }) {
+  return rest;
+}
+function listPending(input, db, _config) {
+  const result = listStamps(db, {
+    status: input.status ?? "pending",
+    limit: Math.min(input.limit ?? 50, 200),
+    offset: input.offset ?? 0,
+    older_than_hours: input.older_than_hours,
+    due_now: input.due_now
+  });
+  return { items: result.items.map(toPublic), total: result.total };
+}
+
+export {
+  createTimestamp,
+  verifyTimestamp,
+  listPending
+};

package/dist/{chunk-4WQTV6CC.js → chunk-ZQUFY5MM.js}

@@ -1,15 +1,138 @@
-import {
-  getDataDir
-} from "./chunk-Y3F7WBP6.js";
 import {
   writeAtomic
 } from "./chunk-YFSUDT24.js";
 
-// src/tools/create-timestamp.ts
-import { mkdirSync } from "fs";
+// src/config.ts
+import { readFileSync, existsSync, mkdirSync } from "fs";
 import { join } from "path";
-import { randomUUID } from "crypto";
-import { OpenTimestampsClient } from "@otskit/client";
+import { homedir } from "os";
+function getDataDir() {
+  return process.env.OTS_MCP_DATA_DIR ?? join(homedir(), ".ots-mcp");
+}
+var DEFAULTS = {
+  stamp_enabled: true,
+  preserve_enabled: true,
+  preserve_whitelist: [],
+  preserve_max_bytes: 104857600,
+  preserve_max_files: 1e4,
+  scheduler_interval_minutes: 30,
+  calendar_timeout_ms: 1e4,
+  calendar_max_response_bytes: 1048576,
+  retry_max_attempts: 20,
+  log_file: join(getDataDir(), "ots-mcp.log"),
+  calendars: [
+    "https://alice.btc.calendar.opentimestamps.org",
+    "https://bob.btc.calendar.opentimestamps.org",
+    "https://finney.calendar.eternitywall.com",
+    "https://btc.calendar.catallaxy.com"
+  ],
+  esplora_url: "https://blockstream.info/api"
+};
+function loadConfig() {
+  const dir = getDataDir();
+  mkdirSync(dir, { recursive: true });
+  const configPath = join(dir, "config.json");
+  if (!existsSync(configPath)) return { ...DEFAULTS };
+  const raw = JSON.parse(readFileSync(configPath, "utf8"));
+  return { ...DEFAULTS, ...raw };
+}
+
+// src/db/index.ts
+import { createRequire } from "module";
+import { join as join2 } from "path";
+import { mkdirSync as mkdirSync2, statSync } from "fs";
+
+// src/db/schema.ts
+function initDb(db) {
+  db.exec("PRAGMA busy_timeout = 5000");
+  db.exec("PRAGMA foreign_keys = ON");
+  runMigrations(db);
+}
+function runMigrations(db) {
+  const row = db.get("PRAGMA user_version");
+  if (row.user_version < 1) migrateTo1(db);
+}
+function migrateTo1(db) {
+  db.exec("BEGIN");
+  try {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS stamps (
+        id              TEXT PRIMARY KEY,
+        hash            TEXT NOT NULL,
+        status          TEXT NOT NULL,
+        created_at      TEXT NOT NULL,
+        confirmed_at    TEXT,
+        bitcoin_block   INTEGER,
+        bitcoin_time    TEXT,
+        proof_path      TEXT,
+        archive_path    TEXT,
+        last_attempt_at TEXT,
+        attempt_count   INTEGER NOT NULL DEFAULT 0,
+        last_error      TEXT,
+        next_retry_at   TEXT,
+        metadata        TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_stamps_hash   ON stamps(hash);
+      CREATE INDEX IF NOT EXISTS idx_stamps_status ON stamps(status);
+
+      CREATE TABLE IF NOT EXISTS operations_log (
+        id               INTEGER PRIMARY KEY AUTOINCREMENT,
+        stamp_id         TEXT NOT NULL REFERENCES stamps(id),
+        action           TEXT NOT NULL,
+        result           TEXT NOT NULL,
+        error_msg        TEXT,
+        calendar_uri     TEXT,
+        response_time_ms INTEGER,
+        created_at       TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_oplog_stamp_id ON operations_log(stamp_id);
+      CREATE INDEX IF NOT EXISTS idx_oplog_created  ON operations_log(created_at);
+    `);
+    db.exec("PRAGMA user_version = 1");
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
+}
+
+// src/db/index.ts
+var _db = null;
+function getDb() {
+  if (_db) return _db;
+  const _require = createRequire(import.meta.url);
+  const { Database } = _require("node-sqlite3-wasm");
+  const dir = getDataDir();
+  mkdirSync2(dir, { recursive: true });
+  _db = new Database(join2(dir, "db.sqlite"));
+  initDb(_db);
+  reconcileOrphans(_db);
+  return _db;
+}
+function backupDb(destPath) {
+  const escaped = destPath.replace(/'/g, "''");
+  getDb().exec(`VACUUM INTO '${escaped}'`);
+}
+function reconcileOrphans(db) {
+  const pending = db.all(
+    `SELECT id, proof_path FROM stamps WHERE status = 'pending' AND proof_path IS NOT NULL`
+  );
+  for (const row of pending) {
+    try {
+      statSync(row.proof_path);
+    } catch {
+      db.run(
+        `UPDATE stamps SET status = 'failed', last_error = ? WHERE id = ?`,
+        ["proof file missing on disk", row.id]
+      );
+    }
+  }
+}
+
+// src/tools/upgrade-timestamp.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { OpenTimestampsClient, UpgradeError } from "@otskit/client";
+import { DetachedTimestampFile, StreamDeserializationContext } from "@otskit/core";
 
 // src/db/stamps.ts
 function insertStamp(db, params) {
@@ -86,50 +209,7 @@ function logOperation(db, params) {
   );
 }
 
-// src/tools/create-timestamp.ts
-var HEX64 = /^[0-9a-f]{64}$/i;
-async function createTimestamp(input, db, config) {
-  if (!HEX64.test(input.hash)) {
-    return { error: "invalid_hash", details: "hash must be 64 hex characters (SHA-256)" };
-  }
-  const normalizedHash = input.hash.toLowerCase();
-  const client = new OpenTimestampsClient({
-    calendars: config.calendars,
-    resilience: { timeout: config.calendar_timeout_ms }
-  });
-  const t0 = Date.now();
-  let proofBuffer;
-  try {
-    proofBuffer = await client.stamp(normalizedHash);
-  } catch (e) {
-    return { error: "calendar_error", details: String(e) };
-  }
-  const responseTimeMs = Date.now() - t0;
-  const id = randomUUID();
-  const proofDir = join(getDataDir(), "proofs");
-  mkdirSync(proofDir, { recursive: true });
-  const proofPath = join(proofDir, `${id}.ots`);
-  try {
-    writeAtomic(proofPath, proofBuffer);
-  } catch (e) {
-    return { error: "storage_error", details: String(e) };
-  }
-  const record = insertStamp(db, { id, hash: normalizedHash, proof_path: proofPath });
-  logOperation(db, { stamp_id: id, action: "stamp", result: "success", response_time_ms: responseTimeMs });
-  return {
-    id: record.id,
-    hash: record.hash,
-    status: "pending",
-    calendars: config.calendars,
-    created_at: record.created_at,
-    proof_path: proofPath
-  };
-}
-
 // src/tools/upgrade-timestamp.ts
-import { readFileSync } from "fs";
-import { OpenTimestampsClient as OpenTimestampsClient2, UpgradeError } from "@otskit/client";
-import { DetachedTimestampFile, StreamDeserializationContext } from "@otskit/core";
 function collectAttestations(ts) {
   const atts = [...ts.attestations];
   for (const branch of ts.branches) {
@@ -159,8 +239,8 @@ async function upgradeTimestamp(input, db, config) {
   const record = getStamp(db, input.id);
   if (!record) return { error: "not_found", details: `No stamp with id ${input.id}` };
   if (!record.proof_path) return { error: "storage_error", details: "No proof_path on record" };
-  const proofBefore = readFileSync(record.proof_path);
-  const client = new OpenTimestampsClient2({
+  const proofBefore = readFileSync2(record.proof_path);
+  const client = new OpenTimestampsClient({
     calendars: config.calendars,
     resilience: { timeout: config.calendar_timeout_ms }
   });
@@ -200,70 +280,14 @@ async function upgradeTimestamp(input, db, config) {
   return { id: input.id, status: "pending", attempt_count: newAttemptCount, last_attempt_at: now, next_retry_at: next };
 }
 
-// src/tools/verify-timestamp.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { OpenTimestampsClient as OpenTimestampsClient3 } from "@otskit/client";
-async function verifyTimestamp(input, db, config) {
-  const record = getStamp(db, input.id);
-  if (!record) return { error: "not_found", details: `No stamp with id ${input.id}` };
-  if (!record.proof_path) return { error: "storage_error", details: "No proof_path on record" };
-  let proofBytes;
-  try {
-    proofBytes = readFileSync2(record.proof_path);
-  } catch (e) {
-    return { error: "storage_error", details: String(e) };
-  }
-  const client = new OpenTimestampsClient3({
-    calendars: config.calendars,
-    resilience: { timeout: config.calendar_timeout_ms }
-  });
-  let result;
-  try {
-    result = await client.verify(proofBytes, record.hash);
-  } catch (e) {
-    logOperation(db, { stamp_id: input.id, action: "verify", result: "failed", error_msg: String(e) });
-    return { status: "network_error", hash: record.hash, details: String(e) };
-  }
-  if (!result.valid) {
-    if (result.error?.includes("No Bitcoin attestation")) {
-      logOperation(db, { stamp_id: input.id, action: "verify", result: "pending" });
-      return { status: "pending", hash: record.hash, calendars: config.calendars };
-    }
-    if (result.error?.toLowerCase().includes("invalid") || result.error?.toLowerCase().includes("corrupt")) {
-      logOperation(db, { stamp_id: input.id, action: "verify", result: "failed", error_msg: result.error });
-      return { status: "invalid", hash: record.hash, reason: result.error ?? "unknown" };
-    }
-    logOperation(db, { stamp_id: input.id, action: "verify", result: "failed", error_msg: result.error });
-    return { status: "unknown", hash: record.hash };
-  }
-  logOperation(db, { stamp_id: input.id, action: "verify", result: "success" });
-  return {
-    status: "confirmed",
-    hash: record.hash,
-    bitcoin_block: result.blockHeight,
-    bitcoin_time: new Date(result.timestamp * 1e3).toISOString()
-  };
-}
-
-// src/tools/list-pending.ts
-function toPublic({ attempt_count: _, last_attempt_at: __, next_retry_at: ___, ...rest }) {
-  return rest;
-}
-function listPending(input, db, _config) {
-  const result = listStamps(db, {
-    status: input.status ?? "pending",
-    limit: Math.min(input.limit ?? 50, 200),
-    offset: input.offset ?? 0,
-    older_than_hours: input.older_than_hours,
-    due_now: input.due_now
-  });
-  return { items: result.items.map(toPublic), total: result.total };
-}
-
 export {
+  getDataDir,
+  loadConfig,
+  getDb,
+  backupDb,
+  insertStamp,
   getStamp,
-  createTimestamp,
-  upgradeTimestamp,
-  verifyTimestamp,
-  listPending
+  listStamps,
+  logOperation,
+  upgradeTimestamp
 };

package/dist/{cli-2KSRIDHM.js → cli-MR24FO2T.js}

@@ -1,14 +1,14 @@
 import {
   createTimestamp,
   listPending,
-  upgradeTimestamp,
   verifyTimestamp
-} from "./chunk-4WQTV6CC.js";
+} from "./chunk-V4ONBNWS.js";
 import {
   backupDb,
   getDb,
-  loadConfig
-} from "./chunk-Y3F7WBP6.js";
+  loadConfig,
+  upgradeTimestamp
+} from "./chunk-ZQUFY5MM.js";
 import "./chunk-YFSUDT24.js";
 
 // src/cli.ts

package/dist/index.js

@@ -7,7 +7,7 @@ if (!command || command === "--help" || command === "help") {
 Commands:
   serve              Start MCP server (stdio transport)
   setup <target>     Configure MCP for an agent (claude | claude-code | codex)
-  watch [interval]   Watch pending stamps in real-time (default: 5 min)
+  watch [interval]   Watch and upgrade due pending stamps (default: 30 min, minimum: 15 min)
   stamp <hash>       Stamp a SHA-256 hash
   upgrade <id>       Upgrade a pending stamp
   verify <id>        Verify a stamp
@@ -20,7 +20,7 @@ Commands:
 }
 switch (command) {
   case "serve": {
-    const { runServer } = await import("./server-P3TIJGLB.js");
+    const { runServer } = await import("./server-6HE6K337.js");
     await runServer();
     break;
   }
@@ -49,11 +49,11 @@ switch (command) {
     break;
   }
   case "watch": {
-    const { watchPending } = await import("./watch-MF5SD2H6.js");
+    const { normalizeWatchInterval, watchPending } = await import("./watch-JQ6XJCXF.js");
     const parsed = args[0] ? parseInt(args[0], 10) : NaN;
-    const interval = isNaN(parsed) || parsed < 1 ? 5 : parsed;
-    if (args[0] && (isNaN(parsed) || parsed < 1))
-      process.stderr.write(`Argumento inv\xE1lido "${args[0]}", usando intervalo por defecto: 5 min
+    const interval = normalizeWatchInterval(isNaN(parsed) ? void 0 : parsed);
+    if (args[0] && (isNaN(parsed) || parsed < 15))
+      process.stderr.write(`Invalid interval "${args[0]}", using ${interval} min
 `);
     await watchPending(interval);
     break;
@@ -65,7 +65,7 @@ switch (command) {
   case "check-pending":
   case "backup":
   case "scheduler": {
-    const { runCli } = await import("./cli-2KSRIDHM.js");
+    const { runCli } = await import("./cli-MR24FO2T.js");
     await runCli(command, args);
     break;
   }

package/dist/{server-P3TIJGLB.js → server-6HE6K337.js}

@@ -1,14 +1,17 @@
 import {
   createTimestamp,
-  getStamp,
   listPending,
-  upgradeTimestamp,
   verifyTimestamp
-} from "./chunk-4WQTV6CC.js";
+} from "./chunk-V4ONBNWS.js";
+import {
+  normalizeWatchInterval
+} from "./chunk-KSFL3INC.js";
 import {
   getDb,
-  loadConfig
-} from "./chunk-Y3F7WBP6.js";
+  getStamp,
+  loadConfig,
+  upgradeTimestamp
+} from "./chunk-ZQUFY5MM.js";
 import "./chunk-YFSUDT24.js";
 
 // src/server.ts
@@ -61,8 +64,8 @@ function inspectTimestamp(input, db, _config) {
 
 // src/tools/watch-window.ts
 import { exec } from "child_process";
-function openWatchWindow(intervalMinutes = 5) {
-  const minutes = Math.max(1, Math.floor(intervalMinutes));
+function openWatchWindow(intervalMinutes) {
+  const minutes = normalizeWatchInterval(intervalMinutes);
   const cmd = `start powershell.exe -NoExit -Command "ots-mcp watch ${minutes}"`;
   let errorMsg;
   exec(cmd, { shell: "cmd" }, (err) => {
@@ -207,18 +210,18 @@ var TOOL_DEFINITIONS = [
   },
   {
     name: "watch",
-    description: "Opens a new terminal window that monitors pending stamps in real-time, polling at the given interval. The window stays open so the user can watch progress.",
+    description: "Opens a new terminal window that monitors pending stamps and attempts due upgrades at a safe interval. The window stays open so the user can watch progress.",
     inputSchema: {
       type: "object",
       properties: {
-        interval_minutes: { type: "number", description: "Polling interval in minutes (default: 5, minimum: 1)" }
+        interval_minutes: { type: "number", description: "Polling interval in minutes (default: 30, minimum: 15)" }
       }
     },
     annotations: {
-      readOnlyHint: true,
+      readOnlyHint: false,
       destructiveHint: false,
       idempotentHint: false,
-      openWorldHint: false
+      openWorldHint: true
     }
   }
 ];

package/dist/watch-JQ6XJCXF.js

@@ -0,0 +1,10 @@
+import {
+  normalizeWatchInterval,
+  watchPending
+} from "./chunk-KSFL3INC.js";
+import "./chunk-ZQUFY5MM.js";
+import "./chunk-YFSUDT24.js";
+export {
+  normalizeWatchInterval,
+  watchPending
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@otskit/mcp",
   "mcpName": "io.github.AlexAlves87/otskit-mcp",
-  "version": "0.6.4",
+  "version": "0.7.0",
   "license": "MIT",
   "description": "OpenTimestamps MCP server — stamp, upgrade, verify via AI agents",
   "repository": {

package/dist/chunk-Y3F7WBP6.js

@@ -1,133 +0,0 @@
-// src/config.ts
-import { readFileSync, existsSync, mkdirSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-function getDataDir() {
-  return process.env.OTS_MCP_DATA_DIR ?? join(homedir(), ".ots-mcp");
-}
-var DEFAULTS = {
-  stamp_enabled: true,
-  preserve_enabled: true,
-  preserve_whitelist: [],
-  preserve_max_bytes: 104857600,
-  preserve_max_files: 1e4,
-  scheduler_interval_minutes: 30,
-  calendar_timeout_ms: 1e4,
-  calendar_max_response_bytes: 1048576,
-  retry_max_attempts: 20,
-  log_file: join(getDataDir(), "ots-mcp.log"),
-  calendars: [
-    "https://alice.btc.calendar.opentimestamps.org",
-    "https://bob.btc.calendar.opentimestamps.org",
-    "https://finney.calendar.eternitywall.com",
-    "https://btc.calendar.catallaxy.com"
-  ],
-  esplora_url: "https://blockstream.info/api"
-};
-function loadConfig() {
-  const dir = getDataDir();
-  mkdirSync(dir, { recursive: true });
-  const configPath = join(dir, "config.json");
-  if (!existsSync(configPath)) return { ...DEFAULTS };
-  const raw = JSON.parse(readFileSync(configPath, "utf8"));
-  return { ...DEFAULTS, ...raw };
-}
-
-// src/db/index.ts
-import { createRequire } from "module";
-import { join as join2 } from "path";
-import { mkdirSync as mkdirSync2, statSync } from "fs";
-
-// src/db/schema.ts
-function initDb(db) {
-  db.exec("PRAGMA busy_timeout = 5000");
-  db.exec("PRAGMA foreign_keys = ON");
-  runMigrations(db);
-}
-function runMigrations(db) {
-  const row = db.get("PRAGMA user_version");
-  if (row.user_version < 1) migrateTo1(db);
-}
-function migrateTo1(db) {
-  db.exec("BEGIN");
-  try {
-    db.exec(`
-      CREATE TABLE IF NOT EXISTS stamps (
-        id              TEXT PRIMARY KEY,
-        hash            TEXT NOT NULL,
-        status          TEXT NOT NULL,
-        created_at      TEXT NOT NULL,
-        confirmed_at    TEXT,
-        bitcoin_block   INTEGER,
-        bitcoin_time    TEXT,
-        proof_path      TEXT,
-        archive_path    TEXT,
-        last_attempt_at TEXT,
-        attempt_count   INTEGER NOT NULL DEFAULT 0,
-        last_error      TEXT,
-        next_retry_at   TEXT,
-        metadata        TEXT
-      );
-      CREATE INDEX IF NOT EXISTS idx_stamps_hash   ON stamps(hash);
-      CREATE INDEX IF NOT EXISTS idx_stamps_status ON stamps(status);
-
-      CREATE TABLE IF NOT EXISTS operations_log (
-        id               INTEGER PRIMARY KEY AUTOINCREMENT,
-        stamp_id         TEXT NOT NULL REFERENCES stamps(id),
-        action           TEXT NOT NULL,
-        result           TEXT NOT NULL,
-        error_msg        TEXT,
-        calendar_uri     TEXT,
-        response_time_ms INTEGER,
-        created_at       TEXT NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS idx_oplog_stamp_id ON operations_log(stamp_id);
-      CREATE INDEX IF NOT EXISTS idx_oplog_created  ON operations_log(created_at);
-    `);
-    db.exec("PRAGMA user_version = 1");
-    db.exec("COMMIT");
-  } catch (e) {
-    db.exec("ROLLBACK");
-    throw e;
-  }
-}
-
-// src/db/index.ts
-var _db = null;
-function getDb() {
-  if (_db) return _db;
-  const _require = createRequire(import.meta.url);
-  const { Database } = _require("node-sqlite3-wasm");
-  const dir = getDataDir();
-  mkdirSync2(dir, { recursive: true });
-  _db = new Database(join2(dir, "db.sqlite"));
-  initDb(_db);
-  reconcileOrphans(_db);
-  return _db;
-}
-function backupDb(destPath) {
-  const escaped = destPath.replace(/'/g, "''");
-  getDb().exec(`VACUUM INTO '${escaped}'`);
-}
-function reconcileOrphans(db) {
-  const pending = db.all(
-    `SELECT id, proof_path FROM stamps WHERE status = 'pending' AND proof_path IS NOT NULL`
-  );
-  for (const row of pending) {
-    try {
-      statSync(row.proof_path);
-    } catch {
-      db.run(
-        `UPDATE stamps SET status = 'failed', last_error = ? WHERE id = ?`,
-        ["proof file missing on disk", row.id]
-      );
-    }
-  }
-}
-
-export {
-  getDataDir,
-  loadConfig,
-  getDb,
-  backupDb
-};

package/dist/watch-MF5SD2H6.js

@@ -1,41 +0,0 @@
-import {
-  getDb,
-  loadConfig
-} from "./chunk-Y3F7WBP6.js";
-
-// src/tools/watch.ts
-async function watchPending(intervalMinutes = 5) {
-  const config = loadConfig();
-  const db = getDb();
-  process.stdout.write(`Watching pending stamps every ${intervalMinutes} min. Ctrl+C to stop.
-
-`);
-  function tick() {
-    const rows = db.all(
-      `SELECT id, hash, status, attempt_count, bitcoin_block, confirmed_at FROM stamps WHERE status != 'confirmed' ORDER BY created_at DESC`
-    );
-    const confirmed = db.get(`SELECT COUNT(*) as n FROM stamps WHERE status = 'confirmed'`);
-    process.stdout.write(`${now()} \u2014 ${rows.length} pendientes, ${confirmed.n} confirmados
-`);
-    for (const row of rows) {
-      process.stdout.write(`  ${row.id.slice(0, 8)}  ${row.status}  (${row.attempt_count} intentos)
-`);
-    }
-    if (rows.length === 0) {
-      process.stdout.write(`  (ning\xFAn sello pendiente)
-`);
-    }
-    process.stdout.write("\n");
-  }
-  function now() {
-    return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
-  }
-  function loop() {
-    tick();
-    setTimeout(loop, Math.max(6e4, intervalMinutes * 60 * 1e3));
-  }
-  loop();
-}
-export {
-  watchPending
-};