@otskit/mcp 0.1.7 → 0.2.1

package/README.md

@@ -1,98 +1,106 @@
-<p align="center">
-  <img src="https://raw.githubusercontent.com/OTSkit/OTSkit-MCP/master/docs/header.png" alt="OTSkit.ts MCP" width="480" />
-</p>
-
-# @otskit/mcp
-
-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.
-
-> **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.
-
-## Install
-
-```bash
-npm install -g @otskit/mcp
-```
-
-## Agent setup
-
-```bash
-ots-mcp setup claude   # Claude Desktop
-ots-mcp setup codex    # Codex CLI
-```
-
-Each command writes the MCP entry into the agent's config file, makes a `.bak` backup if the file already exists, and skips if `ots-mcp` is already configured. Restart the agent afterwards to apply the changes.
-
-## CLI commands
-
-| Command | Description |
-|---|---|
-| `ots-mcp serve` | Start the MCP server (stdio transport) |
-| `ots-mcp stamp <sha256>` | Stamp a SHA-256 hash against Bitcoin calendars |
-| `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 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 |
-| `ots-mcp setup <claude\|codex>` | Configure MCP for an agent |
-
-## MCP tools exposed to agents
-
-| Tool | Description |
-|---|---|
-| `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 |
-| `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 |
-
-## Data directory
-
-All data is stored in `~/.ots-mcp/`:
-
-```
-~/.ots-mcp/
-  ots-mcp.db       # SQLite database (stamps, proof files)
-  config.json      # Optional config overrides
-  ots-mcp.log      # Log file
-```
-
-## Configuration
-
-Create `~/.ots-mcp/config.json` to override defaults:
-
-```json
-{
-  "stamp_enabled": true,
-  "scheduler_interval_minutes": 30,
-  "retry_max_attempts": 20,
-  "calendar_timeout_ms": 10000,
-  "esplora_url": "https://blockstream.info/api",
-  "calendars": [
-    "https://alice.btc.calendar.opentimestamps.org",
-    "https://bob.btc.calendar.opentimestamps.org",
-    "https://finney.calendar.eternitywall.com",
-    "https://btc.calendar.catallaxy.com"
-  ]
-}
-```
-
-## Development
-
-```bash
-npm run build    # production build
-npm run dev      # watch mode
-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
-- `better-sqlite3` — local database
+<p align="center">
+  <img src="https://raw.githubusercontent.com/OTSkit/OTSkit-MCP/master/docs/header.png" alt="OTSkit.ts MCP" width="480" />
+</p>
+
+# @otskit/mcp
+
+[![CI](https://github.com/OTSkit/OTSkit-MCP/actions/workflows/ci.yml/badge.svg)](https://github.com/OTSkit/OTSkit-MCP/actions/workflows/ci.yml)
+[![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/dm/@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)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+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.
+
+> **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.
+
+## Install
+
+```bash
+npm install -g @otskit/mcp
+```
+
+## Agent setup
+
+```bash
+ots-mcp setup claude        # Claude Desktop
+ots-mcp setup claude-code   # Claude Code CLI
+ots-mcp setup codex         # Codex CLI
+```
+
+Each command writes the MCP entry into the agent's config file, makes a `.bak` backup if the file already exists, and skips if `ots-mcp` is already configured. Restart the agent afterwards to apply the changes.
+
+## CLI commands
+
+| Command | Description |
+|---|---|
+| `ots-mcp serve` | Start the MCP server (stdio transport) |
+| `ots-mcp stamp <sha256>` | Stamp a SHA-256 hash against Bitcoin calendars |
+| `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 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 |
+| `ots-mcp setup <claude\|claude-code\|codex>` | Configure MCP for an agent |
+
+## MCP tools exposed to agents
+
+| Tool | Description |
+|---|---|
+| `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 |
+| `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 |
+
+## Data directory
+
+All data is stored in `~/.ots-mcp/`:
+
+```
+~/.ots-mcp/
+  ots-mcp.db       # SQLite database (stamps, proof files)
+  config.json      # Optional config overrides
+  ots-mcp.log      # Log file
+```
+
+## Configuration
+
+Create `~/.ots-mcp/config.json` to override defaults:
+
+```json
+{
+  "stamp_enabled": true,
+  "scheduler_interval_minutes": 30,
+  "retry_max_attempts": 20,
+  "calendar_timeout_ms": 10000,
+  "esplora_url": "https://blockstream.info/api",
+  "calendars": [
+    "https://alice.btc.calendar.opentimestamps.org",
+    "https://bob.btc.calendar.opentimestamps.org",
+    "https://finney.calendar.eternitywall.com",
+    "https://btc.calendar.catallaxy.com"
+  ]
+}
+```
+
+## Development
+
+```bash
+npm run build    # production build
+npm run dev      # watch mode
+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
+- `better-sqlite3` — local database

package/dist/chunk-4ZDPWS7C.js

@@ -0,0 +1,123 @@
+// 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 DatabaseConstructor from "better-sqlite3";
+import { join as join2 } from "path";
+import { mkdirSync as mkdirSync2, statSync } from "fs";
+
+// src/db/schema.ts
+function initDb(db) {
+  db.pragma("journal_mode = WAL");
+  db.pragma("busy_timeout = 5000");
+  db.pragma("foreign_keys = ON");
+  runMigrations(db);
+}
+function runMigrations(db) {
+  const version = db.pragma("user_version", { simple: true });
+  if (version < 1) migrateTo1(db);
+}
+function migrateTo1(db) {
+  db.transaction(() => {
+    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.pragma("user_version = 1");
+  })();
+}
+
+// src/db/index.ts
+var _db = null;
+function getDb() {
+  if (_db) return _db;
+  const dir = getDataDir();
+  mkdirSync2(dir, { recursive: true });
+  _db = new DatabaseConstructor(join2(dir, "db.sqlite"));
+  initDb(_db);
+  reconcileOrphans(_db);
+  return _db;
+}
+function backupDb(destPath) {
+  getDb().backup(destPath);
+}
+function reconcileOrphans(db) {
+  const pending = db.prepare(
+    `SELECT id, proof_path FROM stamps WHERE status = 'pending' AND proof_path IS NOT NULL`
+  ).all();
+  for (const row of pending) {
+    try {
+      statSync(row.proof_path);
+    } catch {
+      db.prepare(`UPDATE stamps SET status = 'failed', last_error = ? WHERE id = ?`).run("proof file missing on disk", row.id);
+    }
+  }
+}
+
+export {
+  getDataDir,
+  loadConfig,
+  getDb,
+  backupDb
+};

package/dist/chunk-OMNHFTJW.js

@@ -0,0 +1,265 @@
+import {
+  getDataDir
+} from "./chunk-4ZDPWS7C.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";
+
+// src/db/stamps.ts
+function insertStamp(db, params) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(`
+    INSERT INTO stamps (id, hash, status, created_at, proof_path, archive_path, attempt_count, metadata)
+    VALUES (?, ?, 'pending', ?, ?, ?, 0, ?)
+  `).run(params.id, params.hash, now, params.proof_path, params.archive_path ?? null, params.metadata ?? null);
+  return getStamp(db, params.id);
+}
+function getStamp(db, id) {
+  return db.prepare("SELECT * FROM stamps WHERE id = ?").get(id) ?? null;
+}
+function updateStampStatus(db, id, params) {
+  const fields = [];
+  const values = [];
+  const add = (col, val) => {
+    fields.push(`${col} = ?`);
+    values.push(val);
+  };
+  if (params.status !== void 0) add("status", params.status);
+  if (params.bitcoin_block !== void 0) add("bitcoin_block", params.bitcoin_block);
+  if (params.bitcoin_time !== void 0) add("bitcoin_time", params.bitcoin_time);
+  if (params.confirmed_at !== void 0) add("confirmed_at", params.confirmed_at);
+  if (params.last_error !== void 0) add("last_error", params.last_error);
+  if (params.attempt_count !== void 0) add("attempt_count", params.attempt_count);
+  if (params.last_attempt_at !== void 0) add("last_attempt_at", params.last_attempt_at);
+  if (params.next_retry_at !== void 0) add("next_retry_at", params.next_retry_at);
+  if (fields.length === 0) return;
+  values.push(id);
+  db.prepare(`UPDATE stamps SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+}
+function listStamps(db, params) {
+  const conds = [];
+  const vals = [];
+  if (params.status) {
+    conds.push("status = ?");
+    vals.push(params.status);
+  }
+  if (params.older_than_hours) {
+    const cutoff = new Date(Date.now() - params.older_than_hours * 36e5).toISOString();
+    conds.push("created_at < ?");
+    vals.push(cutoff);
+  }
+  if (params.due_now) {
+    conds.push("(next_retry_at IS NULL OR next_retry_at <= ?)");
+    vals.push((/* @__PURE__ */ new Date()).toISOString());
+  }
+  const where = conds.length ? `WHERE ${conds.join(" AND ")}` : "";
+  const total = db.prepare(`SELECT COUNT(*) as n FROM stamps ${where}`).get(...vals).n;
+  const items = db.prepare(
+    `SELECT * FROM stamps ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`
+  ).all(...vals, params.limit, params.offset);
+  return { items, total };
+}
+
+// src/db/operations-log.ts
+function logOperation(db, params) {
+  db.prepare(`
+    INSERT INTO operations_log (stamp_id, action, result, error_msg, calendar_uri, response_time_ms, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    params.stamp_id,
+    params.action,
+    params.result,
+    params.error_msg ?? null,
+    params.calendar_uri ?? null,
+    params.response_time_ms ?? null,
+    (/* @__PURE__ */ new Date()).toISOString()
+  );
+}
+
+// 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) {
+    atts.push(...collectAttestations(branch.stamp));
+  }
+  return atts;
+}
+function checkBitcoinConfirmation(bytes) {
+  try {
+    const ctx = new StreamDeserializationContext(new Uint8Array(bytes));
+    const dtf = DetachedTimestampFile.deserialize(ctx);
+    const attestations = collectAttestations(dtf.timestamp);
+    const bitcoinAtts = attestations.filter((a) => a.kind === "bitcoin");
+    if (bitcoinAtts.length === 0) return { confirmed: false };
+    const block = Math.min(...bitcoinAtts.map((a) => a.height));
+    return { confirmed: true, block };
+  } catch {
+    return { confirmed: false };
+  }
+}
+function nextRetryAt(attemptCount) {
+  const base = Math.min(3e4 * Math.pow(2, attemptCount), 36e5);
+  const jitter = Math.random() * 0.2 * base;
+  return new Date(Date.now() + base + jitter).toISOString();
+}
+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({
+    calendars: config.calendars,
+    resilience: { timeout: config.calendar_timeout_ms }
+  });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const newAttemptCount = record.attempt_count + 1;
+  const next = nextRetryAt(newAttemptCount);
+  let upgraded;
+  try {
+    upgraded = await client.upgrade(proofBefore);
+  } catch (e) {
+    if (e instanceof UpgradeError) {
+      updateStampStatus(db, input.id, { last_attempt_at: now, attempt_count: newAttemptCount, next_retry_at: next });
+      logOperation(db, { stamp_id: input.id, action: "upgrade", result: "pending" });
+      return { id: input.id, status: "pending", attempt_count: newAttemptCount, last_attempt_at: now, next_retry_at: next };
+    }
+    updateStampStatus(db, input.id, { last_attempt_at: now, attempt_count: newAttemptCount, last_error: String(e), next_retry_at: next });
+    logOperation(db, { stamp_id: input.id, action: "upgrade", result: "failed", error_msg: String(e) });
+    return { error: "calendar_error", details: String(e) };
+  }
+  writeAtomic(record.proof_path, upgraded);
+  const { confirmed, block } = checkBitcoinConfirmation(upgraded);
+  if (confirmed && block !== void 0) {
+    const bitcoinTime = now;
+    updateStampStatus(db, input.id, {
+      status: "confirmed",
+      bitcoin_block: block,
+      bitcoin_time: bitcoinTime,
+      confirmed_at: now,
+      last_attempt_at: now,
+      attempt_count: newAttemptCount
+    });
+    logOperation(db, { stamp_id: input.id, action: "upgrade", result: "success" });
+    return { id: input.id, status: "confirmed", bitcoin_block: block, bitcoin_time: bitcoinTime, proof_path: record.proof_path };
+  }
+  updateStampStatus(db, input.id, { last_attempt_at: now, attempt_count: newAttemptCount, next_retry_at: next });
+  logOperation(db, { stamp_id: input.id, action: "upgrade", result: "pending" });
+  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 {
+  getStamp,
+  createTimestamp,
+  upgradeTimestamp,
+  verifyTimestamp,
+  listPending
+};

package/dist/chunk-YFSUDT24.js

@@ -0,0 +1,24 @@
+// src/utils.ts
+import { execFileSync } from "child_process";
+import { writeFileSync, renameSync } from "fs";
+function which(cmd) {
+  try {
+    const out = execFileSync(
+      process.platform === "win32" ? "where" : "which",
+      [cmd]
+    ).toString().trim();
+    return out.split("\n")[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+function writeAtomic(dest, data) {
+  const tmp = dest + ".tmp";
+  writeFileSync(tmp, data);
+  renameSync(tmp, dest);
+}
+
+export {
+  which,
+  writeAtomic
+};

package/dist/claude-QTEB3Z5V.js

@@ -0,0 +1,54 @@
+// src/setup/claude.ts
+import { readFileSync, writeFileSync, copyFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function getConfigPath() {
+  if (process.platform === "win32") {
+    return join(process.env.APPDATA ?? "", "Claude", "claude_desktop_config.json");
+  } else if (process.platform === "darwin") {
+    return join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  } else {
+    return join(homedir(), ".config", "Claude", "claude_desktop_config.json");
+  }
+}
+function setupClaude() {
+  const configPath = getConfigPath();
+  const configDir = join(configPath, "..");
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  let config = {};
+  if (existsSync(configPath)) {
+    try {
+      config = JSON.parse(readFileSync(configPath, "utf8"));
+    } catch {
+      process.stderr.write(`  Aviso: no se pudo parsear la config existente, se crear\xE1 nueva.
+`);
+    }
+    const existing = config.mcpServers ?? {};
+    if ("otskit" in existing) {
+      process.stdout.write(`  ots-mcp ya est\xE1 configurado en ${configPath}
+`);
+      process.stdout.write(`  No se hizo ning\xFAn cambio.
+`);
+      return;
+    }
+    const backupPath = configPath + ".bak";
+    copyFileSync(configPath, backupPath);
+    process.stdout.write(`  Backup guardado en ${backupPath}
+`);
+  }
+  const mcpServers = config.mcpServers ?? {};
+  mcpServers["otskit"] = { command: "npx", args: ["-y", "@otskit/mcp", "serve"] };
+  config.mcpServers = mcpServers;
+  writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+  process.stdout.write(`OTSkit MCP configurado para Claude Desktop
+`);
+  process.stdout.write(`  Config: ${configPath}
+`);
+  process.stdout.write(`  Reinicia Claude Desktop para aplicar los cambios.
+`);
+}
+export {
+  setupClaude
+};