// SPDX-License-Identifier: GPL-3.0-or-later import Darwin import SQLite3 import XCTest @MainActor final class MCPArchiveAccessTests: XCTestCase { private let digest = String(repeating: "a", count: 64) private func index(at url: URL) throws { var db: OpaquePointer? guard sqlite3_open(url.path, &db) == SQLITE_OK else { throw POSIXError(.EIO) } defer { sqlite3_close(db) } let sql = """ PRAGMA application_id=0x56434341; PRAGMA user_version=1; CREATE TABLE document(id INTEGER PRIMARY KEY,sha256 TEXT,title TEXT,collection TEXT,source_url TEXT,member_path TEXT,delivery_url TEXT,byte_size INTEGER,page_count INTEGER,issue_year INTEGER); CREATE TABLE page(id INTEGER PRIMARY KEY,document_id INTEGER,page_number INTEGER,page_label TEXT,locator_kind TEXT,is_ocr INTEGER); CREATE VIRTUAL TABLE page_terms USING fts5(terms,title_terms,content='',detail=none,columnsize=0); INSERT INTO document VALUES(1,'\(digest)','Guide','Books','https://colorcomputerarchive.com/repo/Documents/Books/Guides.zip','Guide.pdf','https://delivery.invalid/Guide.pdf',12,20,NULL); INSERT INTO page VALUES(1,1,17,NULL,'pdf_page',1),(2,1,18,NULL,'pdf_page',0); INSERT INTO page_terms(rowid,terms,title_terms) VALUES(1,'joystk','guide'),(2,'joystk','guide'); """ guard sqlite3_exec(db, sql, nil, nil, nil) == SQLITE_OK else { throw POSIXError(.EINVAL) } } /// Exercise the host boundary directly. A caller can bypass the helper's advertised tool list. private func request(_ tool: String, _ arguments: [String: Any], using grant: [String: Any]) async throws -> [String: Any] { let token = try XCTUnwrap(grant["token"] as? String) let port = try XCTUnwrap(grant["port"] as? UInt16) let request = try JSONSerialization.data(withJSONObject: ["version": 1, "tool": tool, "arguments": arguments, "token": token]) + Data([10]) let response = try await Task.detached { let fd = socket(AF_INET, SOCK_STREAM, 0) guard fd >= 0 else { throw POSIXError(.ENOTSOCK) } let handle = FileHandle(fileDescriptor: fd, closeOnDealloc: true) defer { try? handle.close() } var timeout = timeval(tv_sec: 5, tv_usec: 0) guard setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, socklen_t(MemoryLayout.size(ofValue: timeout))) == 0 else { throw POSIXError(.ETIMEDOUT) } var peer = sockaddr_in() peer.sin_family = sa_family_t(AF_INET) peer.sin_len = UInt8(MemoryLayout.size) peer.sin_addr.s_addr = inet_addr("127.0.0.1") peer.sin_port = port.bigEndian let result = withUnsafePointer(to: &peer) { $0.withMemoryRebound(to: sockaddr.self, capacity: 1) { Darwin.connect(fd, $0, socklen_t(MemoryLayout.size)) } } guard result == 0 else { throw POSIXError(.ECONNREFUSED) } try handle.write(contentsOf: request) return try handle.readToEnd() ?? Data() }.value return try XCTUnwrap(JSONSerialization.jsonObject(with: response) as? [String: Any]) } func testSearchOnlyGrantMatchesNativeAndRejectsBroaderAccess() async throws { let base = FileManager.default.temporaryDirectory.appendingPathComponent("archive-mcp-" + UUID().uuidString) try FileManager.default.createDirectory(at: base, withIntermediateDirectories: true) defer { try? FileManager.default.removeItem(at: base) } let db = base.appendingPathComponent("ArchiveLibrary.sqlite") try index(at: db) let catalog = ArchiveLibraryCatalog(url: db), access = MCPArchiveAccess(catalog: catalog) let grantFile = base.appendingPathComponent("grant.json") try await access.connect(at: grantFile) defer { access.revoke() } let raw = try Data(contentsOf: grantFile) var grant = try XCTUnwrap(JSONSerialization.jsonObject(with: raw) as? [String: Any]) XCTAssertEqual(grant["kind"] as? String, "archive") XCTAssertEqual(grant["version"] as? Int, 2) let native = try await catalog.search(query: "JOYSTK", collection: "Books", limit: 1, offset: 0) let expected = try XCTUnwrap(native.first) let reply = try await request("search_archive", ["query": "JOYSTK", "category": "Books", "limit": 1], using: grant) let first = try XCTUnwrap(reply["result"] as? [String: Any]) let result = try XCTUnwrap((first["results"] as? [[String: Any]])?.first) XCTAssertEqual(first["next_offset"] as? Int, 1) XCTAssertEqual(result["citation_id"] as? String, expected.id) XCTAssertEqual(result["source_url"] as? String, expected.sourceURL.absoluteString) XCTAssertEqual(result["member_path"] as? String, "Guide.pdf") XCTAssertEqual(result["pdf_page"] as? Int, expected.page) XCTAssertFalse(String(describing: result).contains("delivery.invalid")) let lookup = try await request("get_archive_citation", ["citation_id": expected.id], using: grant) XCTAssertEqual(lookup["result"] as? NSDictionary, result as NSDictionary) let next = try await request("search_archive", ["query": "JOYSTK", "offset": 1], using: grant) let page2 = (next["result"] as? [String: Any])?["results"] as? [[String: Any]] XCTAssertNotEqual(page2?.first?["citation_id"] as? String, expected.id) XCTAssertEqual(page2?.count, 1) let unsupported = try await request("read_source", ["document_id": "secret"], using: grant) XCTAssertEqual(unsupported["error"] as? String, "access_denied") let missing = try await request("get_archive_citation", ["citation_id": "private-id"], using: grant) XCTAssertEqual(missing["error"] as? String, "citation_unavailable") let badLimit = try await request("search_archive", ["query": "JOYSTK", "limit": true], using: grant) XCTAssertEqual(badLimit["error"] as? String, "invalid_arguments") grant["token"] = "wrong" let denied = try await request("search_archive", ["query": "JOYSTK"], using: grant) XCTAssertEqual(denied["error"] as? String, "access_denied") await access.revoke().value XCTAssertFalse(FileManager.default.fileExists(atPath: grantFile.path)) XCTAssertNil(access.grantFile) } }