@otskit/mcp 0.1.7 → 0.2.1

package/dist/claude-code-THJIWEHG.js

@@ -0,0 +1,48 @@
+// src/setup/claude-code.ts
+import { readFileSync, writeFileSync, copyFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function getConfigPath() {
+  return join(homedir(), ".claude.json");
+}
+function setupClaudeCode() {
+  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 Code CLI
+`);
+  process.stdout.write(`  Config: ${configPath}
+`);
+  process.stdout.write(`  Reinicia Claude Code para aplicar los cambios.
+`);
+}
+export {
+  setupClaudeCode
+};

package/dist/cli-D7G2H6UT.js

@@ -0,0 +1,98 @@
+import {
+  createTimestamp,
+  listPending,
+  upgradeTimestamp,
+  verifyTimestamp
+} from "./chunk-OMNHFTJW.js";
+import {
+  backupDb,
+  getDb,
+  loadConfig
+} from "./chunk-4ZDPWS7C.js";
+import "./chunk-YFSUDT24.js";
+
+// src/cli.ts
+async function runCli(command, args) {
+  const config = loadConfig();
+  const db = getDb();
+  switch (command) {
+    case "stamp": {
+      const hash = args[0];
+      if (!hash) {
+        process.stderr.write("Usage: ots-mcp stamp <sha256-hash>\n");
+        process.exit(1);
+      }
+      const result = await createTimestamp({ hash }, db, config);
+      if ("error" in result) {
+        process.stderr.write(`Error: ${result.error} \u2014 ${result.details}
+`);
+        process.exit(1);
+      }
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      break;
+    }
+    case "upgrade": {
+      const id = args[0];
+      if (!id) {
+        process.stderr.write("Usage: ots-mcp upgrade <id>\n");
+        process.exit(1);
+      }
+      const result = await upgradeTimestamp({ id }, db, config);
+      if ("error" in result) {
+        process.stderr.write(`Error: ${result.error} \u2014 ${result.details}
+`);
+        process.exit(1);
+      }
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      break;
+    }
+    case "verify": {
+      const id = args[0];
+      if (!id) {
+        process.stderr.write("Usage: ots-mcp verify <id>\n");
+        process.exit(1);
+      }
+      const result = await verifyTimestamp({ id }, db, config);
+      if ("error" in result) {
+        process.stderr.write(`Error: ${result.error} \u2014 ${result.details}
+`);
+        process.exit(1);
+      }
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      break;
+    }
+    case "list": {
+      const status = args[0] ?? "pending";
+      const result = listPending({ status }, db, config);
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      break;
+    }
+    case "check-pending": {
+      const { items } = listPending({ status: "pending", limit: 200, due_now: true }, db, config);
+      process.stderr.write(`Processing ${items.length} pending stamps...
+`);
+      for (const record of items) {
+        const result = await upgradeTimestamp({ id: record.id }, db, config);
+        const statusStr = "status" in result ? result.status : `error:${result.error}`;
+        process.stderr.write(`${record.id.slice(0, 8)}: ${statusStr}
+`);
+      }
+      process.exit(0);
+    }
+    case "backup": {
+      const dest = args[0] ?? `ots-mcp-backup-${Date.now()}.sqlite`;
+      backupDb(dest);
+      process.stdout.write(`Backup saved to ${dest}
+`);
+      break;
+    }
+    case "scheduler": {
+      const { runScheduler } = await import("./scheduler-MTE6OUSV.js");
+      await runScheduler(args);
+      break;
+    }
+  }
+}
+export {
+  runCli
+};

package/dist/codex-P7EDO5GY.js

@@ -0,0 +1,41 @@
+// src/setup/codex.ts
+import { readFileSync, writeFileSync, copyFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var BLOCK = `
+[mcp_servers.ots-mcp]
+command = "npx"
+args = ["-y", "@otskit/mcp", "serve"]
+`;
+function setupCodex() {
+  const configPath = join(homedir(), ".codex", "config.toml");
+  const configDir = join(configPath, "..");
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  let content = "";
+  if (existsSync(configPath)) {
+    content = readFileSync(configPath, "utf8");
+    if (content.includes("[mcp_servers.ots-mcp]")) {
+      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}
+`);
+  }
+  writeFileSync(configPath, content.trimEnd() + "\n" + BLOCK, "utf8");
+  process.stdout.write(`OTSkit MCP configurado para Codex
+`);
+  process.stdout.write(`  Config: ${configPath}
+`);
+  process.stdout.write(`  Reinicia Codex para aplicar los cambios.
+`);
+}
+export {
+  setupCodex
+};

package/dist/index.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+// src/index.ts
+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)
+  setup <target>     Configure MCP for an agent (claude | claude-code | codex)
+  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-IDRHOKL7.js");
+    await runServer();
+    break;
+  }
+  case "setup": {
+    const target = args[0];
+    if (!target || target !== "claude" && target !== "claude-code" && target !== "codex") {
+      process.stderr.write(`Usage: ots-mcp setup <claude|claude-code|codex>
+`);
+      process.exit(1);
+    }
+    if (target === "claude") {
+      const { setupClaude } = await import("./claude-QTEB3Z5V.js");
+      setupClaude();
+    } else if (target === "claude-code") {
+      const { setupClaudeCode } = await import("./claude-code-THJIWEHG.js");
+      setupClaudeCode();
+    } else {
+      const { setupCodex } = await import("./codex-P7EDO5GY.js");
+      setupCodex();
+    }
+    break;
+  }
+  case "install-claude": {
+    const { installClaude } = await import("./install-claude-UKSS65BW.js");
+    installClaude();
+    break;
+  }
+  case "watch": {
+    const { watchPending } = await import("./watch-7NPUWR6I.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
+`);
+    await watchPending(interval);
+    break;
+  }
+  case "stamp":
+  case "upgrade":
+  case "verify":
+  case "list":
+  case "check-pending":
+  case "backup":
+  case "scheduler": {
+    const { runCli } = await import("./cli-D7G2H6UT.js");
+    await runCli(command, args);
+    break;
+  }
+  default: {
+    process.stderr.write(`Unknown command: ${command}. Run 'ots-mcp help' for usage.
+`);
+    process.exit(1);
+  }
+}

package/dist/install-BUSOMBB2.js

@@ -0,0 +1,37 @@
+import {
+  which
+} from "./chunk-YFSUDT24.js";
+
+// src/scheduler/install.ts
+import { execFileSync } from "child_process";
+import { writeFileSync } from "fs";
+async function installScheduler(args) {
+  const intervalIdx = args.indexOf("--interval");
+  const interval = intervalIdx !== -1 ? parseInt(args[intervalIdx + 1] ?? "30") : 30;
+  const bin = which("ots-mcp") ?? process.argv[1];
+  if (process.platform === "win32") {
+    const xmlPath = `${process.env.TEMP}\\ots-mcp-task.xml`;
+    writeFileSync(xmlPath, `<?xml version="1.0"?>
+<Task xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <Triggers><TimeTrigger>
+    <Repetition><Interval>PT${interval}M</Interval><StopAtDurationEnd>false</StopAtDurationEnd></Repetition>
+    <StartBoundary>2020-01-01T00:00:00</StartBoundary><Enabled>true</Enabled>
+  </TimeTrigger></Triggers>
+  <Actions><Exec>
+    <Command>${bin}</Command>
+    <Arguments>check-pending</Arguments>
+  </Exec></Actions>
+</Task>`);
+    execFileSync("schtasks", ["/create", "/tn", "ots-mcp-check-pending", "/xml", xmlPath, "/f"]);
+    process.stdout.write(`Scheduler installed: runs every ${interval} minutes
+`);
+  } else {
+    process.stdout.write(`Add to crontab (run: crontab -e):
+`);
+    process.stdout.write(`*/${interval} * * * * "${bin}" check-pending
+`);
+  }
+}
+export {
+  installScheduler
+};

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/remove-BGFQRDX3.js

@@ -0,0 +1,17 @@
+// src/scheduler/remove.ts
+import { execFileSync } from "child_process";
+async function removeScheduler() {
+  if (process.platform === "win32") {
+    try {
+      execFileSync("schtasks", ["/delete", "/tn", "ots-mcp-check-pending", "/f"]);
+      process.stdout.write("Scheduler task removed\n");
+    } catch {
+      process.stderr.write("Task not found or could not be removed\n");
+    }
+  } else {
+    process.stdout.write("Remove the ots-mcp entry from crontab: crontab -e\n");
+  }
+}
+export {
+  removeScheduler
+};

package/dist/scheduler-MTE6OUSV.js

@@ -0,0 +1,27 @@
+// src/scheduler/index.ts
+async function runScheduler(args) {
+  const [sub, ...rest] = args;
+  switch (sub) {
+    case "install": {
+      const { installScheduler } = await import("./install-BUSOMBB2.js");
+      await installScheduler(rest);
+      break;
+    }
+    case "remove": {
+      const { removeScheduler } = await import("./remove-BGFQRDX3.js");
+      await removeScheduler();
+      break;
+    }
+    case "status": {
+      const { statusScheduler } = await import("./status-M6A2RG7G.js");
+      await statusScheduler();
+      break;
+    }
+    default:
+      process.stderr.write("Usage: ots-mcp scheduler install [--interval N] | remove | status\n");
+      process.exit(1);
+  }
+}
+export {
+  runScheduler
+};

package/dist/server-IDRHOKL7.js

@@ -0,0 +1,221 @@
+import {
+  createTimestamp,
+  getStamp,
+  listPending,
+  upgradeTimestamp,
+  verifyTimestamp
+} from "./chunk-OMNHFTJW.js";
+import {
+  getDb,
+  loadConfig
+} from "./chunk-4ZDPWS7C.js";
+import "./chunk-YFSUDT24.js";
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/inspect-timestamp.ts
+import { readFileSync, statSync } from "fs";
+import { DetachedTimestampFile } from "@otskit/core";
+function inspectTimestamp(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: "proof_missing", details: "No proof file on record" };
+  let proofBytes;
+  let proofSize;
+  try {
+    proofSize = statSync(record.proof_path).size;
+    proofBytes = readFileSync(record.proof_path);
+  } catch {
+    return { error: "proof_missing", details: `Cannot read proof: ${record.proof_path}` };
+  }
+  let calendarAttestations = 0;
+  let bitcoinAttestations = 0;
+  let bitcoinBlock = null;
+  try {
+    const proof = DetachedTimestampFile.deserialize(new Uint8Array(proofBytes));
+    const attestations = proof.timestamp.getAttestations();
+    bitcoinAttestations = attestations.filter((a) => a.kind === "bitcoin").length;
+    calendarAttestations = attestations.filter((a) => a.kind !== "bitcoin").length;
+    if (bitcoinAttestations > 0) {
+      const blocks = attestations.filter((a) => a.kind === "bitcoin").map((a) => a.height);
+      bitcoinBlock = blocks.length > 0 ? Math.min(...blocks) : null;
+    }
+  } catch {
+  }
+  return {
+    id: record.id,
+    hash: record.hash,
+    status: record.status,
+    created_at: record.created_at,
+    proof_path: record.proof_path,
+    proof_size_bytes: proofSize,
+    calendar_attestations: calendarAttestations,
+    bitcoin_attestations: bitcoinAttestations,
+    bitcoin_confirmed: bitcoinAttestations > 0,
+    bitcoin_block: bitcoinBlock
+  };
+}
+
+// src/tools/watch-window.ts
+import { exec } from "child_process";
+function openWatchWindow(intervalMinutes = 5) {
+  const minutes = Math.max(1, Math.floor(intervalMinutes));
+  const cmd = `start powershell.exe -NoExit -Command "ots-mcp watch ${minutes}"`;
+  let errorMsg;
+  exec(cmd, { shell: "cmd" }, (err) => {
+    if (err) errorMsg = err.message;
+  });
+  return { opened: true, interval_minutes: minutes, ...errorMsg ? { error: errorMsg } : {} };
+}
+
+// src/tool-definitions.ts
+var TOOL_DEFINITIONS = [
+  {
+    name: "create_timestamp",
+    description: "Stamps a SHA-256 hash against public OpenTimestamps calendars. IMPORTANT: the digest is sent to external calendar servers (alice.btc, bob.btc, finney, catallaxy).",
+    inputSchema: {
+      type: "object",
+      properties: { hash: { type: "string", description: "SHA-256 hex digest (64 chars)" } },
+      required: ["hash"]
+    },
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    }
+  },
+  {
+    name: "upgrade_timestamp",
+    description: "Checks if a pending stamp has been confirmed in Bitcoin. Use the id returned by create_timestamp.",
+    inputSchema: {
+      type: "object",
+      properties: { id: { type: "string", description: "UUID from the stamp record" } },
+      required: ["id"]
+    },
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    }
+  },
+  {
+    name: "verify_timestamp",
+    description: "Verifies a stamp against Bitcoin. Does NOT affirm document authorship or truth \u2014 only proves the hash existed before a given Bitcoin block.",
+    inputSchema: {
+      type: "object",
+      properties: { id: { type: "string", description: "UUID from the stamp record" } },
+      required: ["id"]
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    }
+  },
+  {
+    name: "inspect_timestamp",
+    description: "Inspects a stored proof file without network calls. Returns calendar_attestations (promises from OTS servers, NOT Bitcoin confirmation) and bitcoin_attestations (actual Bitcoin blocks). A stamp is only truly confirmed when bitcoin_attestations > 0 and bitcoin_confirmed is true.",
+    inputSchema: {
+      type: "object",
+      properties: { id: { type: "string", description: "UUID from the stamp record" } },
+      required: ["id"]
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    }
+  },
+  {
+    name: "list_pending",
+    description: "Lists stamp records with status and retry info.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        status: { type: "string", enum: ["pending", "confirmed", "failed", "timeout"] },
+        limit: { type: "number", maximum: 200 },
+        offset: { type: "number" },
+        older_than_hours: { type: "number" }
+      }
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    }
+  },
+  {
+    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.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        interval_minutes: { type: "number", description: "Polling interval in minutes (default: 5, minimum: 1)" }
+      }
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    }
+  }
+];
+
+// src/server.ts
+async function runServer() {
+  const config = loadConfig();
+  const db = getDb();
+  const server = new Server(
+    { name: "ots-mcp", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOL_DEFINITIONS
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      let result;
+      switch (name) {
+        case "create_timestamp":
+          result = await createTimestamp(args, db, config);
+          break;
+        case "upgrade_timestamp":
+          result = await upgradeTimestamp(args, db, config);
+          break;
+        case "verify_timestamp":
+          result = await verifyTimestamp(args, db, config);
+          break;
+        case "inspect_timestamp":
+          result = inspectTimestamp(args, db, config);
+          break;
+        case "list_pending":
+          result = listPending(args, db, config);
+          break;
+        case "watch":
+          result = openWatchWindow(args?.interval_minutes);
+          break;
+        default:
+          return { content: [{ type: "text", text: JSON.stringify({ error: "unknown_tool", tool: name }) }], isError: true };
+      }
+      const isError = Boolean(result && typeof result === "object" && "error" in result);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }], isError };
+    } catch (e) {
+      return { content: [{ type: "text", text: JSON.stringify({ error: "internal_error", details: String(e) }) }], isError: true };
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+export {
+  runServer
+};

package/dist/status-M6A2RG7G.js

@@ -0,0 +1,17 @@
+// src/scheduler/status.ts
+import { execFileSync } from "child_process";
+async function statusScheduler() {
+  if (process.platform === "win32") {
+    try {
+      const out = execFileSync("schtasks", ["/query", "/tn", "ots-mcp-check-pending", "/fo", "LIST"]).toString();
+      process.stdout.write(out + "\n");
+    } catch {
+      process.stdout.write("Scheduler task not found\n");
+    }
+  } else {
+    process.stdout.write("Check with: crontab -l | grep ots-mcp\n");
+  }
+}
+export {
+  statusScheduler
+};

package/dist/watch-7NPUWR6I.js

@@ -0,0 +1,41 @@
+import {
+  getDb,
+  loadConfig
+} from "./chunk-4ZDPWS7C.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.
+
+`);
+  function tick() {
+    const rows = db.prepare(
+      `SELECT id, hash, status, attempt_count, bitcoin_block, confirmed_at FROM stamps WHERE status != 'confirmed' ORDER BY created_at DESC`
+    ).all();
+    const confirmed = db.prepare(`SELECT COUNT(*) as n FROM stamps WHERE status = 'confirmed'`).get();
+    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
+};