@otskit/mcp 0.1.2 → 0.1.4

package/dist/chunk-45GR42GV.js

@@ -0,0 +1,115 @@
+import {
+  getDataDir,
+  getStamp,
+  insertStamp,
+  listStamps,
+  logOperation
+} from "./chunk-ASPLCXMC.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 listPending(input, db, _config) {
+  return listStamps(db, {
+    status: input.status ?? "pending",
+    limit: Math.min(input.limit ?? 50, 200),
+    offset: input.offset ?? 0,
+    older_than_hours: input.older_than_hours
+  });
+}
+
+export {
+  createTimestamp,
+  verifyTimestamp,
+  listPending
+};

package/dist/{chunk-6IPLIM6I.js → chunk-ASPLCXMC.js}

@@ -119,11 +119,10 @@ function reconcileOrphans(db) {
   }
 }
 
-// src/tools/create-timestamp.ts
-import { mkdirSync as mkdirSync3 } from "fs";
-import { join as join3 } from "path";
-import { randomUUID } from "crypto";
-import { OpenTimestampsClient } from "@otskit/client";
+// src/tools/upgrade-timestamp.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { OpenTimestampsClient, UpgradeError } from "@otskit/client";
+import { DetachedTimestampFile } from "@otskit/core";
 
 // src/db/stamps.ts
 function insertStamp(db, params) {
@@ -192,50 +191,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 = join3(getDataDir(), "proofs");
-  mkdirSync3(proofDir, { recursive: true });
-  const proofPath = join3(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 as readFileSync2 } from "fs";
-import { OpenTimestampsClient as OpenTimestampsClient2, UpgradeError } from "@otskit/client";
-import { DetachedTimestampFile } from "@otskit/core";
 function checkBitcoinConfirmation(bytes) {
   try {
     const proof = DetachedTimestampFile.deserialize(new Uint8Array(bytes));
@@ -260,7 +216,7 @@ async function upgradeTimestamp(input, db, config) {
   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 = readFileSync2(record.proof_path);
-  const client = new OpenTimestampsClient2({
+  const client = new OpenTimestampsClient({
     calendars: config.calendars,
     resilience: { timeout: config.calendar_timeout_ms }
   });
@@ -300,69 +256,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 readFileSync3 } 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 = readFileSync3(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 listPending(input, db, _config) {
-  return listStamps(db, {
-    status: input.status ?? "pending",
-    limit: Math.min(input.limit ?? 50, 200),
-    offset: input.offset ?? 0,
-    older_than_hours: input.older_than_hours
-  });
-}
-
 export {
   getDataDir,
   loadConfig,
   getDb,
   backupDb,
+  insertStamp,
   getStamp,
-  createTimestamp,
-  upgradeTimestamp,
-  verifyTimestamp,
-  listPending
+  listStamps,
+  logOperation,
+  upgradeTimestamp
 };

package/dist/{cli-GQMURR5I.js → cli-67APZKT6.js}

@@ -1,12 +1,14 @@
 import {
-  backupDb,
   createTimestamp,
-  getDb,
   listPending,
-  loadConfig,
-  upgradeTimestamp,
   verifyTimestamp
-} from "./chunk-6IPLIM6I.js";
+} from "./chunk-45GR42GV.js";
+import {
+  backupDb,
+  getDb,
+  loadConfig,
+  upgradeTimestamp
+} from "./chunk-ASPLCXMC.js";
 import "./chunk-YFSUDT24.js";
 
 // src/cli.ts

package/dist/index.js

@@ -5,23 +5,36 @@ var [, , command, ...args] = process.argv;
 if (!command || command === "--help" || command === "help") {
   process.stderr.write(`Usage: ots-mcp <command>
 Commands:
-  serve           Start MCP server (stdio transport)
-  stamp <hash>    Stamp a SHA-256 hash
-  upgrade <id>    Upgrade a pending stamp
-  verify <id>     Verify a stamp
-  list [status]   List stamps (default: pending)
-  check-pending   Run pending upgrades (for scheduler)
-  backup [dest]   Backup the SQLite database
-  scheduler       Manage OS scheduler (install|remove|status)
+  serve              Start MCP server (stdio transport)
+  install-claude     Install MCP in Claude Desktop config (auto-setup)
+  watch [interval]   Watch pending stamps in real-time (default: 5 min)
+  stamp <hash>       Stamp a SHA-256 hash
+  upgrade <id>       Upgrade a pending stamp
+  verify <id>        Verify a stamp
+  list [status]      List stamps (default: pending)
+  check-pending      Run pending upgrades (for scheduler)
+  backup [dest]      Backup the SQLite database
+  scheduler          Manage OS scheduler (install|remove|status)
 `);
   process.exit(command ? 0 : 1);
 }
 switch (command) {
   case "serve": {
-    const { runServer } = await import("./server-NCO7JIUI.js");
+    const { runServer } = await import("./server-2YEI77IT.js");
     await runServer();
     break;
   }
+  case "install-claude": {
+    const { installClaude } = await import("./install-claude-UKSS65BW.js");
+    installClaude();
+    break;
+  }
+  case "watch": {
+    const { watchPending } = await import("./watch-JWDMAZWS.js");
+    const interval = args[0] ? parseInt(args[0]) : 5;
+    await watchPending(interval);
+    break;
+  }
   case "stamp":
   case "upgrade":
   case "verify":
@@ -29,7 +42,7 @@ switch (command) {
   case "check-pending":
   case "backup":
   case "scheduler": {
-    const { runCli } = await import("./cli-GQMURR5I.js");
+    const { runCli } = await import("./cli-67APZKT6.js");
     await runCli(command, args);
     break;
   }

package/dist/install-claude-UKSS65BW.js

@@ -0,0 +1,44 @@
+// src/install-claude.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+function getConfigPath() {
+  if (process.platform === "win32") {
+    return join(process.env.APPDATA ?? "", "Claude", "claude_desktop_config.json");
+  } else if (process.platform === "darwin") {
+    return join(process.env.HOME ?? "", "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  } else {
+    return join(process.env.HOME ?? "", ".config", "Claude", "claude_desktop_config.json");
+  }
+}
+function installClaude() {
+  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(`Warning: could not parse existing config, creating new one
+`);
+    }
+  }
+  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(`\u2713 OTSkit MCP installed in Claude Desktop
+`);
+  process.stdout.write(`  Config: ${configPath}
+`);
+  process.stdout.write(`  Restart Claude Desktop to apply changes.
+`);
+}
+export {
+  installClaude
+};

package/dist/{server-NCO7JIUI.js → server-2YEI77IT.js}

@@ -1,13 +1,15 @@
 import {
   createTimestamp,
+  listPending,
+  verifyTimestamp
+} from "./chunk-45GR42GV.js";
+import {
   getDataDir,
   getDb,
   getStamp,
-  listPending,
   loadConfig,
-  upgradeTimestamp,
-  verifyTimestamp
-} from "./chunk-6IPLIM6I.js";
+  upgradeTimestamp
+} from "./chunk-ASPLCXMC.js";
 import "./chunk-YFSUDT24.js";
 
 // src/server.ts

package/dist/watch-JWDMAZWS.js

@@ -0,0 +1,47 @@
+import {
+  getDb,
+  loadConfig,
+  upgradeTimestamp
+} from "./chunk-ASPLCXMC.js";
+import "./chunk-YFSUDT24.js";
+
+// src/tools/watch.ts
+async function watchPending(intervalMinutes = 5) {
+  const config = loadConfig();
+  const db = getDb(config);
+  process.stdout.write(`Watching pending stamps every ${intervalMinutes} min. Ctrl+C to stop.
+
+`);
+  async function tick() {
+    const rows = db.prepare(`SELECT id, hash, status FROM stamps WHERE status = 'pending'`).all();
+    if (rows.length === 0) {
+      process.stdout.write(`${now()} All stamps confirmed.
+`);
+      process.exit(0);
+    }
+    process.stdout.write(`${now()} Checking ${rows.length} pending stamps...
+`);
+    for (const row of rows) {
+      const result = await upgradeTimestamp({ id: row.id }, db, config);
+      if ("error" in result) {
+        process.stdout.write(`  ${row.id.slice(0, 8)}... ERROR: ${result.error}
+`);
+      } else if (result.status === "confirmed") {
+        process.stdout.write(`  ${row.id.slice(0, 8)}... CONFIRMED block #${result.bitcoin_block}
+`);
+      } else {
+        process.stdout.write(`  ${row.id.slice(0, 8)}... pending (attempt ${result.attempt_count})
+`);
+      }
+    }
+    process.stdout.write("\n");
+  }
+  function now() {
+    return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+  }
+  await tick();
+  setInterval(tick, intervalMinutes * 60 * 1e3);
+}
+export {
+  watchPending
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otskit/mcp",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "OpenTimestamps MCP server — stamp, upgrade, verify via AI agents",
   "type": "module",
   "engines": { "node": ">=18" },