@thingd/cli 0.31.0

package/dist/logo.d.ts

@@ -0,0 +1,3 @@
+export declare function logoText(): string;
+export declare function logoLine(): string;
+//# sourceMappingURL=logo.d.ts.map

package/dist/logo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logo.d.ts","sourceRoot":"","sources":["../src/logo.ts"],"names":[],"mappings":"AAGA,wBAAgB,QAAQ,IAAI,MAAM,CAEjC;AAED,wBAAgB,QAAQ,IAAI,MAAM,CAEjC"}

package/dist/logo.js

@@ -0,0 +1,8 @@
+const orange = (s) => `\x1b[38;2;224;83;22m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[38;2;0;196;212m${s}\x1b[0m`;
+export function logoText() {
+    return `${orange("{")}${cyan("t")}${cyan("h")}${cyan("i")}${cyan("n")}${cyan("g")}${orange(":")}${orange("d")}${orange("}")}`;
+}
+export function logoLine() {
+    return `${logoText()}\n`;
+}

package/dist/mcp/audit.d.ts

@@ -0,0 +1,27 @@
+import type { ThingD } from "thingd";
+export type ThingdMcpAuditOptions = {
+    enabled?: boolean;
+    actor?: string;
+    source?: string;
+    stream?: string;
+};
+export type ThingdMcpAuditMetadata = {
+    actor?: string;
+    source?: string;
+};
+type ResolvedThingdMcpAuditOptions = {
+    enabled: boolean;
+    actor: string;
+    source: string;
+    stream: string;
+};
+type ThingdMcpAuditEventOptions = {
+    action: string;
+    target: Record<string, unknown>;
+    metadata?: ThingdMcpAuditMetadata;
+    result?: Record<string, unknown>;
+};
+export declare function resolveThingdMcpAuditOptions(options: ThingdMcpAuditOptions | false | undefined): ResolvedThingdMcpAuditOptions;
+export declare function appendMcpAuditEvent(db: ThingD, options: ResolvedThingdMcpAuditOptions, event: ThingdMcpAuditEventOptions): Promise<void>;
+export {};
+//# sourceMappingURL=audit.d.ts.map

package/dist/mcp/audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.d.ts","sourceRoot":"","sources":["../../src/mcp/audit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,MAAM,EAAE,MAAM,QAAQ,CAAC;AAElD,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,KAAK,6BAA6B,GAAG;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,QAAQ,CAAC,EAAE,sBAAsB,CAAC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC,CAAC;AAMF,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,qBAAqB,GAAG,KAAK,GAAG,SAAS,GACjD,6BAA6B,CAgB/B;AAED,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,6BAA6B,EACtC,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,IAAI,CAAC,CAkBf"}

package/dist/mcp/audit.js

@@ -0,0 +1,36 @@
+const DEFAULT_AUDIT_STREAM = "__thingd:mcp:audit";
+const DEFAULT_AUDIT_ACTOR = "mcp-client";
+const DEFAULT_AUDIT_SOURCE = "thingd-mcp";
+export function resolveThingdMcpAuditOptions(options) {
+    if (options === false || options?.enabled === false) {
+        return {
+            enabled: false,
+            actor: DEFAULT_AUDIT_ACTOR,
+            source: DEFAULT_AUDIT_SOURCE,
+            stream: DEFAULT_AUDIT_STREAM,
+        };
+    }
+    return {
+        enabled: true,
+        actor: options?.actor ?? DEFAULT_AUDIT_ACTOR,
+        source: options?.source ?? DEFAULT_AUDIT_SOURCE,
+        stream: options?.stream ?? DEFAULT_AUDIT_STREAM,
+    };
+}
+export async function appendMcpAuditEvent(db, options, event) {
+    if (!options.enabled) {
+        return;
+    }
+    const actor = event.metadata?.actor ?? options.actor;
+    const source = event.metadata?.source ?? options.source;
+    const auditEvent = {
+        type: `mcp.${event.action}`,
+        text: `MCP ${event.action} by ${actor}`,
+        actor,
+        source,
+        target: event.target,
+        result: event.result,
+        at: new Date().toISOString(),
+    };
+    await db.events.append(options.stream, auditEvent);
+}

package/dist/mcp/cluster.d.ts

@@ -0,0 +1,68 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { ThingD } from "@thingd/node";
+export type ThingdClusterMode = "single" | "leader" | "follower";
+export type ThingdClusterDiscovery = "none" | "static" | "kubernetes";
+export type ThingdClusterOptions = {
+    mode?: ThingdClusterMode;
+    advertiseUrl?: string;
+    leaderUrl?: string;
+    fallbackLeaderUrl?: string;
+    peers?: string[];
+    discovery?: ThingdClusterDiscovery;
+    service?: string;
+    namespace?: string;
+    port?: number;
+    forwardAuthToken?: string;
+    statusPath?: string;
+    peersPath?: string;
+    /** Enable automatic leader failover. Default: false. */
+    leaderElection?: boolean;
+    /** Consecutive replication failures before triggering election. Default: 3. */
+    electionMaxFailures?: number;
+};
+export type ResolvedThingdClusterOptions = {
+    mode: ThingdClusterMode;
+    advertiseUrl?: string;
+    leaderUrl?: string;
+    fallbackLeaderUrl?: string;
+    activeLeaderUrl?: string;
+    peers: string[];
+    discovery: ThingdClusterDiscovery;
+    service?: string;
+    namespace?: string;
+    port: number;
+    forwardAuthToken?: string;
+    statusPath: string;
+    peersPath: string;
+    leaderElection: boolean;
+    electionMaxFailures: number;
+    /** Cached replication lag (events behind leader). Updated by the replication runner. */
+    cachedReplicationLag: number;
+};
+export type ThingdClusterStatus = {
+    mode: ThingdClusterMode;
+    writable: boolean;
+    forwarding: boolean;
+    leaderUrl?: string;
+    fallbackLeaderUrl?: string;
+    activeLeaderUrl?: string;
+    advertiseUrl?: string;
+    discovery: ThingdClusterDiscovery;
+    peers: string[];
+    leaderElection: boolean;
+    electionMaxFailures: number;
+    replication: {
+        lastReplicatedSequence: number;
+        status: string;
+        lag?: number;
+    } | "not-implemented";
+};
+export declare function readClusterOptionsFromEnv(env: Record<string, string | undefined>): ThingdClusterOptions;
+export declare function resolveClusterOptions(options: ThingdClusterOptions | undefined): ResolvedThingdClusterOptions;
+export declare function getClusterStatus(cluster: ResolvedThingdClusterOptions, db: ThingD): Promise<ThingdClusterStatus>;
+export declare function forwardMcpRequestToLeader(cluster: ResolvedThingdClusterOptions, mcpPath: string, request: IncomingMessage, response: ServerResponse): Promise<void>;
+export declare function findNextLeaderCandidate(cluster: ResolvedThingdClusterOptions): {
+    url: string;
+    isSelf: boolean;
+} | undefined;
+//# sourceMappingURL=cluster.d.ts.map

package/dist/mcp/cluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cluster.d.ts","sourceRoot":"","sources":["../../src/mcp/cluster.ts"],"names":[],"mappings":"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"}

package/dist/mcp/cluster.js

@@ -0,0 +1,303 @@
+import { parseBooleanFlag, parsePort } from "./config.js";
+const DEFAULT_CLUSTER_PORT = 8757;
+export function readClusterOptionsFromEnv(env) {
+    return {
+        mode: parseClusterMode(env.THINGD_CLUSTER_MODE),
+        advertiseUrl: env.THINGD_ADVERTISE_URL,
+        leaderUrl: env.THINGD_CLUSTER_LEADER_URL,
+        fallbackLeaderUrl: env.THINGD_CLUSTER_LEADER_FALLBACK_URL,
+        peers: parsePeers(env.THINGD_CLUSTER_PEERS),
+        discovery: parseClusterDiscovery(env.THINGD_CLUSTER_DISCOVERY),
+        service: env.THINGD_CLUSTER_SERVICE,
+        namespace: env.THINGD_CLUSTER_NAMESPACE,
+        port: parsePort(env.THINGD_CLUSTER_PORT, DEFAULT_CLUSTER_PORT),
+        forwardAuthToken: env.THINGD_CLUSTER_FORWARD_AUTH_TOKEN ?? env.THINGD_AUTH_TOKEN,
+        leaderElection: parseBooleanFlag(env.THINGD_CLUSTER_LEADER_ELECTION, "THINGD_CLUSTER_LEADER_ELECTION"),
+        electionMaxFailures: parsePositiveInt(env.THINGD_CLUSTER_LEADER_ELECTION_MAX_FAILURES, 3),
+    };
+}
+export function resolveClusterOptions(options) {
+    const mode = options?.mode ?? "single";
+    const discovery = options?.discovery ?? (options?.peers?.length ? "static" : "none");
+    const port = options?.port ?? DEFAULT_CLUSTER_PORT;
+    const peers = resolvePeers({
+        discovery,
+        peers: options?.peers ?? [],
+        service: options?.service,
+        namespace: options?.namespace,
+        port,
+    });
+    const leaderElection = options?.leaderElection ?? false;
+    const electionMaxFailures = options?.electionMaxFailures ?? 3;
+    // When leader election is enabled, derive leaderUrl from peer list if not explicitly set.
+    if (mode === "follower" && !options?.leaderUrl && leaderElection && peers.length > 0) {
+        options = { ...options, leaderUrl: peers[0] };
+    }
+    if (mode === "follower" && !options?.leaderUrl) {
+        throw new Error("THINGD_CLUSTER_LEADER_URL is required when THINGD_CLUSTER_MODE=follower");
+    }
+    return {
+        mode,
+        advertiseUrl: options?.advertiseUrl,
+        leaderUrl: options?.leaderUrl,
+        fallbackLeaderUrl: options?.fallbackLeaderUrl,
+        activeLeaderUrl: undefined,
+        peers,
+        discovery,
+        service: options?.service,
+        namespace: options?.namespace,
+        port,
+        forwardAuthToken: options?.forwardAuthToken,
+        statusPath: options?.statusPath ?? "/cluster/status",
+        peersPath: options?.peersPath ?? "/cluster/peers",
+        leaderElection,
+        electionMaxFailures,
+        cachedReplicationLag: 0,
+    };
+}
+export async function getClusterStatus(cluster, db) {
+    let replication = "not-implemented";
+    if (cluster.mode === "follower") {
+        try {
+            const status = await db.get("__thingd_meta", "replication_status");
+            const lastSeq = status && typeof status.lastReplicatedSequence === "number"
+                ? status.lastReplicatedSequence
+                : 0;
+            // Lag is updated asynchronously by the replication runner — read cached value
+            // to avoid a synchronous outbound HTTP call on every /healthz request.
+            replication = {
+                lastReplicatedSequence: lastSeq,
+                status: "syncing",
+                lag: cluster.cachedReplicationLag,
+            };
+        }
+        catch {
+            replication = { lastReplicatedSequence: 0, status: "error" };
+        }
+    }
+    else if (cluster.mode === "leader" || cluster.mode === "single") {
+        try {
+            const list = await db.events.list("__thingd:system:replication");
+            const lastEvent = list[list.length - 1];
+            const lastSeq = lastEvent ? Number.parseInt(lastEvent.id, 10) : 0;
+            replication = {
+                lastReplicatedSequence: lastSeq,
+                status: "active",
+            };
+        }
+        catch {
+            replication = { lastReplicatedSequence: 0, status: "error" };
+        }
+    }
+    return {
+        mode: cluster.mode,
+        writable: cluster.mode !== "follower",
+        forwarding: cluster.mode === "follower",
+        leaderUrl: cluster.leaderUrl,
+        fallbackLeaderUrl: cluster.fallbackLeaderUrl,
+        activeLeaderUrl: cluster.activeLeaderUrl,
+        advertiseUrl: cluster.advertiseUrl,
+        discovery: cluster.discovery,
+        peers: cluster.peers,
+        leaderElection: cluster.leaderElection,
+        electionMaxFailures: cluster.electionMaxFailures,
+        replication,
+    };
+}
+export async function forwardMcpRequestToLeader(cluster, mcpPath, request, response) {
+    if (!cluster.leaderUrl) {
+        writeForwardError(response, 503, "cluster_leader_unavailable");
+        return;
+    }
+    const body = await readRequestBody(request);
+    const urls = cluster.fallbackLeaderUrl
+        ? [cluster.leaderUrl, cluster.fallbackLeaderUrl]
+        : [cluster.leaderUrl];
+    let lastError;
+    for (const url of urls) {
+        try {
+            const upstreamUrl = leaderMcpUrl(url, mcpPath);
+            const upstream = await fetch(upstreamUrl, {
+                method: "POST",
+                headers: forwardedHeaders(request, cluster.forwardAuthToken),
+                body: new Uint8Array(body),
+                signal: AbortSignal.timeout(30_000),
+            });
+            cluster.activeLeaderUrl = url;
+            response.writeHead(upstream.status, responseHeaders(upstream.headers));
+            response.end(Buffer.from(await upstream.arrayBuffer()));
+            return;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            console.error(`Forward to leader ${url} failed:`, lastError.message);
+        }
+    }
+    if (lastError) {
+        console.error("All leader URLs exhausted for forward, last error:", lastError.message);
+    }
+    writeForwardError(response, 503, "cluster_leader_unavailable");
+}
+export function findNextLeaderCandidate(cluster) {
+    const { advertiseUrl, peers } = cluster;
+    const currentLeaderUrl = cluster.activeLeaderUrl ?? cluster.leaderUrl;
+    if (!currentLeaderUrl || peers.length === 0) {
+        return undefined;
+    }
+    const leaderIndex = findPeerIndex(peers, currentLeaderUrl);
+    if (leaderIndex === -1) {
+        return undefined;
+    }
+    // Scan from the next peer after the current leader.
+    for (let i = leaderIndex + 1; i < peers.length; i++) {
+        const candidate = peers[i];
+        if (candidate) {
+            const isSelf = typeof advertiseUrl === "string" && sameOrigin(advertiseUrl, candidate);
+            return { url: candidate, isSelf };
+        }
+    }
+    // Wrap around — all peers after leader's index exhausted, try from the beginning.
+    for (let i = 0; i < leaderIndex; i++) {
+        const candidate = peers[i];
+        if (candidate) {
+            const isSelf = typeof advertiseUrl === "string" && sameOrigin(advertiseUrl, candidate);
+            return { url: candidate, isSelf };
+        }
+    }
+    return undefined;
+}
+function findPeerIndex(peers, targetUrl) {
+    return peers.findIndex((peer) => sameOrigin(peer, targetUrl));
+}
+/** Compare two URLs by origin (scheme + host + port). */
+function sameOrigin(a, b) {
+    try {
+        return new URL(a).origin === new URL(b).origin;
+    }
+    catch {
+        return a === b;
+    }
+}
+function parsePositiveInt(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const n = Number.parseInt(value, 10);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new Error(`Invalid positive integer: ${value}`);
+    }
+    return n;
+}
+function parseClusterMode(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (value === "single" || value === "leader" || value === "follower") {
+        return value;
+    }
+    throw new Error(`Unsupported THINGD_CLUSTER_MODE: ${value}`);
+}
+function parseClusterDiscovery(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (value === "none" || value === "static" || value === "kubernetes") {
+        return value;
+    }
+    throw new Error(`Unsupported THINGD_CLUSTER_DISCOVERY: ${value}`);
+}
+function parsePeers(value) {
+    if (!value) {
+        return undefined;
+    }
+    return value
+        .split(",")
+        .map((peer) => peer.trim())
+        .filter(Boolean);
+}
+function resolvePeers(options) {
+    if (options.discovery === "static") {
+        return options.peers;
+    }
+    if (options.discovery !== "kubernetes" || !options.service) {
+        return [];
+    }
+    const namespace = options.namespace ?? "default";
+    return [`http://${options.service}.${namespace}.svc.cluster.local:${options.port}`];
+}
+function leaderMcpUrl(leaderUrl, mcpPath) {
+    const url = new URL(leaderUrl);
+    if (url.pathname === "/" || url.pathname === "") {
+        url.pathname = mcpPath;
+    }
+    return url.toString();
+}
+function forwardedHeaders(request, forwardAuthToken) {
+    const headers = new Headers();
+    const contentType = request.headers["content-type"];
+    const protocolVersion = request.headers["mcp-protocol-version"];
+    const accept = request.headers.accept;
+    if (typeof contentType === "string") {
+        headers.set("Content-Type", contentType);
+    }
+    if (typeof accept === "string") {
+        headers.set("Accept", accept);
+    }
+    if (typeof protocolVersion === "string") {
+        headers.set("MCP-Protocol-Version", protocolVersion);
+    }
+    if (forwardAuthToken) {
+        headers.set("Authorization", `Bearer ${forwardAuthToken}`);
+    }
+    else if (typeof request.headers.authorization === "string") {
+        headers.set("Authorization", request.headers.authorization);
+    }
+    return headers;
+}
+function responseHeaders(headers) {
+    const result = {};
+    for (const [key, value] of headers) {
+        if (!isHopByHopHeader(key)) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function isHopByHopHeader(header) {
+    return [
+        "connection",
+        "content-length",
+        "keep-alive",
+        "proxy-authenticate",
+        "proxy-authorization",
+        "te",
+        "trailer",
+        "transfer-encoding",
+        "upgrade",
+    ].includes(header.toLowerCase());
+}
+function readRequestBody(request) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        request.on("data", (chunk) => {
+            chunks.push(chunk);
+        });
+        request.on("end", () => {
+            resolve(Buffer.concat(chunks));
+        });
+        request.on("error", reject);
+    });
+}
+function writeForwardError(response, statusCode, error) {
+    response.writeHead(statusCode, {
+        "Content-Type": "application/json",
+    });
+    response.end(JSON.stringify({
+        jsonrpc: "2.0",
+        error: {
+            code: -32_603,
+            message: error,
+        },
+        id: null,
+    }));
+}

package/dist/mcp/config.d.ts

@@ -0,0 +1,14 @@
+import type { ThingDDriver, ThingdMcpAuditOptions } from "@thingd/node";
+export type ThingDStorageDriver = Exclude<ThingDDriver, "remote">;
+export type HttpRuntimeSafetyOptions = {
+    host: string;
+    authToken?: string;
+    allowUnauthenticated?: boolean;
+};
+export declare function parseThingdDriver(value: string | undefined): ThingDStorageDriver | undefined;
+export declare function parsePort(value: string | undefined, fallback: number): number;
+export declare function parseBooleanFlag(value: string | undefined, name: string): boolean;
+export declare function readMcpAuditOptionsFromEnv(env: Record<string, string | undefined>): ThingdMcpAuditOptions | false;
+export declare function readCliValue(args: string[], index: number, name: string): string;
+export declare function ensureHttpRuntimeIsSafe(options: HttpRuntimeSafetyOptions): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/mcp/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/mcp/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAExE,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;AAElE,MAAM,MAAM,wBAAwB,GAAG;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,mBAAmB,GAAG,SAAS,CAU5F;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAY7E;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAejF;AAED,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GACtC,qBAAqB,GAAG,KAAK,CAgB/B;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAQhF;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI,CAU/E"}

package/dist/mcp/config.js

@@ -0,0 +1,67 @@
+export function parseThingdDriver(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (value === "memory" || value === "native") {
+        return value;
+    }
+    throw new Error(`Unsupported thingd driver: ${value}`);
+}
+export function parsePort(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const port = Number.parseInt(value, 10);
+    if (!Number.isInteger(port) || port < 0 || port > 65_535) {
+        throw new Error(`Invalid port: ${value}`);
+    }
+    return port;
+}
+export function parseBooleanFlag(value, name) {
+    if (!value) {
+        return false;
+    }
+    const normalized = value.toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(normalized)) {
+        return false;
+    }
+    throw new Error(`Invalid ${name}: expected true or false`);
+}
+export function readMcpAuditOptionsFromEnv(env) {
+    const enabled = env.THINGD_MCP_AUDIT === undefined
+        ? undefined
+        : parseBooleanFlag(env.THINGD_MCP_AUDIT, "THINGD_MCP_AUDIT");
+    if (enabled === false) {
+        return false;
+    }
+    return {
+        enabled,
+        actor: env.THINGD_MCP_ACTOR,
+        source: env.THINGD_MCP_SOURCE,
+        stream: env.THINGD_MCP_AUDIT_STREAM,
+    };
+}
+export function readCliValue(args, index, name) {
+    const value = args[index + 1];
+    if (!value) {
+        throw new Error(`${name} requires a value`);
+    }
+    return value;
+}
+export function ensureHttpRuntimeIsSafe(options) {
+    const authToken = options.authToken?.trim();
+    if (authToken || options.allowUnauthenticated || isLoopbackHost(options.host)) {
+        return;
+    }
+    throw new Error("THINGD_AUTH_TOKEN is required when the HTTP MCP runtime binds to a non-loopback host. Set THINGD_AUTH_TOKEN or THINGD_ALLOW_UNAUTHENTICATED=true for local-only experiments.");
+}
+function isLoopbackHost(host) {
+    const normalized = host.toLowerCase();
+    return (normalized === "localhost" ||
+        normalized === "127.0.0.1" ||
+        normalized === "::1" ||
+        normalized === "[::1]");
+}

package/dist/mcp/http.d.ts

@@ -0,0 +1,25 @@
+import { type Server } from "node:http";
+import { type ThingdMcpAuditOptions, type ThingdMcpHardeningOptions } from "@thingd/node";
+import { type ThingdClusterOptions } from "./cluster.js";
+import { type ThingDStorageDriver } from "./config.js";
+export type ThingdHttpServerOptions = {
+    path: string;
+    driver?: ThingDStorageDriver;
+    host?: string;
+    port?: number;
+    authToken?: string;
+    allowUnauthenticated?: boolean;
+    audit?: ThingdMcpAuditOptions | false;
+    cluster?: ThingdClusterOptions;
+    mcpPath?: string;
+    healthPath?: string;
+    hardening?: ThingdMcpHardeningOptions;
+};
+export type RunningThingdHttpServer = {
+    server: Server;
+    url: string;
+    mcpUrl: string;
+    close(): Promise<void>;
+};
+export declare function startThingdHttpServer(options: ThingdHttpServerOptions): Promise<RunningThingdHttpServer>;
+//# sourceMappingURL=http.d.ts.map

package/dist/mcp/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/mcp/http.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsC,KAAK,MAAM,EAAuB,MAAM,WAAW,CAAC;AAGjG,OAAO,EAKL,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC/B,MAAM,cAAc,CAAC;AACtB,OAAO,EAML,KAAK,oBAAoB,EAC1B,MAAM,cAAc,CAAC;AACtB,OAAO,EAA2B,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEhF,MAAM,MAAM,uBAAuB,GAAG;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,KAAK,CAAC,EAAE,qBAAqB,GAAG,KAAK,CAAC;IACtC,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,yBAAyB,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB,CAAC;AAkBF,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,uBAAuB,CAAC,CAqDlC"}