@thingd/sdk 0.72.0 → 0.74.2

package/dist/client/in-memory-thing-store.js

@@ -0,0 +1,292 @@
+const DEFAULT_LEASE_MS = 30_000;
+function uid() {
+    return typeof crypto !== "undefined" && typeof crypto.randomUUID === "function"
+        ? crypto.randomUUID()
+        : `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function now() {
+    return new Date().toISOString();
+}
+export class InMemoryThingStore {
+    objects = new Map();
+    events = new Map();
+    jobs = new Map();
+    links = new Map();
+    async put(collection, object) {
+        const key = `${collection}:${object.id}`;
+        const existing = this.objects.get(key);
+        const timestamp = now();
+        const stored = {
+            ...object,
+            id: object.id,
+            collection,
+            createdAt: existing?.data.createdAt ?? timestamp,
+            updatedAt: timestamp,
+            version: (existing?.data.version ?? 0) + 1,
+        };
+        this.objects.set(key, { collection, data: stored });
+        return stored;
+    }
+    async get(collection, id) {
+        const row = this.objects.get(`${collection}:${id}`);
+        return row ? row.data : null;
+    }
+    async getBatch(collection, ids) {
+        return Promise.all(ids.map((id) => this.get(collection, id)));
+    }
+    async delete(_collection, _id) {
+        const deleted = this.objects.delete(`${_collection}:${_id}`);
+        return { deleted };
+    }
+    async listObjects(collection, options) {
+        let items = Array.from(this.objects.values())
+            .filter((r) => r.collection === collection)
+            .map((r) => r.data);
+        if (options?.filter) {
+            const filter = options.filter;
+            items = items.filter((obj) => Object.entries(filter).every(([k, v]) => obj[k] === v));
+        }
+        if (options?.sortBy) {
+            const field = options.sortBy.field === "created_at"
+                ? "createdAt"
+                : options.sortBy.field === "updated_at"
+                    ? "updatedAt"
+                    : options.sortBy.field;
+            const dir = options.sortBy.direction === "desc" ? -1 : 1;
+            items.sort((a, b) => {
+                const va = a[field];
+                const vb = b[field];
+                if (va == null) {
+                    return 1;
+                }
+                if (vb == null) {
+                    return -1;
+                }
+                return va < vb ? -dir : va > vb ? dir : 0;
+            });
+        }
+        if (options?.offset) {
+            items = items.slice(options.offset);
+        }
+        if (options?.limit) {
+            items = items.slice(0, options.limit);
+        }
+        return items;
+    }
+    async appendEvent(stream, event) {
+        const streamEvents = this.events.get(stream) ?? [];
+        const sequence = streamEvents.length + 1;
+        const stored = {
+            ...event,
+            id: String(sequence),
+            stream,
+            sequence,
+            createdAt: now(),
+        };
+        streamEvents.push(stored);
+        this.events.set(stream, streamEvents);
+        return stored;
+    }
+    async listEvents(stream, options) {
+        let items;
+        if (stream) {
+            items = this.events.get(stream) ?? [];
+        }
+        else {
+            items = Array.from(this.events.values()).flat();
+        }
+        if (options?.fromSequence) {
+            items = items.filter((e) => e.sequence > (options.fromSequence ?? 0));
+        }
+        if (options?.since) {
+            const since = options.since;
+            items = items.filter((e) => e.createdAt >= since);
+        }
+        if (options?.limit) {
+            items = items.slice(0, options.limit);
+        }
+        return items;
+    }
+    async pushJob(queue, payload, options = {}) {
+        const timestamp = now();
+        const job = {
+            id: options.idempotencyKey ?? uid(),
+            queue,
+            payload,
+            status: "ready",
+            attempts: 0,
+            maxAttempts: options.maxAttempts ?? 3,
+            createdAt: timestamp,
+            availableAt: new Date(Date.now() + (options.delayMs ?? 0)).toISOString(),
+            priority: options.priority ?? 0,
+        };
+        const queueJobs = this.jobs.get(queue) ?? [];
+        queueJobs.push(job);
+        this.jobs.set(queue, queueJobs);
+        return job;
+    }
+    async claimJob(queue, options = {}) {
+        const queueJobs = this.jobs.get(queue);
+        if (!queueJobs) {
+            return null;
+        }
+        const now_ = new Date();
+        const ready = queueJobs.filter((c) => c.status === "ready" && c.availableAt <= now_.toISOString());
+        if (ready.length === 0) {
+            return null;
+        }
+        ready.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+        const job = ready[0];
+        job.status = "leased";
+        job.attempts += 1;
+        job.leasedAt = now_.toISOString();
+        job.leaseExpiresAt = new Date(now_.getTime() + (options.leaseMs ?? DEFAULT_LEASE_MS)).toISOString();
+        return job;
+    }
+    async ackJob(queue, jobId) {
+        const job = this.findJob(queue, jobId);
+        if (!job) {
+            return { ok: false, reason: "not_found" };
+        }
+        if (job.status !== "leased") {
+            return { ok: false, reason: "not_leased" };
+        }
+        job.status = "completed";
+        job.completedAt = now();
+        return { ok: true, job };
+    }
+    async nackJob(queue, jobId, options = {}) {
+        const job = this.findJob(queue, jobId);
+        if (!job) {
+            return { ok: false, reason: "not_found" };
+        }
+        if (job.status !== "leased") {
+            return { ok: false, reason: "not_leased" };
+        }
+        job.lastError = options.error;
+        if (job.attempts >= job.maxAttempts) {
+            job.status = "dead";
+            job.deadAt = now();
+        }
+        else {
+            job.status = "ready";
+            job.availableAt = new Date(Date.now() + (options.delayMs ?? 0)).toISOString();
+        }
+        return { ok: true, job };
+    }
+    async listJobs(queue) {
+        return this.jobs.get(queue) ?? [];
+    }
+    async listDeadJobs(queue) {
+        return (this.jobs.get(queue) ?? []).filter((j) => j.status === "dead");
+    }
+    async search(_query, _options = {}) {
+        return [];
+    }
+    async putBatch(collection, objects) {
+        return Promise.all(objects.map((obj) => this.put(collection, obj)));
+    }
+    async deleteBatch(collection, ids) {
+        let count = 0;
+        for (const id of ids) {
+            const result = await this.delete(collection, id);
+            if (result.deleted) {
+                count++;
+            }
+        }
+        return count;
+    }
+    async createLink(fromRef, linkType, toRef, weight, metadataJson) {
+        const link = {
+            id: uid(),
+            fromRef,
+            linkType,
+            toRef,
+            weight,
+            metadataJson: metadataJson ?? "{}",
+            createdAt: now(),
+        };
+        this.links.set(link.id, link);
+        return link;
+    }
+    async deleteLink(id) {
+        return this.links.delete(id);
+    }
+    async getLink(id) {
+        return this.links.get(id) ?? null;
+    }
+    async getNeighbors(reference, direction = "Both", options = {}) {
+        let items = Array.from(this.links.values()).filter((l) => {
+            if (direction === "Outgoing" || direction === "Both") {
+                if (l.fromRef === reference) {
+                    return true;
+                }
+            }
+            if (direction === "Incoming" || direction === "Both") {
+                if (l.toRef === reference) {
+                    return true;
+                }
+            }
+            return false;
+        });
+        if (options.linkType) {
+            items = items.filter((l) => l.linkType === options.linkType);
+        }
+        if (options.limit) {
+            items = items.slice(0, options.limit);
+        }
+        return items;
+    }
+    async countObjects() {
+        return this.objects.size;
+    }
+    async countObjectsInCollection(collection) {
+        let count = 0;
+        for (const [key] of this.objects) {
+            if (key.startsWith(`${collection}:`)) {
+                count++;
+            }
+        }
+        return count;
+    }
+    async countEvents() {
+        return Array.from(this.events.values()).reduce((acc, e) => acc + e.length, 0);
+    }
+    async countActiveJobs() {
+        let active = 0;
+        for (const jobs of this.jobs.values()) {
+            active += jobs.filter((j) => j.status === "ready" || j.status === "leased").length;
+        }
+        return active;
+    }
+    async countDeadJobs() {
+        let dead = 0;
+        for (const jobs of this.jobs.values()) {
+            dead += jobs.filter((j) => j.status === "dead").length;
+        }
+        return dead;
+    }
+    async countLinks() {
+        return this.links.size;
+    }
+    async listCollections() {
+        const collections = new Set(Array.from(this.objects.values()).map((r) => r.collection));
+        return Array.from(collections);
+    }
+    async listStreams() {
+        return Array.from(this.events.keys());
+    }
+    async listQueues() {
+        return Array.from(this.jobs.keys());
+    }
+    async createIndex(_collection, _field) {
+        // No-op for in-memory client store
+    }
+    async listIndexes() {
+        return [];
+    }
+    async close() { }
+    findJob(queue, jobId) {
+        return (this.jobs.get(queue) ?? []).find((j) => j.id === jobId);
+    }
+}

package/dist/client/index.d.ts

@@ -0,0 +1,5 @@
+export type { AggregateFunction, AggregateGroupResult, AggregateOptions, AggregateResult, BackupCapableThingStore, CollectionSchema, ConnectorAuth, ConnectorSchema, ConnectorSyncOptions, ConnectorSyncResult, FieldSchema, FilterOperator, Link, LinkDirection, LinkQueryOptions, ListEventsOptions, ListObjectsOptions, LocalThingDConnection, MemoryEvent, MemoryObject, MemoryQueue, MemorySearchOptions, MemorySearchResult, NlqIntent, NlqOptions, NlqResult, PutOptions, QueueClaimOptions, QueueJob, QueueJobOptions, QueueJobPayload, QueueJobResult, QueueJobStatus, QueueNackOptions, ReconnectableThingStore, SchemaOptions, SortBy, SortDirection, StoredMemoryEvent, StoredMemoryObject, ThingDConnection, ThingDeleteResult, ThingStore, TimeBucket, TimeSeriesBucket, TimeSeriesOptions, TimeSeriesResult, VectorSearchHit, VectorSearchOptions, WalCheckpointResult, } from "../types.js";
+export { HttpThingStore, type HttpThingStoreOptions } from "./http-thing-store.js";
+export { InMemoryThingStore } from "./in-memory-thing-store.js";
+export { openThingD, type ThingDClientOptions, } from "./thingd.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,uBAAuB,EACvB,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,oBAAoB,EACpB,mBAAmB,EACnB,WAAW,EACX,cAAc,EACd,IAAI,EACJ,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,WAAW,EACX,YAAY,EACZ,WAAW,EACX,mBAAmB,EACnB,kBAAkB,EAClB,SAAS,EACT,UAAU,EACV,SAAS,EACT,UAAU,EACV,iBAAiB,EACjB,QAAQ,EACR,eAAe,EACf,eAAe,EACf,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,uBAAuB,EACvB,aAAa,EACb,MAAM,EACN,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,cAAc,EAAE,KAAK,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EACL,UAAU,EACV,KAAK,mBAAmB,GACzB,MAAM,aAAa,CAAC"}

package/dist/client/index.js

@@ -0,0 +1,3 @@
+export { HttpThingStore } from "./http-thing-store.js";
+export { InMemoryThingStore } from "./in-memory-thing-store.js";
+export { openThingD, } from "./thingd.js";

package/dist/client/thingd.d.ts

@@ -0,0 +1,24 @@
+import { HttpThingStore } from "./http-thing-store.js";
+import { InMemoryThingStore } from "./in-memory-thing-store.js";
+export type { ThingDDriver, ThingDOpenConfig, ThingDOpenOptions, } from "../thingd.js";
+export type ThingDClientOptions = {
+    driver?: "memory" | "cloud";
+    url?: string;
+    authToken?: string;
+    apiKey?: string;
+};
+/**
+ * Open a thingd connection from a browser/edge-compatible environment.
+ *
+ * Unlike ThingD.open() from the main entry point, this does NOT read from
+ * process.env — all configuration must be passed explicitly.
+ *
+ * @example
+ * ```ts
+ * const db = await openThingD({ url: "http://localhost:8757" });
+ * await db.put("notes", { id: "1", text: "hello" });
+ * ```
+ */
+export declare function openThingD(options?: ThingDClientOptions): Promise<HttpThingStore | InMemoryThingStore>;
+export { HttpThingStore, InMemoryThingStore };
+//# sourceMappingURL=thingd.d.ts.map

package/dist/client/thingd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thingd.d.ts","sourceRoot":"","sources":["../../src/client/thingd.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAEhE,YAAY,EACV,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,cAAc,CAAC;AAEtB,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAMF;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAC9B,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,cAAc,GAAG,kBAAkB,CAAC,CAS9C;AAED,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/client/thingd.js

@@ -0,0 +1,27 @@
+import { HttpThingStore } from "./http-thing-store.js";
+import { InMemoryThingStore } from "./in-memory-thing-store.js";
+function resolveToken(options) {
+    return options.authToken ?? options.apiKey;
+}
+/**
+ * Open a thingd connection from a browser/edge-compatible environment.
+ *
+ * Unlike ThingD.open() from the main entry point, this does NOT read from
+ * process.env — all configuration must be passed explicitly.
+ *
+ * @example
+ * ```ts
+ * const db = await openThingD({ url: "http://localhost:8757" });
+ * await db.put("notes", { id: "1", text: "hello" });
+ * ```
+ */
+export async function openThingD(options = {}) {
+    if (options.driver === "memory" || !options.url) {
+        return new InMemoryThingStore();
+    }
+    return HttpThingStore.open({
+        url: options.url,
+        authToken: resolveToken(options),
+    });
+}
+export { HttpThingStore, InMemoryThingStore };

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+/** Number of tools registered by the TypeScript MCP server. Keep this derived
+ * from the registry in CI via scripts/check-docs.mjs. */
+export declare const MCP_TOOL_COUNT: 46;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;yDACyD;AACzD,eAAO,MAAM,cAAc,EAAG,EAAW,CAAC"}

package/dist/constants.js

@@ -0,0 +1,3 @@
+/** Number of tools registered by the TypeScript MCP server. Keep this derived
+ * from the registry in CI via scripts/check-docs.mjs. */
+export const MCP_TOOL_COUNT = 46;

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { MCP_TOOL_COUNT } from "./constants.js";
+export { appendMcpAuditEvent, createThingdMcpServer, jsonResult, parseCollectionAllowlist, parsePayloadSizeLimit, type RegisterThingdToolsOptions, readMcpHardeningOptionsFromEnv, registerThingdTools, resolveThingdMcpAuditOptions, type ThingdMcpAuditMetadata, type ThingdMcpAuditOptions, type ThingdMcpHardeningOptions, type ThingdMcpServerOptions, } from "./mcp/index.js";
+export { handleRestRequest, parseFilter, parseIntParam, parseSortBy, readBody, sendData, sendDataList, sendError, sendJson, } from "./rest/index.js";
+export { Scheduler } from "./scheduler.js";
+export type { CloudThingStoreOptions } from "./stores/cloud-thing-store.js";
+export { CloudThingStore } from "./stores/cloud-thing-store.js";
+export { InMemoryThingStore } from "./stores/in-memory-thing-store.js";
+export { NativeThingStore } from "./stores/native-thing-store.js";
+export type { ThingDDriver, ThingDOpenConfig, ThingDOpenOptions } from "./thingd.js";
+export { ThingD } from "./thingd.js";
+export type { AggregateFunction, AggregateGroupResult, AggregateOptions, AggregateResult, BackupCapableThingStore, CollectionSchema, ConnectorAuth, ConnectorSchema, ConnectorSyncOptions, ConnectorSyncResult, FieldSchema, FilterOperator, Link, LinkDirection, LinkQueryOptions, ListEventsOptions, ListObjectsOptions, LocalThingDConnection, MemoryEvent, MemoryObject, MemoryQueue, MemorySearchOptions, MemorySearchResult, NlqIntent, NlqOptions, NlqResult, PutOptions, QueueClaimOptions, QueueJob, QueueJobOptions, QueueJobPayload, QueueJobResult, QueueJobStatus, QueueNackOptions, ReconnectableThingStore, Schedule, ScheduleContext, ScheduleEvent, ScheduleHandler, ScheduleIntervalOptions, ScheduleOnceOptions, ScheduleOptions, SchedulerEventType, SchedulerFacade, SchedulerListener, SchedulerStats, SchemaOptions, SortBy, SortDirection, StoredMemoryEvent, StoredMemoryObject, ThingDConnection, ThingDeleteResult, ThingStore, TimeBucket, TimeSeriesBucket, TimeSeriesOptions, TimeSeriesResult, VectorSearchHit, VectorSearchOptions, WalCheckpointResult, } from "./types.js";
+export { SDK_VERSION } from "./version.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,UAAU,EACV,wBAAwB,EACxB,qBAAqB,EACrB,KAAK,0BAA0B,EAC/B,8BAA8B,EAC9B,mBAAmB,EACnB,4BAA4B,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,KAAK,sBAAsB,GAC5B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,iBAAiB,EACjB,WAAW,EACX,aAAa,EACb,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,QAAQ,GACT,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,YAAY,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrF,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,YAAY,EACV,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,uBAAuB,EACvB,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,oBAAoB,EACpB,mBAAmB,EACnB,WAAW,EACX,cAAc,EACd,IAAI,EACJ,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,WAAW,EACX,YAAY,EACZ,WAAW,EACX,mBAAmB,EACnB,kBAAkB,EAClB,SAAS,EACT,UAAU,EACV,SAAS,EACT,UAAU,EACV,iBAAiB,EACjB,QAAQ,EACR,eAAe,EACf,eAAe,EACf,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,uBAAuB,EACvB,QAAQ,EACR,eAAe,EACf,aAAa,EACb,eAAe,EACf,uBAAuB,EACvB,mBAAmB,EACnB,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,MAAM,EACN,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,11 @@
+// MCP server (tool handlers + factory)
+export { MCP_TOOL_COUNT } from "./constants.js";
+export { appendMcpAuditEvent, createThingdMcpServer, jsonResult, parseCollectionAllowlist, parsePayloadSizeLimit, readMcpHardeningOptionsFromEnv, registerThingdTools, resolveThingdMcpAuditOptions, } from "./mcp/index.js";
+// REST API (route handlers + helpers)
+export { handleRestRequest, parseFilter, parseIntParam, parseSortBy, readBody, sendData, sendDataList, sendError, sendJson, } from "./rest/index.js";
+export { Scheduler } from "./scheduler.js";
+export { CloudThingStore } from "./stores/cloud-thing-store.js";
+export { InMemoryThingStore } from "./stores/in-memory-thing-store.js";
+export { NativeThingStore } from "./stores/native-thing-store.js";
+export { ThingD } from "./thingd.js";
+export { SDK_VERSION } from "./version.js";

package/dist/mcp/audit.d.ts

@@ -0,0 +1,27 @@
+import type { ThingD } from "../thingd.js";
+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,cAAc,CAAC;AAG3C,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/config.d.ts

@@ -0,0 +1,22 @@
+export type ThingdMcpHardeningOptions = {
+    /** Comma-separated collection allowlist from THINGD_MCP_COLLECTIONS. Empty = all allowed. */
+    collectionAllowlist?: Set<string>;
+    /** When true, all write tools are rejected. Set via THINGD_MCP_READ_ONLY=true. */
+    readOnly?: boolean;
+    /** Maximum HTTP request body in bytes. Set via THINGD_MCP_MAX_PAYLOAD_BYTES. Default 512 KB. */
+    maxPayloadBytes?: number;
+};
+/**
+ * Parse THINGD_MCP_COLLECTIONS into a Set.
+ * An empty string or missing env var means all collections are allowed.
+ */
+export declare function parseCollectionAllowlist(value: string | undefined): Set<string> | undefined;
+/**
+ * Parse THINGD_MCP_MAX_PAYLOAD_BYTES. Defaults to 512 KB if unset or zero.
+ */
+export declare function parsePayloadSizeLimit(value: string | undefined, defaultBytes?: number): number;
+/**
+ * Read all MCP hardening options from the environment.
+ */
+export declare function readMcpHardeningOptionsFromEnv(env: Record<string, string | undefined>): ThingdMcpHardeningOptions;
+//# 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,MAAM,MAAM,yBAAyB,GAAG;IACtC,6FAA6F;IAC7F,mBAAmB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAClC,kFAAkF;IAClF,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gGAAgG;IAChG,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,SAAS,CAW3F;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,YAAY,SAAU,GAAG,MAAM,CAW/F;AAmBD;;GAEG;AACH,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GACtC,yBAAyB,CAQ3B"}

package/dist/mcp/config.js

@@ -0,0 +1,52 @@
+/**
+ * Parse THINGD_MCP_COLLECTIONS into a Set.
+ * An empty string or missing env var means all collections are allowed.
+ */
+export function parseCollectionAllowlist(value) {
+    if (!value?.trim()) {
+        return undefined;
+    }
+    const names = value
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    return names.length > 0 ? new Set(names) : undefined;
+}
+/**
+ * Parse THINGD_MCP_MAX_PAYLOAD_BYTES. Defaults to 512 KB if unset or zero.
+ */
+export function parsePayloadSizeLimit(value, defaultBytes = 524_288) {
+    if (!value) {
+        return defaultBytes;
+    }
+    const n = Number.parseInt(value, 10);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new Error(`Invalid THINGD_MCP_MAX_PAYLOAD_BYTES: ${value}`);
+    }
+    return n;
+}
+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`);
+}
+/**
+ * Read all MCP hardening options from the environment.
+ */
+export function readMcpHardeningOptionsFromEnv(env) {
+    return {
+        collectionAllowlist: parseCollectionAllowlist(env.THINGD_MCP_COLLECTIONS),
+        readOnly: env.THINGD_MCP_READ_ONLY
+            ? parseBooleanFlag(env.THINGD_MCP_READ_ONLY, "THINGD_MCP_READ_ONLY")
+            : undefined,
+        maxPayloadBytes: parsePayloadSizeLimit(env.THINGD_MCP_MAX_PAYLOAD_BYTES),
+    };
+}

package/dist/mcp/index.d.ts

@@ -0,0 +1,6 @@
+export { appendMcpAuditEvent, resolveThingdMcpAuditOptions, type ThingdMcpAuditMetadata, type ThingdMcpAuditOptions, } from "./audit.js";
+export { parseCollectionAllowlist, parsePayloadSizeLimit, readMcpHardeningOptionsFromEnv, type ThingdMcpHardeningOptions, } from "./config.js";
+export { jsonResult } from "./result.js";
+export { createThingdMcpServer, type ThingdMcpServerOptions } from "./server.js";
+export { type RegisterThingdToolsOptions, registerThingdTools } from "./tools.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,4BAA4B,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,GAC3B,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,wBAAwB,EACxB,qBAAqB,EACrB,8BAA8B,EAC9B,KAAK,yBAAyB,GAC/B,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,qBAAqB,EAAE,KAAK,sBAAsB,EAAE,MAAM,aAAa,CAAC;AACjF,OAAO,EAAE,KAAK,0BAA0B,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC"}

package/dist/mcp/index.js

@@ -0,0 +1,5 @@
+export { appendMcpAuditEvent, resolveThingdMcpAuditOptions, } from "./audit.js";
+export { parseCollectionAllowlist, parsePayloadSizeLimit, readMcpHardeningOptionsFromEnv, } from "./config.js";
+export { jsonResult } from "./result.js";
+export { createThingdMcpServer } from "./server.js";
+export { registerThingdTools } from "./tools.js";

package/dist/mcp/result.d.ts

@@ -0,0 +1,3 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export declare function jsonResult(value: unknown): CallToolResult;
+//# sourceMappingURL=result.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../src/mcp/result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEzE,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,CASzD"}

package/dist/mcp/result.js

@@ -0,0 +1,10 @@
+export function jsonResult(value) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(value, null, 2),
+            },
+        ],
+    };
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1,19 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ThingD } from "../thingd.js";
+import type { ThingdMcpAuditOptions } from "./audit.js";
+import type { ThingdMcpHardeningOptions } from "./config.js";
+export type ThingdMcpServerOptions = {
+    audit?: ThingdMcpAuditOptions | false;
+    hardening?: ThingdMcpHardeningOptions;
+};
+/**
+ * Create a new McpServer with all thingd tools registered.
+ *
+ * Note: a new instance must be created per HTTP request because
+ * @modelcontextprotocol/sdk's underlying Server.connect() throws if called
+ * on an already-connected instance (stateless HTTP mode: one transport per
+ * request lifecycle). Tool registration is cheap (Map insertions) so this
+ * is not a meaningful overhead in practice.
+ */
+export declare function createThingdMcpServer(db: ThingD, options?: ThingdMcpServerOptions): McpServer;
+//# sourceMappingURL=server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACxD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAG7D,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,CAAC,EAAE,qBAAqB,GAAG,KAAK,CAAC;IACtC,SAAS,CAAC,EAAE,yBAAyB,CAAC;CACvC,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,sBAA2B,GAAG,SAAS,CAwDjG"}