101 lines
6.3 KiB
Swift
101 lines
6.3 KiB
Swift
// 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<sockaddr_in>.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<sockaddr_in>.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)
|
|
}
|
|
}
|