@thingd/sdk 0.31.0

package/dist/stores/cloud-thing-store.js

@@ -0,0 +1,243 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { SDK_VERSION } from "../version.js";
+export class CloudThingStore {
+    client;
+    connectOptions;
+    static async open(urlOrOptions) {
+        const options = typeof urlOrOptions === "string"
+            ? {
+                url: urlOrOptions,
+            }
+            : urlOrOptions;
+        const client = new Client({
+            name: options.clientName ?? "thingd-node-sdk",
+            version: options.clientVersion ?? SDK_VERSION,
+        });
+        const transport = new StreamableHTTPClientTransport(new URL(resolveMcpUrl(options.url)), {
+            requestInit: options.authToken
+                ? {
+                    headers: {
+                        Authorization: `Bearer ${options.authToken}`,
+                    },
+                }
+                : undefined,
+        });
+        await client.connect(transport);
+        return new CloudThingStore(client, options);
+    }
+    constructor(client, connectOptions) {
+        this.client = client;
+        this.connectOptions = connectOptions;
+    }
+    /**
+     * Explicitly reconnect the transport — useful if you detect the connection
+     * has dropped and want to recover without recreating the store.
+     */
+    async reconnect() {
+        try {
+            await this.client.close();
+        }
+        catch {
+            // ignore close errors
+        }
+        const client = new Client({
+            name: this.connectOptions.clientName ?? "thingd-node-sdk",
+            version: this.connectOptions.clientVersion ?? SDK_VERSION,
+        });
+        const transport = new StreamableHTTPClientTransport(new URL(resolveMcpUrl(this.connectOptions.url)), {
+            requestInit: this.connectOptions.authToken
+                ? { headers: { Authorization: `Bearer ${this.connectOptions.authToken}` } }
+                : undefined,
+        });
+        await client.connect(transport);
+        this.client = client;
+    }
+    put(collection, object) {
+        return this.callTool("thing_put", {
+            collection,
+            object,
+        });
+    }
+    get(collection, id) {
+        return this.callTool("thing_get", {
+            collection,
+            id,
+        });
+    }
+    delete(collection, id) {
+        return this.callTool("thing_delete", {
+            collection,
+            id,
+        });
+    }
+    listObjects(collection, options) {
+        const params = { collection };
+        if (options?.filter) {
+            params.filter = options.filter;
+        }
+        if (options?.limit) {
+            params.limit = options.limit;
+        }
+        if (options?.offset) {
+            params.offset = options.offset;
+        }
+        return this.callTool("thing_objects_list", params);
+    }
+    appendEvent(stream, event) {
+        return this.callTool("thing_events_append", {
+            stream,
+            event,
+        });
+    }
+    listEvents(stream, options) {
+        const params = {};
+        if (stream) {
+            params.stream = stream;
+        }
+        if (options?.fromSequence) {
+            params.fromSequence = options.fromSequence;
+        }
+        if (options?.limit) {
+            params.limit = options.limit;
+        }
+        return this.callTool("thing_events_list", params);
+    }
+    pushJob(queue, payload, options = {}) {
+        return this.callTool("thing_queue_push", {
+            queue,
+            payload,
+            idempotencyKey: options.idempotencyKey,
+            maxAttempts: options.maxAttempts,
+            delayMs: options.delayMs,
+        });
+    }
+    claimJob(queue, options = {}) {
+        return this.callTool("thing_queue_claim", {
+            queue,
+            leaseMs: options.leaseMs,
+        });
+    }
+    ackJob(queue, jobId) {
+        return this.callTool("thing_queue_ack", {
+            queue,
+            id: jobId,
+        });
+    }
+    nackJob(queue, jobId, options = {}) {
+        return this.callTool("thing_queue_nack", {
+            queue,
+            id: jobId,
+            delayMs: options.delayMs,
+            error: options.error,
+        });
+    }
+    listJobs(queue) {
+        return this.callTool("thing_queue_list", {
+            queue,
+        });
+    }
+    listDeadJobs(queue) {
+        return this.callTool("thing_queue_dead", {
+            queue,
+        });
+    }
+    search(query, options = {}) {
+        return this.callTool("thing_search", {
+            query,
+            collections: options.collections,
+            limit: options.limit,
+            filter: options.filter,
+        });
+    }
+    async countObjects() {
+        return this.callTool("thing_count_objects", {});
+    }
+    async countEvents() {
+        return this.callTool("thing_count_events", {});
+    }
+    async countActiveJobs() {
+        return this.callTool("thing_count_active_jobs", {});
+    }
+    async countDeadJobs() {
+        return this.callTool("thing_count_dead_jobs", {});
+    }
+    async countLinks() {
+        return Promise.reject(new Error("Graph links not supported by cloud driver yet"));
+    }
+    async putBatch(_collection, _objects) {
+        return Promise.reject(new Error("Batch put not supported by cloud driver yet"));
+    }
+    async deleteBatch(_collection, _ids) {
+        return Promise.reject(new Error("Batch delete not supported by cloud driver yet"));
+    }
+    async createLink(_fromRef, _linkType, _toRef, _weight, _metadataJson) {
+        return Promise.reject(new Error("Graph links not supported by cloud driver yet"));
+    }
+    async deleteLink(_id) {
+        return Promise.reject(new Error("Graph links not supported by cloud driver yet"));
+    }
+    async getLink(_id) {
+        return Promise.reject(new Error("Graph links not supported by cloud driver yet"));
+    }
+    async getNeighbors(_reference, _direction, _options) {
+        return Promise.reject(new Error("Graph links not supported by cloud driver yet"));
+    }
+    async listCollections() {
+        return this.callTool("thing_list_collections", {});
+    }
+    async listStreams() {
+        return this.callTool("thing_list_streams", {});
+    }
+    async listQueues() {
+        return this.callTool("thing_list_queues", {});
+    }
+    async close() {
+        await this.client.close();
+    }
+    async callTool(name, args) {
+        return this.callToolOnce(name, args, true);
+    }
+    async callToolOnce(name, args, retryOnTransportError) {
+        let result;
+        try {
+            result = (await this.client.callTool({ name, arguments: args }));
+        }
+        catch (error) {
+            // Transport-level error (connection dropped, ECONNRESET, etc.).
+            // Attempt one reconnect and retry before propagating.
+            if (retryOnTransportError) {
+                try {
+                    await this.reconnect();
+                }
+                catch (reconnectError) {
+                    throw new Error(`thingd cloud: transport error calling "${name}" and reconnect failed: ${reconnectError instanceof Error ? reconnectError.message : String(reconnectError)}`);
+                }
+                return this.callToolOnce(name, args, false);
+            }
+            throw error;
+        }
+        if (result.isError) {
+            const text = result.content.find((part) => part.type === "text")?.text;
+            throw new Error(text ?? `thingd cloud tool "${name}" returned an error`);
+        }
+        return parseJsonToolResult(result);
+    }
+}
+function resolveMcpUrl(value) {
+    const normalized = value.startsWith("thingd://")
+        ? `http://${value.slice("thingd://".length)}`
+        : value;
+    const url = new URL(normalized);
+    if (url.pathname === "" || url.pathname === "/") {
+        url.pathname = "/mcp";
+    }
+    return url.toString();
+}
+function parseJsonToolResult(result) {
+    const text = result.content.find((part) => part.type === "text" && typeof part.text === "string")?.text;
+    if (!text) {
+        throw new Error("thingd cloud tool did not return JSON text content");
+    }
+    return JSON.parse(text);
+}

package/dist/stores/in-memory-thing-store.d.ts

@@ -0,0 +1,44 @@
+import type { ListEventsOptions, ListObjectsOptions, MemoryEvent, MemoryObject, MemorySearchOptions, MemorySearchResult, QueueClaimOptions, QueueJob, QueueJobOptions, QueueJobPayload, QueueJobResult, QueueNackOptions, StoredMemoryEvent, StoredMemoryObject, ThingDeleteResult, ThingStore } from "../types.js";
+export declare class InMemoryThingStore implements ThingStore {
+    private readonly collections;
+    private readonly events;
+    private nextEventSequence;
+    private readonly queues;
+    private readonly links;
+    private readonly mutex;
+    private withLock;
+    put(collection: string, object: MemoryObject): Promise<StoredMemoryObject>;
+    get<T = StoredMemoryObject>(collection: string, id: string): Promise<T | null>;
+    delete(collection: string, id: string): Promise<ThingDeleteResult>;
+    listObjects<T = StoredMemoryObject>(collection: string, options?: ListObjectsOptions): Promise<T[]>;
+    appendEvent(stream: string, event: MemoryEvent): Promise<StoredMemoryEvent>;
+    listEvents<T = StoredMemoryEvent>(stream?: string, options?: ListEventsOptions): Promise<T[]>;
+    pushJob(queue: string, payload: QueueJobPayload, options?: QueueJobOptions): Promise<QueueJob>;
+    claimJob(queue: string, options?: QueueClaimOptions): Promise<QueueJob | null>;
+    ackJob(queue: string, jobId: string): Promise<QueueJobResult>;
+    nackJob(queue: string, jobId: string, options?: QueueNackOptions): Promise<QueueJobResult>;
+    listJobs(queue: string): Promise<QueueJob[]>;
+    listDeadJobs(queue: string): Promise<QueueJob[]>;
+    search(query: string, options?: MemorySearchOptions): Promise<MemorySearchResult[]>;
+    countObjects(): Promise<number>;
+    countEvents(): Promise<number>;
+    countActiveJobs(): Promise<number>;
+    countDeadJobs(): Promise<number>;
+    countLinks(): Promise<number>;
+    putBatch(collection: string, objects: MemoryObject[]): Promise<StoredMemoryObject[]>;
+    deleteBatch(collection: string, ids: string[]): Promise<number>;
+    createLink(fromRef: string, linkType: string, toRef: string, weight?: number, metadataJson?: string): Promise<import("../types.js").Link>;
+    deleteLink(id: string): Promise<boolean>;
+    getLink(id: string): Promise<import("../types.js").Link | null>;
+    getNeighbors(reference: string, direction: import("../types.js").LinkDirection, options: import("../types.js").LinkQueryOptions): Promise<import("../types.js").Link[]>;
+    listCollections(): Promise<string[]>;
+    listQueues(): Promise<string[]>;
+    listStreams(): Promise<string[]>;
+    close(): Promise<void>;
+    private getCollection;
+    private getQueue;
+    private findJob;
+    private releaseExpiredLeases;
+    private cloneJob;
+}
+//# sourceMappingURL=in-memory-thing-store.d.ts.map

package/dist/stores/in-memory-thing-store.d.ts.map

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

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

@@ -0,0 +1,411 @@
+import { randomUUID } from "node:crypto";
+const DEFAULT_LEASE_MS = 30_000;
+class Mutex {
+    queue = [];
+    locked = false;
+    async acquire() {
+        if (!this.locked) {
+            this.locked = true;
+            return () => this.release();
+        }
+        return new Promise((resolve) => {
+            this.queue.push(() => {
+                this.locked = true;
+                resolve(() => this.release());
+            });
+        });
+    }
+    release() {
+        const next = this.queue.shift();
+        if (next) {
+            next();
+        }
+        else {
+            this.locked = false;
+        }
+    }
+}
+export class InMemoryThingStore {
+    collections = new Map();
+    events = [];
+    nextEventSequence = 0;
+    queues = new Map();
+    links = new Map();
+    mutex = new Mutex();
+    async withLock(fn) {
+        const release = await this.mutex.acquire();
+        try {
+            return fn();
+        }
+        finally {
+            release();
+        }
+    }
+    async put(collection, object) {
+        return this.withLock(() => {
+            const records = this.getCollection(collection);
+            const now = new Date().toISOString();
+            const existing = records.get(object.id);
+            const record = {
+                ...object,
+                id: object.id,
+                collection,
+                createdAt: existing?.createdAt ?? now,
+                updatedAt: now,
+                version: (existing?.version ?? 0) + 1,
+            };
+            records.set(object.id, record);
+            return record;
+        });
+    }
+    async get(collection, id) {
+        return this.collections.get(collection)?.get(id) ?? null;
+    }
+    async delete(collection, id) {
+        return this.withLock(() => ({
+            deleted: this.collections.get(collection)?.delete(id) ?? false,
+        }));
+    }
+    async listObjects(collection, options) {
+        const records = this.collections.get(collection);
+        if (!records) {
+            return [];
+        }
+        let results = Array.from(records.values());
+        const filter = options?.filter;
+        if (filter) {
+            results = results.filter((obj) => Object.entries(filter).every(([key, value]) => obj[key] === value));
+        }
+        if (options?.sortBy) {
+            const { field, direction } = options.sortBy;
+            const asc = direction !== "desc";
+            results.sort((a, b) => {
+                const va = a[field];
+                const vb = b[field];
+                if (va === vb) {
+                    return 0;
+                }
+                if (va === undefined) {
+                    return 1;
+                }
+                if (vb === undefined) {
+                    return -1;
+                }
+                const cmp = va < vb ? -1 : 1;
+                return asc ? cmp : -cmp;
+            });
+        }
+        if (options?.offset) {
+            results = results.slice(options.offset);
+        }
+        if (options?.limit) {
+            results = results.slice(0, options.limit);
+        }
+        return results;
+    }
+    async appendEvent(stream, event) {
+        return this.withLock(() => {
+            this.nextEventSequence += 1;
+            const record = {
+                ...event,
+                id: randomUUID(),
+                stream,
+                sequence: this.nextEventSequence,
+                createdAt: new Date().toISOString(),
+            };
+            this.events.push(record);
+            return record;
+        });
+    }
+    async listEvents(stream, options) {
+        let events = this.events;
+        if (stream) {
+            events = events.filter((event) => event.stream === stream);
+        }
+        const fromSeq = options?.fromSequence;
+        if (fromSeq) {
+            events = events.filter((event) => event.sequence > fromSeq);
+        }
+        if (options?.limit) {
+            events = events.slice(0, options.limit);
+        }
+        return [...events];
+    }
+    async pushJob(queue, payload, options = {}) {
+        return this.withLock(() => {
+            const jobs = this.getQueue(queue);
+            const now = new Date().toISOString();
+            const job = {
+                id: options.idempotencyKey ?? randomUUID(),
+                queue,
+                payload,
+                status: "ready",
+                attempts: 0,
+                maxAttempts: options.maxAttempts ?? 3,
+                createdAt: now,
+                availableAt: new Date(Date.now() + (options.delayMs ?? 0)).toISOString(),
+            };
+            const existing = jobs.find((candidate) => candidate.id === job.id);
+            if (existing) {
+                return this.cloneJob(existing);
+            }
+            jobs.push(job);
+            return this.cloneJob(job);
+        });
+    }
+    async claimJob(queue, options = {}) {
+        return this.withLock(() => {
+            this.releaseExpiredLeases(queue);
+            const now = new Date();
+            const job = this.queues
+                .get(queue)
+                ?.find((candidate) => candidate.status === "ready" && candidate.availableAt <= now.toISOString());
+            if (!job) {
+                return null;
+            }
+            job.status = "leased";
+            job.attempts += 1;
+            job.leasedAt = now.toISOString();
+            job.leaseExpiresAt = new Date(now.getTime() + (options.leaseMs ?? DEFAULT_LEASE_MS)).toISOString();
+            return this.cloneJob(job);
+        });
+    }
+    async ackJob(queue, jobId) {
+        return this.withLock(() => {
+            const job = this.findJob(queue, jobId);
+            if (!job) {
+                return { ok: false, reason: "not_found" };
+            }
+            if (job.status === "completed" || job.status === "dead") {
+                return { ok: false, reason: "terminal" };
+            }
+            if (job.status !== "leased") {
+                return { ok: false, reason: "not_leased" };
+            }
+            job.status = "completed";
+            job.completedAt = new Date().toISOString();
+            return { ok: true, job: this.cloneJob(job) };
+        });
+    }
+    async nackJob(queue, jobId, options = {}) {
+        return this.withLock(() => {
+            const job = this.findJob(queue, jobId);
+            if (!job) {
+                return { ok: false, reason: "not_found" };
+            }
+            if (job.status === "completed" || job.status === "dead") {
+                return { ok: false, reason: "terminal" };
+            }
+            if (job.status !== "leased") {
+                return { ok: false, reason: "not_leased" };
+            }
+            job.lastError = options.error;
+            job.leasedAt = undefined;
+            job.leaseExpiresAt = undefined;
+            if (job.attempts >= job.maxAttempts) {
+                job.status = "dead";
+                job.deadAt = new Date().toISOString();
+            }
+            else {
+                job.status = "ready";
+                job.availableAt = new Date(Date.now() + (options.delayMs ?? 0)).toISOString();
+            }
+            return { ok: true, job: this.cloneJob(job) };
+        });
+    }
+    async listJobs(queue) {
+        return (this.queues.get(queue) ?? []).map((job) => this.cloneJob(job));
+    }
+    async listDeadJobs(queue) {
+        return (this.queues.get(queue) ?? [])
+            .filter((job) => job.status === "dead")
+            .map((job) => this.cloneJob(job));
+    }
+    async search(query, options = {}) {
+        const normalizedQuery = query.toLowerCase();
+        const collections = options.collections ? new Set(options.collections) : null;
+        const results = [];
+        for (const [collection, records] of this.collections) {
+            if (collections && !collections.has(collection)) {
+                continue;
+            }
+            for (const record of records.values()) {
+                const haystack = JSON.stringify(record).toLowerCase();
+                if (haystack.includes(normalizedQuery)) {
+                    results.push({
+                        kind: "object",
+                        id: record.id,
+                        collection,
+                        score: 1,
+                        value: record,
+                    });
+                }
+            }
+        }
+        for (const event of this.events) {
+            const haystack = JSON.stringify(event).toLowerCase();
+            if (haystack.includes(normalizedQuery)) {
+                results.push({
+                    kind: "event",
+                    id: event.id,
+                    stream: event.stream,
+                    score: 1,
+                    value: event,
+                });
+            }
+        }
+        return options.limit !== undefined ? results.slice(0, options.limit) : results;
+    }
+    async countObjects() {
+        let total = 0;
+        for (const records of this.collections.values()) {
+            total += records.size;
+        }
+        return total;
+    }
+    async countEvents() {
+        return this.events.length;
+    }
+    async countActiveJobs() {
+        let total = 0;
+        for (const jobs of this.queues.values()) {
+            total += jobs.filter((job) => job.status !== "dead").length;
+        }
+        return total;
+    }
+    async countDeadJobs() {
+        let total = 0;
+        for (const jobs of this.queues.values()) {
+            total += jobs.filter((job) => job.status === "dead").length;
+        }
+        return total;
+    }
+    async countLinks() {
+        return this.links.size;
+    }
+    async putBatch(collection, objects) {
+        return this.withLock(() => {
+            const records = this.getCollection(collection);
+            const now = new Date().toISOString();
+            const results = [];
+            for (const object of objects) {
+                const existing = records.get(object.id);
+                const record = {
+                    ...object,
+                    id: object.id,
+                    collection,
+                    createdAt: existing?.createdAt ?? now,
+                    updatedAt: now,
+                    version: (existing?.version ?? 0) + 1,
+                };
+                records.set(object.id, record);
+                results.push(record);
+            }
+            return results;
+        });
+    }
+    async deleteBatch(collection, ids) {
+        return this.withLock(() => {
+            const records = this.collections.get(collection);
+            if (!records) {
+                return 0;
+            }
+            let count = 0;
+            for (const id of ids) {
+                if (records.delete(id)) {
+                    count++;
+                }
+            }
+            return count;
+        });
+    }
+    async createLink(fromRef, linkType, toRef, weight, metadataJson) {
+        return this.withLock(() => {
+            const link = {
+                id: randomUUID(),
+                fromRef,
+                linkType,
+                toRef,
+                weight,
+                metadataJson: metadataJson ?? "{}",
+                createdAt: new Date().toISOString(),
+            };
+            this.links.set(link.id, link);
+            return link;
+        });
+    }
+    async deleteLink(id) {
+        return this.withLock(() => {
+            return this.links.delete(id);
+        });
+    }
+    async getLink(id) {
+        return this.links.get(id) ?? null;
+    }
+    async getNeighbors(reference, direction, options) {
+        let results = Array.from(this.links.values());
+        results = results.filter((link) => {
+            if (direction === "Outgoing") {
+                return link.fromRef === reference;
+            }
+            if (direction === "Incoming") {
+                return link.toRef === reference;
+            }
+            return link.fromRef === reference || link.toRef === reference;
+        });
+        if (options.linkType) {
+            results = results.filter((link) => link.linkType === options.linkType);
+        }
+        if (options.limit !== undefined) {
+            results = results.slice(0, options.limit);
+        }
+        return results;
+    }
+    async listCollections() {
+        return Array.from(this.collections.keys()).sort();
+    }
+    async listQueues() {
+        return Array.from(this.queues.keys()).sort();
+    }
+    async listStreams() {
+        const streams = new Set();
+        for (const event of this.events) {
+            streams.add(event.stream);
+        }
+        return Array.from(streams).sort();
+    }
+    async close() {
+        // no-op for in-memory store
+    }
+    getCollection(collection) {
+        const records = this.collections.get(collection) ?? new Map();
+        this.collections.set(collection, records);
+        return records;
+    }
+    getQueue(queue) {
+        const jobs = this.queues.get(queue) ?? [];
+        this.queues.set(queue, jobs);
+        return jobs;
+    }
+    findJob(queue, jobId) {
+        return this.queues.get(queue)?.find((job) => job.id === jobId) ?? null;
+    }
+    releaseExpiredLeases(queue) {
+        const now = new Date().toISOString();
+        for (const job of this.queues.get(queue) ?? []) {
+            if (job.status === "leased" && job.leaseExpiresAt && job.leaseExpiresAt <= now) {
+                job.status = "ready";
+                job.leasedAt = undefined;
+                job.leaseExpiresAt = undefined;
+            }
+        }
+    }
+    cloneJob(job) {
+        return {
+            ...job,
+            payload: {
+                ...job.payload,
+            },
+        };
+    }
+}