archive-org-mcp 1.0.0

package/README.md

@@ -0,0 +1,25 @@
+# archive-org-mcp
+
+Internet Archive search, item metadata, and Wayback snapshots.
+
+A merged MCP server that consolidates duplicate single-purpose servers in this monorepo into one focused server.
+
+## Tools
+
+- `searchItems` — Search the Internet Archive.
+- `getItem` — Details and file manifest for an item.
+- `getSnapshots` — Wayback snapshot history for a URL.
+- `getAvailability` — Closest Wayback snapshot for a URL.
+- `readSnapshot` — Read archived page text.
+
+## Run
+
+```bash
+npm install
+npm run build
+node dist/index.js
+```
+
+## Source
+
+Public free APIs only. See `src/api.ts` for exact endpoints.

package/dist/api.d.ts

@@ -0,0 +1,122 @@
+export interface m0_ArchiveItem {
+    identifier: string;
+    title?: string;
+    mediatype?: string;
+    year?: string;
+    downloads?: number;
+    collection?: string[];
+    description?: string;
+}
+export interface m0_ArchiveFile {
+    name: string;
+    size?: number;
+    format?: string;
+    length?: string;
+    title?: string;
+}
+export interface m1_Snapshot {
+    timestamp: string;
+    original: string;
+    statusCode: string;
+    mimeType: string;
+    length: string;
+    url: string;
+}
+export declare const ArchiveError: {
+    new (message?: string): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    new (message?: string, options?: ErrorOptions): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const WaybackError: {
+    new (message?: string): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    new (message?: string, options?: ErrorOptions): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const fmtSize: (bytes?: number) => string;
+export declare const fmtTimestamp: (ts: string) => string;
+export declare const formatItem: (it: m0_ArchiveItem, index: number) => string;
+export declare const formatSnapshot: (s: m1_Snapshot, index?: number) => string;
+export declare const getAvailability: (url: string) => Promise<m1_Snapshot | null>;
+export declare const getItemDetails: (identifier: string) => Promise<{
+    identifier: string;
+    title?: string;
+    mediatype?: string;
+    description?: string;
+    files: m0_ArchiveFile[];
+}>;
+export declare const getSnapshotText: (timestamp: string, originalUrl: string, maxChars?: number) => Promise<string>;
+export declare const getSnapshots: (url: string, limit?: number) => Promise<m1_Snapshot[]>;
+export declare const searchItems: (query: string, mediatype: string | undefined, limit?: number) => Promise<m0_ArchiveItem[]>;
+export declare const m0_fmtSize: (bytes?: number) => string;
+export declare const m0_ArchiveError: {
+    new (message?: string): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    new (message?: string, options?: ErrorOptions): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const m0_getItemDetails: (identifier: string) => Promise<{
+    identifier: string;
+    title?: string;
+    mediatype?: string;
+    description?: string;
+    files: m0_ArchiveFile[];
+}>;
+export declare const m0_formatItem: (it: m0_ArchiveItem, index: number) => string;
+export declare const m0_searchItems: (query: string, mediatype: string | undefined, limit?: number) => Promise<m0_ArchiveItem[]>;
+export declare const m1_fmtTimestamp: (ts: string) => string;
+export declare const m1_formatSnapshot: (s: m1_Snapshot, index?: number) => string;
+export declare const m1_getAvailability: (url: string) => Promise<m1_Snapshot | null>;
+export declare const m1_WaybackError: {
+    new (message?: string): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    new (message?: string, options?: ErrorOptions): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const m1_getSnapshotText: (timestamp: string, originalUrl: string, maxChars?: number) => Promise<string>;
+export declare const m1_getSnapshots: (url: string, limit?: number) => Promise<m1_Snapshot[]>;

package/dist/api.js

@@ -0,0 +1,183 @@
+const m0 = (() => {
+    /**
+     * Internet Archive client — keyless.
+     *  - advancedsearch.php: full-text + metadata search over ~200M items.
+     *  - metadata/{identifier}: file manifests for an item.
+     */
+    const SEARCH = "https://archive.org/advancedsearch.php";
+    const META = "https://archive.org/metadata";
+    class ArchiveError extends Error {
+    }
+    async function getJson(url) {
+        const res = await fetch(url, { headers: { "User-Agent": "archive-org-mcp/1.0" } });
+        if (!res.ok)
+            throw new ArchiveError(`Internet Archive error ${res.status} for ${url.slice(0, 120)}`);
+        return (await res.json());
+    }
+    async function searchItems(query, mediatype, limit = 8) {
+        const q = mediatype ? `(${query}) AND mediatype:${mediatype}` : query;
+        const fl = ["identifier", "title", "mediatype", "year", "downloads", "collection", "description"].join(",");
+        const url = `${SEARCH}?q=${encodeURIComponent(q)}&fl[]=${fl}&rows=${limit}&page=1&output=json`;
+        const data = await getJson(url);
+        return (data.response?.docs ?? []).map((d) => ({
+            identifier: d.identifier ?? "",
+            title: d.title ?? d.identifier,
+            mediatype: d.mediatype,
+            year: d.year,
+            downloads: d.downloads,
+            collection: d.collection,
+            description: d.description,
+        }));
+    }
+    async function getItemDetails(identifier) {
+        const data = await getJson(`${META}/${encodeURIComponent(identifier)}`);
+        const files = (data.files ?? [])
+            .filter((f) => f.name && !f.name.endsWith("_files.xml") && !f.name.endsWith("_meta.xml"))
+            .map((f) => ({
+            name: f.name ?? "",
+            size: f.size,
+            format: f.format,
+            length: f.length,
+            title: f.title,
+        }))
+            .slice(0, 30);
+        return {
+            identifier: data.metadata?.identifier ?? identifier,
+            title: data.metadata?.title ?? data.metadata?.identifier,
+            mediatype: data.metadata?.mediatype,
+            description: data.metadata?.description,
+            files,
+        };
+    }
+    function fmtSize(bytes) {
+        if (!bytes)
+            return "";
+        const units = ["B", "KB", "MB", "GB", "TB"];
+        let v = bytes;
+        let i = 0;
+        while (v >= 1024 && i < units.length - 1) {
+            v /= 1024;
+            i++;
+        }
+        return `${v.toFixed(1)} ${units[i]}`;
+    }
+    function formatItem(it, index) {
+        const meta = [
+            it.mediatype,
+            it.year,
+            it.downloads ? `${it.downloads.toLocaleString()} downloads` : "",
+        ]
+            .filter(Boolean)
+            .join(" · ");
+        const lines = [
+            `${index + 1}. ${it.title ?? it.identifier} [${it.identifier}]`,
+            meta,
+            `https://archive.org/details/${it.identifier}`,
+        ].filter(Boolean);
+        return lines.join("\n");
+    }
+    return { ArchiveError, fmtSize, formatItem, getItemDetails, searchItems };
+})();
+const m1 = (() => {
+    /**
+     * Wayback Machine client. Keyless.
+     *  - CDX API lists snapshot history for a URL.
+     *  - /wayback/available finds the nearest snapshot.
+     *  - /web/{timestamp}id_/{url} serves the archived page content.
+     */
+    const CDX = "https://web.archive.org/cdx/search/cdx";
+    const AVAILABLE = "https://archive.org/wayback/available";
+    class WaybackError extends Error {
+    }
+    async function getText(url) {
+        const res = await fetch(url, {
+            headers: { "User-Agent": "wayback-mcp/1.0", Accept: "application/json,text/plain,text/html" },
+        });
+        if (!res.ok)
+            throw new WaybackError(`Wayback error ${res.status} for ${url.slice(0, 100)}`);
+        return res.text();
+    }
+    async function getSnapshots(url, limit = 10) {
+        const q = `${CDX}?url=${encodeURIComponent(url)}&output=json&fl=timestamp,original,statuscode,mimetype,length&filter=statuscode:200&limit=${limit}`;
+        const text = await getText(q);
+        const rows = JSON.parse(text);
+        if (rows.length <= 1)
+            return [];
+        const [, ...data] = rows;
+        return data.map((r) => ({
+            timestamp: r[0] ?? "",
+            original: r[1] ?? url,
+            statusCode: r[2] ?? "",
+            mimeType: r[3] ?? "",
+            length: r[4] ?? "",
+            url: `https://web.archive.org/web/${r[0]}id_/${r[1] ?? url}`,
+        }));
+    }
+    async function getAvailability(url) {
+        const text = await getText(`${AVAILABLE}?url=${encodeURIComponent(url)}`);
+        const d = JSON.parse(text);
+        const closest = d.archived_snapshots?.closest;
+        if (!closest?.url)
+            return null;
+        return {
+            timestamp: closest.timestamp ?? "",
+            original: url,
+            statusCode: closest.status ?? "",
+            mimeType: "",
+            length: "",
+            url: closest.url,
+        };
+    }
+    async function getSnapshotText(timestamp, originalUrl, maxChars = 15000) {
+        const target = `https://web.archive.org/web/${timestamp}id_/${originalUrl}`;
+        const raw = await getText(target);
+        const plain = raw
+            .replace(/<script[\s\S]*?<\/script>/gi, " ")
+            .replace(/<style[\s\S]*?<\/style>/gi, " ")
+            .replace(/<[^>]+>/g, " ")
+            .replace(/&nbsp;/g, " ")
+            .replace(/&amp;/g, "&")
+            .replace(/&lt;/g, "<")
+            .replace(/&gt;/g, ">")
+            .replace(/\s+/g, " ")
+            .trim();
+        return plain.slice(0, maxChars);
+    }
+    function fmtTimestamp(ts) {
+        if (ts.length < 12)
+            return ts;
+        return `${ts.slice(0, 4)}-${ts.slice(4, 6)}-${ts.slice(6, 8)} ${ts.slice(8, 10)}:${ts.slice(10, 12)} UTC`;
+    }
+    function formatSnapshot(s, index) {
+        const head = `${index !== undefined ? `${index + 1}. ` : ""}${fmtTimestamp(s.timestamp)}`;
+        const lines = [
+            head,
+            `Status ${s.statusCode || "?"}${s.mimeType ? ` · ${s.mimeType}` : ""}${s.length ? ` · ${s.length} bytes` : ""}`,
+            s.url,
+        ].filter(Boolean);
+        return lines.join("\n");
+    }
+    return { WaybackError, fmtTimestamp, formatSnapshot, getAvailability, getSnapshotText, getSnapshots };
+})();
+export const ArchiveError = m0.ArchiveError;
+export const WaybackError = m1.WaybackError;
+export const fmtSize = m0.fmtSize;
+export const fmtTimestamp = m1.fmtTimestamp;
+export const formatItem = m0.formatItem;
+export const formatSnapshot = m1.formatSnapshot;
+export const getAvailability = m1.getAvailability;
+export const getItemDetails = m0.getItemDetails;
+export const getSnapshotText = m1.getSnapshotText;
+export const getSnapshots = m1.getSnapshots;
+export const searchItems = m0.searchItems;
+export const m0_fmtSize = m0.fmtSize;
+export const m0_ArchiveError = m0.ArchiveError;
+export const m0_getItemDetails = m0.getItemDetails;
+export const m0_formatItem = m0.formatItem;
+export const m0_searchItems = m0.searchItems;
+export const m1_fmtTimestamp = m1.fmtTimestamp;
+export const m1_formatSnapshot = m1.formatSnapshot;
+export const m1_getAvailability = m1.getAvailability;
+export const m1_WaybackError = m1.WaybackError;
+export const m1_getSnapshotText = m1.getSnapshotText;
+export const m1_getSnapshots = m1.getSnapshots;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,12 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./server.js";
+async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("MCP server running on stdio");
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createServer(): McpServer;

package/dist/server.js

@@ -0,0 +1,112 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { m0_fmtSize, m0_formatItem, m0_getItemDetails, m0_searchItems, m1_formatSnapshot, m1_getAvailability, m1_getSnapshots, m1_getSnapshotText } from './api.js';
+const text = (value) => ({ content: [{ type: 'text', text: value }] });
+const textError = (t) => ({ content: [{ type: "text", text: t }], isError: true });
+const READ_ONLY = { readOnlyHint: true, openWorldHint: true };
+const error = (e) => `Error: ${e instanceof Error ? e.message : String(e)}`;
+const errorMessage = error;
+export function createServer() {
+    const server = new McpServer({ name: 'archive-org-mcp', version: '1.0.0' });
+    server.registerTool("search_items", {
+        title: "Search items",
+        description: "Search the Internet Archive — old software, abandoned CD-ROM games, " +
+            "bootleg concert tapes, 78rpm records, dead web pages, and more.",
+        inputSchema: z.object({
+            query: z.string().describe("Search query, e.g. 'Windows 95' or 'sonic hedgehog prototype'"),
+            mediatype: z
+                .enum(["software", "audio", "movies", "texts", "image", "web"])
+                .optional()
+                .describe("Restrict to a media type"),
+            limit: z.number().int().min(1).max(25).default(8),
+        }),
+        annotations: READ_ONLY,
+    }, async ({ query, mediatype, limit }) => {
+        try {
+            const items = await m0_searchItems(query, mediatype, limit);
+            if (items.length === 0)
+                return text(`Nothing in the Archive matches "${query}".`);
+            return text(`Archive.org results for "${query}"${mediatype ? ` (${mediatype})` : ""}:\n\n` +
+                items.map((it, i) => m0_formatItem(it, i)).join("\n\n"));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("get_item", {
+        title: "Get item",
+        description: "Get full details + file manifest for an archive.org item.",
+        inputSchema: z.object({ identifier: z.string().describe("Item identifier from search_items") }),
+        annotations: READ_ONLY,
+    }, async ({ identifier }) => {
+        try {
+            const d = await m0_getItemDetails(identifier);
+            const lines = [
+                d.title ?? d.identifier,
+                d.mediatype ? `Type: ${d.mediatype}` : "",
+                d.description ? d.description.slice(0, 400) : "",
+                `https://archive.org/details/${d.identifier}`,
+                "",
+                `Files (${d.files.length} shown):`,
+                ...d.files.map((f, i) => `${i + 1}. ${f.name}${f.format ? ` [${f.format}]` : ""}${f.size ? ` ${m0_fmtSize(f.size)}` : ""}${f.length ? ` (${f.length})` : ""}`),
+            ].filter(Boolean);
+            return text(lines.join("\n"));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("get_snapshots", {
+        title: "Get snapshots",
+        description: "List the Wayback Machine snapshot history for a URL.",
+        inputSchema: z.object({ url: z.string().describe("Full URL, e.g. 'example.com/page.html'"), limit: z.number().int().min(1).max(25).default(10) }),
+        annotations: READ_ONLY,
+    }, async ({ url, limit }) => {
+        try {
+            const snaps = await m1_getSnapshots(url, limit);
+            if (snaps.length === 0)
+                return text(`No archived snapshots of ${url}.`);
+            return text(`Snapshots of ${url}:\n\n${snaps.map((s, i) => m1_formatSnapshot(s, i)).join("\n\n")}`);
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("get_availability", {
+        title: "Get availability",
+        description: "Check whether a page is archived and get its closest snapshot.",
+        inputSchema: z.object({ url: z.string().describe("Full URL") }),
+        annotations: READ_ONLY,
+    }, async ({ url }) => {
+        try {
+            const snap = await m1_getAvailability(url);
+            if (!snap)
+                return text(`No archived snapshot of ${url}.`);
+            return text(`Closest snapshot of ${url}:\n\n${m1_formatSnapshot(snap)}`);
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("read_snapshot", {
+        title: "Read snapshot",
+        description: "Read the text content of an archived page, for reading dead sites.",
+        inputSchema: z.object({
+            timestamp: z.string().describe("Snapshot timestamp from get_snapshots, e.g. '20240101120000'"),
+            url: z.string().describe("The original URL that was archived"),
+            maxChars: z.number().int().min(500).max(50000).default(15000),
+        }),
+        annotations: READ_ONLY,
+    }, async ({ timestamp, url, maxChars }) => {
+        try {
+            const content = await m1_getSnapshotText(timestamp, url, maxChars);
+            if (!content.trim())
+                return text(`Snapshot ${timestamp} of ${url} has no readable text.`);
+            return text(content);
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    return server;
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "archive-org-mcp",
+  "version": "1.0.0",
+  "description": "Internet Archive search, item metadata, and Wayback snapshots.",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.0",
+    "@types/node": "^20.0.0"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "mcpName": "io.github.mrfentmen/archive-org-mcp"
+}

package/server.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.mrfentmen/archive-org-mcp",
+  "description": "Internet Archive search, item metadata, and Wayback snapshots.",
+  "repository": {
+    "url": "https://github.com/mrfentmen/awesome-mcps",
+    "source": "github"
+  },
+  "version": "1.0.0",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "archive-org-mcp",
+      "version": "1.0.0",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}

package/src/api.ts

@@ -0,0 +1,237 @@
+
+export interface m0_ArchiveItem {
+  identifier: string
+  title?: string
+  mediatype?: string
+  year?: string
+  downloads?: number
+  collection?: string[]
+  description?: string
+}
+
+export interface m0_ArchiveFile {
+  name: string
+  size?: number
+  format?: string
+  length?: string
+  title?: string
+}
+
+export interface m1_Snapshot {
+  timestamp: string
+  original: string
+  statusCode: string
+  mimeType: string
+  length: string
+  url: string
+}
+
+const m0 = (() => {
+/**
+ * Internet Archive client — keyless.
+ *  - advancedsearch.php: full-text + metadata search over ~200M items.
+ *  - metadata/{identifier}: file manifests for an item.
+ */
+const SEARCH = "https://archive.org/advancedsearch.php"
+const META = "https://archive.org/metadata"
+
+class ArchiveError extends Error {}
+
+
+
+async function getJson<T>(url: string): Promise<T> {
+  const res = await fetch(url, { headers: { "User-Agent": "archive-org-mcp/1.0" } })
+  if (!res.ok) throw new ArchiveError(`Internet Archive error ${res.status} for ${url.slice(0, 120)}`)
+  return (await res.json()) as T
+}
+
+async function searchItems(
+  query: string,
+  mediatype: string | undefined,
+  limit = 8
+): Promise<m0_ArchiveItem[]> {
+  const q = mediatype ? `(${query}) AND mediatype:${mediatype}` : query
+  const fl = ["identifier", "title", "mediatype", "year", "downloads", "collection", "description"].join(",")
+  const url = `${SEARCH}?q=${encodeURIComponent(q)}&fl[]=${fl}&rows=${limit}&page=1&output=json`
+  const data = await getJson<{ response?: { docs?: any[] } }>(url)
+  return (data.response?.docs ?? []).map((d) => ({
+    identifier: d.identifier ?? "",
+    title: d.title ?? d.identifier,
+    mediatype: d.mediatype,
+    year: d.year,
+    downloads: d.downloads,
+    collection: d.collection,
+    description: d.description,
+  }))
+}
+
+async function getItemDetails(identifier: string): Promise<{
+  identifier: string
+  title?: string
+  mediatype?: string
+  description?: string
+  files: m0_ArchiveFile[]
+}> {
+  const data = await getJson<any>(`${META}/${encodeURIComponent(identifier)}`)
+  const files: m0_ArchiveFile[] = (data.files ?? [])
+    .filter((f: any) => f.name && !f.name.endsWith("_files.xml") && !f.name.endsWith("_meta.xml"))
+    .map((f: any) => ({
+      name: f.name ?? "",
+      size: f.size,
+      format: f.format,
+      length: f.length,
+      title: f.title,
+    }))
+    .slice(0, 30)
+  return {
+    identifier: data.metadata?.identifier ?? identifier,
+    title: data.metadata?.title ?? data.metadata?.identifier,
+    mediatype: data.metadata?.mediatype,
+    description: data.metadata?.description,
+    files,
+  }
+}
+
+function fmtSize(bytes?: number): string {
+  if (!bytes) return ""
+  const units = ["B", "KB", "MB", "GB", "TB"]
+  let v = bytes
+  let i = 0
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024
+    i++
+  }
+  return `${v.toFixed(1)} ${units[i]}`
+}
+
+function formatItem(it: m0_ArchiveItem, index: number): string {
+  const meta = [
+    it.mediatype,
+    it.year,
+    it.downloads ? `${it.downloads.toLocaleString()} downloads` : "",
+  ]
+    .filter(Boolean)
+    .join(" · ")
+  const lines = [
+    `${index + 1}. ${it.title ?? it.identifier} [${it.identifier}]`,
+    meta,
+    `https://archive.org/details/${it.identifier}`,
+  ].filter(Boolean)
+  return lines.join("\n")
+}
+
+return { ArchiveError, fmtSize, formatItem, getItemDetails, searchItems };
+})();
+
+const m1 = (() => {
+/**
+ * Wayback Machine client. Keyless.
+ *  - CDX API lists snapshot history for a URL.
+ *  - /wayback/available finds the nearest snapshot.
+ *  - /web/{timestamp}id_/{url} serves the archived page content.
+ */
+const CDX = "https://web.archive.org/cdx/search/cdx"
+const AVAILABLE = "https://archive.org/wayback/available"
+
+class WaybackError extends Error {}
+
+
+async function getText(url: string): Promise<string> {
+  const res = await fetch(url, {
+    headers: { "User-Agent": "wayback-mcp/1.0", Accept: "application/json,text/plain,text/html" },
+  })
+  if (!res.ok) throw new WaybackError(`Wayback error ${res.status} for ${url.slice(0, 100)}`)
+  return res.text()
+}
+
+async function getSnapshots(url: string, limit = 10): Promise<m1_Snapshot[]> {
+  const q = `${CDX}?url=${encodeURIComponent(url)}&output=json&fl=timestamp,original,statuscode,mimetype,length&filter=statuscode:200&limit=${limit}`
+  const text = await getText(q)
+  const rows: string[][] = JSON.parse(text)
+  if (rows.length <= 1) return []
+  const [, ...data] = rows
+  return data.map((r) => ({
+    timestamp: r[0] ?? "",
+    original: r[1] ?? url,
+    statusCode: r[2] ?? "",
+    mimeType: r[3] ?? "",
+    length: r[4] ?? "",
+    url: `https://web.archive.org/web/${r[0]}id_/${r[1] ?? url}`,
+  }))
+}
+
+async function getAvailability(url: string): Promise<m1_Snapshot | null> {
+  const text = await getText(`${AVAILABLE}?url=${encodeURIComponent(url)}`)
+  const d = JSON.parse(text) as { archived_snapshots?: { closest?: { url?: string; timestamp?: string; status?: string } } }
+  const closest = d.archived_snapshots?.closest
+  if (!closest?.url) return null
+  return {
+    timestamp: closest.timestamp ?? "",
+    original: url,
+    statusCode: closest.status ?? "",
+    mimeType: "",
+    length: "",
+    url: closest.url,
+  }
+}
+
+async function getSnapshotText(
+  timestamp: string,
+  originalUrl: string,
+  maxChars = 15000
+): Promise<string> {
+  const target = `https://web.archive.org/web/${timestamp}id_/${originalUrl}`
+  const raw = await getText(target)
+  const plain = raw
+    .replace(/<script[\s\S]*?<\/script>/gi, " ")
+    .replace(/<style[\s\S]*?<\/style>/gi, " ")
+    .replace(/<[^>]+>/g, " ")
+    .replace(/&nbsp;/g, " ")
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/\s+/g, " ")
+    .trim()
+  return plain.slice(0, maxChars)
+}
+
+function fmtTimestamp(ts: string): string {
+  if (ts.length < 12) return ts
+  return `${ts.slice(0, 4)}-${ts.slice(4, 6)}-${ts.slice(6, 8)} ${ts.slice(8, 10)}:${ts.slice(10, 12)} UTC`
+}
+
+function formatSnapshot(s: m1_Snapshot, index?: number): string {
+  const head = `${index !== undefined ? `${index + 1}. ` : ""}${fmtTimestamp(s.timestamp)}`
+  const lines = [
+    head,
+    `Status ${s.statusCode || "?"}${s.mimeType ? ` · ${s.mimeType}` : ""}${s.length ? ` · ${s.length} bytes` : ""}`,
+    s.url,
+  ].filter(Boolean)
+  return lines.join("\n")
+}
+
+return { WaybackError, fmtTimestamp, formatSnapshot, getAvailability, getSnapshotText, getSnapshots };
+})();
+
+export const ArchiveError = m0.ArchiveError;
+export const WaybackError = m1.WaybackError;
+export const fmtSize = m0.fmtSize;
+export const fmtTimestamp = m1.fmtTimestamp;
+export const formatItem = m0.formatItem;
+export const formatSnapshot = m1.formatSnapshot;
+export const getAvailability = m1.getAvailability;
+export const getItemDetails = m0.getItemDetails;
+export const getSnapshotText = m1.getSnapshotText;
+export const getSnapshots = m1.getSnapshots;
+export const searchItems = m0.searchItems;
+export const m0_fmtSize = m0.fmtSize;
+export const m0_ArchiveError = m0.ArchiveError;
+export const m0_getItemDetails = m0.getItemDetails;
+export const m0_formatItem = m0.formatItem;
+export const m0_searchItems = m0.searchItems;
+export const m1_fmtTimestamp = m1.fmtTimestamp;
+export const m1_formatSnapshot = m1.formatSnapshot;
+export const m1_getAvailability = m1.getAvailability;
+export const m1_WaybackError = m1.WaybackError;
+export const m1_getSnapshotText = m1.getSnapshotText;
+export const m1_getSnapshots = m1.getSnapshots;

package/src/index.ts

@@ -0,0 +1,14 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
+import { createServer } from "./server.js"
+
+async function main(): Promise<void> {
+  const server = createServer()
+  const transport = new StdioServerTransport()
+  await server.connect(transport)
+  console.error("MCP server running on stdio")
+}
+
+main().catch((err: unknown) => {
+  console.error("Fatal error:", err)
+  process.exit(1)
+})

package/src/server.ts

@@ -0,0 +1,135 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { z } from 'zod'
+import { m0_ArchiveError, m0_fmtSize, m0_formatItem, m0_getItemDetails, m0_searchItems, m1_WaybackError, m1_formatSnapshot, m1_getAvailability, m1_getSnapshots, m1_getSnapshotText } from './api.js'
+
+const text = (value: string) => ({ content: [{ type: 'text' as const, text: value }] })
+const textError = (t: string) => ({ content: [{ type: "text" as const, text: t }], isError: true as const })
+const READ_ONLY = { readOnlyHint: true, openWorldHint: true } as const
+const error = (e: unknown) => `Error: ${e instanceof Error ? e.message : String(e)}`
+const errorMessage = error
+
+export function createServer(): McpServer {
+  const server = new McpServer({ name: 'archive-org-mcp', version: '1.0.0' })
+server.registerTool(
+    "search_items",
+    {
+      title: "Search items",
+      description: "Search the Internet Archive — old software, abandoned CD-ROM games, " +
+      "bootleg concert tapes, 78rpm records, dead web pages, and more.",
+      inputSchema: z.object(
+    {
+      query: z.string().describe("Search query, e.g. 'Windows 95' or 'sonic hedgehog prototype'"),
+      mediatype: z
+        .enum(["software", "audio", "movies", "texts", "image", "web"])
+        .optional()
+        .describe("Restrict to a media type"),
+      limit: z.number().int().min(1).max(25).default(8),
+    }),
+      annotations: READ_ONLY,
+    },
+    async ({ query, mediatype, limit }) => {
+      try {
+        const items = await m0_searchItems(query, mediatype, limit)
+        if (items.length === 0) return text(`Nothing in the Archive matches "${query}".`)
+        return text(
+          `Archive.org results for "${query}"${mediatype ? ` (${mediatype})` : ""}:\n\n` +
+            items.map((it, i) => m0_formatItem(it, i)).join("\n\n")
+        )
+      } catch (e) {
+        return textError(errorMessage(e))
+      }
+    }
+  )
+server.registerTool(
+    "get_item",
+    {
+      title: "Get item",
+      description: "Get full details + file manifest for an archive.org item.",
+      inputSchema: z.object(
+    { identifier: z.string().describe("Item identifier from search_items") }),
+      annotations: READ_ONLY,
+    },
+    async ({ identifier }) => {
+      try {
+        const d = await m0_getItemDetails(identifier)
+        const lines = [
+          d.title ?? d.identifier,
+          d.mediatype ? `Type: ${d.mediatype}` : "",
+          d.description ? d.description.slice(0, 400) : "",
+          `https://archive.org/details/${d.identifier}`,
+          "",
+          `Files (${d.files.length} shown):`,
+          ...d.files.map(
+            (f, i) =>
+              `${i + 1}. ${f.name}${f.format ? ` [${f.format}]` : ""}${f.size ? ` ${m0_fmtSize(f.size)}` : ""}${f.length ? ` (${f.length})` : ""}`
+          ),
+        ].filter(Boolean)
+        return text(lines.join("\n"))
+      } catch (e) {
+        return textError(errorMessage(e))
+      }
+    }
+  )
+server.registerTool(
+    "get_snapshots",
+    {
+      title: "Get snapshots",
+      description: "List the Wayback Machine snapshot history for a URL.",
+      inputSchema: z.object(
+    { url: z.string().describe("Full URL, e.g. 'example.com/page.html'"), limit: z.number().int().min(1).max(25).default(10) }),
+      annotations: READ_ONLY,
+    },
+    async ({ url, limit }) => {
+      try {
+        const snaps = await m1_getSnapshots(url, limit)
+        if (snaps.length === 0) return text(`No archived snapshots of ${url}.`)
+        return text(`Snapshots of ${url}:\n\n${snaps.map((s, i) => m1_formatSnapshot(s, i)).join("\n\n")}`)
+      } catch (e) {
+        return textError(errorMessage(e))
+      }
+    }
+  )
+server.registerTool(
+    "get_availability",
+    {
+      title: "Get availability",
+      description: "Check whether a page is archived and get its closest snapshot.",
+      inputSchema: z.object(
+    { url: z.string().describe("Full URL") }),
+      annotations: READ_ONLY,
+    },
+    async ({ url }) => {
+      try {
+        const snap = await m1_getAvailability(url)
+        if (!snap) return text(`No archived snapshot of ${url}.`)
+        return text(`Closest snapshot of ${url}:\n\n${m1_formatSnapshot(snap)}`)
+      } catch (e) {
+        return textError(errorMessage(e))
+      }
+    }
+  )
+server.registerTool(
+    "read_snapshot",
+    {
+      title: "Read snapshot",
+      description: "Read the text content of an archived page, for reading dead sites.",
+      inputSchema: z.object(
+    {
+      timestamp: z.string().describe("Snapshot timestamp from get_snapshots, e.g. '20240101120000'"),
+      url: z.string().describe("The original URL that was archived"),
+      maxChars: z.number().int().min(500).max(50000).default(15000),
+    }),
+      annotations: READ_ONLY,
+    },
+    async ({ timestamp, url, maxChars }) => {
+      try {
+        const content = await m1_getSnapshotText(timestamp, url, maxChars)
+        if (!content.trim()) return text(`Snapshot ${timestamp} of ${url} has no readable text.`)
+        return text(content)
+      } catch (e) {
+        return textError(errorMessage(e))
+      }
+    }
+  )
+  return server
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"]
+}