@thingd/cli 0.31.0

package/dist/mcp/http.js

@@ -0,0 +1,588 @@
+import { createServer } from "node:http";
+import { PassThrough } from "node:stream";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createThingdMcpServer, ThingD, } from "@thingd/node";
+import { findNextLeaderCandidate, forwardMcpRequestToLeader, getClusterStatus, resolveClusterOptions, } from "./cluster.js";
+import { ensureHttpRuntimeIsSafe } from "./config.js";
+export async function startThingdHttpServer(options) {
+    const host = options.host ?? "127.0.0.1";
+    const port = options.port ?? 8757;
+    ensureHttpRuntimeIsSafe({
+        host,
+        authToken: options.authToken,
+        allowUnauthenticated: options.allowUnauthenticated,
+    });
+    const originalDb = await ThingD.open({
+        path: options.path,
+        driver: options.driver,
+    });
+    const cluster = resolveClusterOptions(options.cluster);
+    const db = createReplicatingDb(originalDb, cluster.mode);
+    const state = {
+        db,
+        originalDb,
+        authToken: options.authToken,
+        mcpPath: options.mcpPath ?? "/mcp",
+        healthPath: options.healthPath ?? "/healthz",
+        driver: options.driver ?? "memory",
+        audit: options.audit,
+        cluster,
+        hardening: options.hardening,
+        consecutiveReplicationFailures: 0,
+    };
+    const server = createServer((request, response) => {
+        void handleRequest(state, request, response);
+    });
+    await listen(server, port, host);
+    const address = server.address();
+    const resolvedPort = typeof address === "object" && address ? address.port : port;
+    const displayHost = host === "0.0.0.0" ? "127.0.0.1" : host;
+    const url = `http://${displayHost}:${resolvedPort}`;
+    if (cluster.mode === "follower") {
+        startReplicationRunner(state);
+    }
+    return {
+        server,
+        url,
+        mcpUrl: `${url}${state.mcpPath}`,
+        close: async () => {
+            stopReplicationRunner(state);
+            await close(server);
+            await originalDb.close?.();
+        },
+    };
+}
+async function handleRequest(state, request, response) {
+    try {
+        setCommonHeaders(response);
+        const path = requestPath(request);
+        if (request.method === "OPTIONS") {
+            response.writeHead(204);
+            response.end();
+            return;
+        }
+        if (path === state.healthPath) {
+            await handleHealth(state, request, response);
+            return;
+        }
+        if (path === state.cluster.statusPath) {
+            await handleClusterStatus(state, request, response);
+            return;
+        }
+        if (path === state.cluster.peersPath) {
+            handleClusterPeers(state, request, response);
+            return;
+        }
+        if (path !== state.mcpPath && path !== "/v1/replication/events") {
+            writeJson(response, 404, {
+                error: "not_found",
+            });
+            return;
+        }
+        if (!isAuthorized(state, request)) {
+            response.setHeader("WWW-Authenticate", "Bearer");
+            writeJson(response, 401, {
+                error: "unauthorized",
+            });
+            return;
+        }
+        if (path === "/v1/replication/events") {
+            await handleReplicationEvents(state, request, response);
+            return;
+        }
+        if (request.method !== "POST") {
+            response.setHeader("Allow", "POST, OPTIONS");
+            writeJson(response, 405, {
+                jsonrpc: "2.0",
+                error: {
+                    code: -32_000,
+                    message: "Method not allowed.",
+                },
+                id: null,
+            });
+            return;
+        }
+        // Enforce payload size limit.
+        // For requests with Content-Length we can reject immediately without draining the body.
+        // For chunked transfers we wrap the request in a PassThrough that aborts if the limit is exceeded.
+        const maxBytes = state.hardening?.maxPayloadBytes ?? 524_288;
+        const contentLength = parseContentLength(request);
+        if (contentLength !== null && contentLength > maxBytes) {
+            writeJson(response, 413, {
+                jsonrpc: "2.0",
+                error: {
+                    code: -32_000,
+                    message: `Request body exceeds the maximum allowed size of ${maxBytes} bytes.`,
+                },
+                id: null,
+            });
+            return;
+        }
+        if (state.cluster.mode === "follower") {
+            await forwardMcpRequestToLeader(state.cluster, state.mcpPath, request, response);
+            return;
+        }
+        // For chunked transfers, wrap the request in a PassThrough that enforces the limit
+        // without pre-draining the stream (the MCP transport still drives reading).
+        const wrappedRequest = contentLength === null ? wrapRequestWithSizeLimit(request, response, maxBytes) : request;
+        await handleMcpRequest(state, wrappedRequest, response);
+    }
+    catch (error) {
+        if (!response.headersSent) {
+            writeJson(response, 500, {
+                jsonrpc: "2.0",
+                error: {
+                    code: -32_603,
+                    message: error instanceof Error ? error.message : "Internal server error",
+                },
+                id: null,
+            });
+            return;
+        }
+        response.end();
+    }
+}
+async function handleHealth(state, request, response) {
+    if (request.method !== "GET" && request.method !== "HEAD") {
+        response.setHeader("Allow", "GET, HEAD, OPTIONS");
+        writeJson(response, 405, {
+            error: "method_not_allowed",
+        });
+        return;
+    }
+    const status = await getClusterStatus(state.cluster, state.db);
+    writeJson(response, 200, {
+        ok: true,
+        service: "thingd-mcp",
+        driver: state.driver,
+        mcpPath: state.mcpPath,
+        cluster: status,
+    }, request.method === "HEAD");
+}
+async function handleClusterStatus(state, request, response) {
+    if (request.method !== "GET" && request.method !== "HEAD") {
+        response.setHeader("Allow", "GET, HEAD, OPTIONS");
+        writeJson(response, 405, {
+            error: "method_not_allowed",
+        });
+        return;
+    }
+    const status = await getClusterStatus(state.cluster, state.db);
+    writeJson(response, 200, status, request.method === "HEAD");
+}
+function handleClusterPeers(state, request, response) {
+    if (request.method !== "GET" && request.method !== "HEAD") {
+        response.setHeader("Allow", "GET, HEAD, OPTIONS");
+        writeJson(response, 405, {
+            error: "method_not_allowed",
+        });
+        return;
+    }
+    writeJson(response, 200, {
+        peers: state.cluster.peers,
+        discovery: state.cluster.discovery,
+    }, request.method === "HEAD");
+}
+async function handleMcpRequest(state, request, response) {
+    const server = createThingdMcpServer(state.db, {
+        audit: state.audit,
+        hardening: state.hardening,
+    });
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined,
+    });
+    response.on("close", () => {
+        void transport.close();
+        void server.close();
+    });
+    await server.connect(transport);
+    await transport.handleRequest(request, response);
+}
+function requestPath(request) {
+    return new URL(request.url ?? "/", "http://thingd.local").pathname;
+}
+function isAuthorized(state, request) {
+    if (!state.authToken) {
+        return true;
+    }
+    return request.headers.authorization === `Bearer ${state.authToken}`;
+}
+function setCommonHeaders(response) {
+    response.setHeader("Access-Control-Allow-Origin", "*");
+    response.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type, MCP-Protocol-Version");
+    response.setHeader("Access-Control-Allow-Methods", "POST, GET, HEAD, OPTIONS");
+}
+function writeJson(response, statusCode, body, headersOnly = false) {
+    response.writeHead(statusCode, {
+        "Content-Type": "application/json",
+    });
+    if (headersOnly) {
+        response.end();
+        return;
+    }
+    response.end(JSON.stringify(body));
+}
+function listen(server, port, host) {
+    return new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off("listening", onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.off("error", onError);
+            resolve();
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen(port, host);
+    });
+}
+function close(server) {
+    return new Promise((resolve, reject) => {
+        server.close((error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+/** Parse Content-Length header. Returns null if absent or invalid. */
+function parseContentLength(request) {
+    const header = request.headers["content-length"];
+    if (!header) {
+        return null;
+    }
+    const n = Number.parseInt(header, 10);
+    return Number.isInteger(n) && n >= 0 ? n : null;
+}
+/**
+ * Wrap a request in a PassThrough that enforces maxBytes for chunked transfers.
+ * The MCP transport still drives reading — we just count bytes as they flow through
+ * and destroy the stream (causing the transport to error) if the limit is exceeded.
+ * The response is also aborted with HTTP 413 immediately on overflow.
+ */
+function wrapRequestWithSizeLimit(request, response, maxBytes) {
+    const pass = new PassThrough();
+    let total = 0;
+    let aborted = false;
+    Object.defineProperties(pass, {
+        method: { get: () => request.method },
+        url: { get: () => request.url },
+        headers: { get: () => request.headers },
+    });
+    request.on("data", (chunk) => {
+        if (aborted) {
+            return;
+        }
+        total += chunk.length;
+        if (total > maxBytes) {
+            aborted = true;
+            if (!response.headersSent) {
+                writeJson(response, 413, {
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32_000,
+                        message: `Request body exceeds the maximum allowed size of ${maxBytes} bytes.`,
+                    },
+                    id: null,
+                });
+            }
+            pass.destroy();
+            request.destroy();
+            return;
+        }
+        pass.push(chunk);
+    });
+    request.on("end", () => {
+        if (!aborted) {
+            pass.end();
+        }
+    });
+    request.on("error", (err) => {
+        if (!aborted) {
+            pass.destroy(err);
+        }
+    });
+    return pass;
+}
+function createReplicatingDb(originalDb, mode) {
+    if (mode !== "leader" && mode !== "single") {
+        return originalDb;
+    }
+    const proxy = Object.create(originalDb);
+    proxy.put = async (collection, object) => {
+        const stored = await originalDb.put(collection, object);
+        if (!collection.startsWith("__thingd")) {
+            try {
+                await originalDb.events.append("__thingd:system:replication", {
+                    type: "replication.objects.put",
+                    collection,
+                    id: stored.id,
+                    object: stored,
+                });
+            }
+            catch (err) {
+                console.error("Replication event append failed:", err);
+            }
+        }
+        return stored;
+    };
+    proxy.delete = async (collection, id) => {
+        const result = await originalDb.delete(collection, id);
+        if (!collection.startsWith("__thingd")) {
+            try {
+                await originalDb.events.append("__thingd:system:replication", {
+                    type: "replication.objects.delete",
+                    collection,
+                    id,
+                });
+            }
+            catch (err) {
+                console.error("Replication event append failed:", err);
+            }
+        }
+        return result;
+    };
+    const originalEventsAppend = originalDb.events.append.bind(originalDb.events);
+    Object.defineProperty(proxy, "events", {
+        value: {
+            ...originalDb.events,
+            append: async (stream, event) => {
+                const stored = await originalEventsAppend(stream, event);
+                if (stream !== "__thingd:system:replication") {
+                    try {
+                        await originalEventsAppend("__thingd:system:replication", {
+                            type: "replication.events.append",
+                            stream,
+                            event: stored,
+                        });
+                    }
+                    catch (err) {
+                        console.error("Replication event append failed:", err);
+                    }
+                }
+                return stored;
+            },
+        },
+        writable: true,
+        configurable: true,
+    });
+    return proxy;
+}
+function* resolveLeaderUrls(cluster) {
+    if (cluster.leaderUrl) {
+        yield cluster.leaderUrl;
+    }
+    if (cluster.fallbackLeaderUrl) {
+        yield cluster.fallbackLeaderUrl;
+    }
+}
+function startReplicationRunner(state) {
+    const leaderUrl = state.cluster.leaderUrl;
+    if (!leaderUrl) {
+        return;
+    }
+    const pullInterval = 500;
+    async function runSync() {
+        if (state.replicationStopped) {
+            return;
+        }
+        const status = await state.db.get("__thingd_meta", "replication_status");
+        const lastSeq = status && typeof status.lastReplicatedSequence === "number"
+            ? status.lastReplicatedSequence
+            : 0;
+        let fetched = false;
+        for (const url of resolveLeaderUrls(state.cluster)) {
+            if (state.replicationStopped) {
+                return;
+            }
+            try {
+                const fetchUrl = new URL("/v1/replication/events", url);
+                fetchUrl.searchParams.set("after", String(lastSeq));
+                const headers = {
+                    Accept: "application/json",
+                };
+                if (state.cluster.forwardAuthToken) {
+                    headers.Authorization = `Bearer ${state.cluster.forwardAuthToken}`;
+                }
+                const response = await fetch(fetchUrl.toString(), {
+                    headers,
+                    signal: AbortSignal.timeout(10_000),
+                });
+                if (!response.ok) {
+                    throw new Error(`Leader replication returned HTTP ${response.status}`);
+                }
+                state.cluster.activeLeaderUrl = url;
+                const resData = (await response.json());
+                if (resData.success && Array.isArray(resData.events) && resData.events.length > 0) {
+                    for (const ev of resData.events) {
+                        if (state.replicationStopped) {
+                            return;
+                        }
+                        const type = ev.type;
+                        if (type === "replication.objects.put" && ev.collection) {
+                            const { collection, object } = ev;
+                            const cleanObj = { ...object };
+                            delete cleanObj.collection;
+                            delete cleanObj.createdAt;
+                            delete cleanObj.updatedAt;
+                            delete cleanObj.version;
+                            await state.db.put(collection, cleanObj);
+                        }
+                        else if (type === "replication.objects.delete" && ev.collection && ev.id) {
+                            const { collection, id } = ev;
+                            await state.db.delete(collection, id);
+                        }
+                        else if (type === "replication.events.append" && ev.stream) {
+                            const { stream, event } = ev;
+                            const cleanEv = { ...event };
+                            delete cleanEv.id;
+                            delete cleanEv.createdAt;
+                            delete cleanEv.stream;
+                            await state.db.events.append(stream, cleanEv);
+                        }
+                        const seq = Number.parseInt(ev.id, 10);
+                        await state.db.put("__thingd_meta", {
+                            id: "replication_status",
+                            lastReplicatedSequence: seq,
+                            updatedAt: new Date().toISOString(),
+                        });
+                    }
+                }
+                fetched = true;
+                // Asynchronously update the cached replication lag so /healthz never
+                // blocks on an outbound request. Fire-and-forget; errors are non-fatal.
+                void updateCachedLag(state, url, lastSeq);
+                break;
+            }
+            catch (error) {
+                console.error(`Replication from ${url} failed:`, error instanceof Error ? error.message : String(error));
+            }
+        }
+        if (state.replicationStopped) {
+            return;
+        }
+        if (!fetched) {
+            state.consecutiveReplicationFailures++;
+            if (state.cluster.leaderElection &&
+                state.consecutiveReplicationFailures >= state.cluster.electionMaxFailures) {
+                state.consecutiveReplicationFailures = 0;
+                const promoted = attemptFollowerFailover(state);
+                if (promoted) {
+                    // This node is now leader. Stop the replication runner.
+                    return;
+                }
+                // leaderUrl was updated by failover; retry immediately.
+            }
+            else {
+                console.error("All leader URLs exhausted for replication");
+            }
+        }
+        else {
+            state.consecutiveReplicationFailures = 0;
+        }
+        if (!state.replicationStopped) {
+            state.replicationTimer = setTimeout(() => {
+                void runSync();
+            }, pullInterval);
+        }
+    }
+    state.replicationTimer = setTimeout(() => {
+        void runSync();
+    }, pullInterval);
+}
+function stopReplicationRunner(state) {
+    state.replicationStopped = true;
+    if (state.replicationTimer) {
+        clearTimeout(state.replicationTimer);
+        state.replicationTimer = undefined;
+    }
+}
+/**
+ * Asynchronously fetch the leader's last replicated sequence and update
+ * the cached lag on the cluster state. Called after each successful sync
+ * so that /healthz can return the lag without making an outbound request.
+ */
+async function updateCachedLag(state, leaderUrl, localLastSeq) {
+    try {
+        const leaderStatusUrl = new URL("/cluster/status", leaderUrl).toString();
+        const headers = { Accept: "application/json" };
+        if (state.cluster.forwardAuthToken) {
+            headers.Authorization = `Bearer ${state.cluster.forwardAuthToken}`;
+        }
+        const res = await fetch(leaderStatusUrl, {
+            headers,
+            signal: AbortSignal.timeout(5_000),
+        });
+        if (!res.ok) {
+            return;
+        }
+        const leaderStatus = (await res.json());
+        const leaderSeq = leaderStatus?.replication?.lastReplicatedSequence;
+        if (typeof leaderSeq === "number") {
+            state.cluster.cachedReplicationLag = Math.max(0, leaderSeq - localLastSeq);
+        }
+    }
+    catch {
+        // Non-fatal — lag will remain at the last known value.
+    }
+}
+/**
+ * Attempt a static-config leader failover from this follower.
+ * Returns true if this node promoted itself to leader.
+ */
+function attemptFollowerFailover(state) {
+    if (state.replicationStopped) {
+        return false;
+    }
+    const candidate = findNextLeaderCandidate(state.cluster);
+    if (!candidate) {
+        console.error("Leader failover: no candidate found in peer list");
+        return false;
+    }
+    if (candidate.isSelf) {
+        // Promote this node to leader.
+        console.error(`Leader failover: promoting self (${candidate.url}) to leader`);
+        state.db = createReplicatingDb(state.originalDb, "leader");
+        state.cluster.mode = "leader";
+        state.cluster.leaderUrl = candidate.url;
+        state.cluster.activeLeaderUrl = candidate.url;
+        state.cluster.fallbackLeaderUrl = undefined;
+        stopReplicationRunner(state);
+        state.consecutiveReplicationFailures = 0;
+        return true;
+    }
+    // Redirect to the next candidate leader.
+    console.error(`Leader failover: redirecting to ${candidate.url}`);
+    state.cluster.leaderUrl = candidate.url;
+    state.cluster.activeLeaderUrl = undefined;
+    state.cluster.fallbackLeaderUrl = undefined;
+    state.consecutiveReplicationFailures = 0;
+    return false;
+}
+async function handleReplicationEvents(state, request, response) {
+    if (request.method !== "GET" && request.method !== "HEAD") {
+        response.setHeader("Allow", "GET, HEAD, OPTIONS");
+        writeJson(response, 405, { error: "method_not_allowed" });
+        return;
+    }
+    const url = new URL(request.url ?? "", "http://localhost");
+    const afterStr = url.searchParams.get("after");
+    const afterSeq = afterStr ? Number.parseInt(afterStr, 10) : 0;
+    try {
+        const filteredEvents = await state.db.events.list("__thingd:system:replication", {
+            fromSequence: afterSeq,
+        });
+        writeJson(response, 200, {
+            success: true,
+            events: filteredEvents,
+        }, request.method === "HEAD");
+    }
+    catch (error) {
+        writeJson(response, 500, {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}

package/dist/mcp/index.d.ts

@@ -0,0 +1,5 @@
+export { appendMcpAuditEvent, createThingdMcpServer, jsonResult, parseCollectionAllowlist, parsePayloadSizeLimit, type RegisterThingdToolsOptions, readMcpHardeningOptionsFromEnv, registerThingdTools, resolveThingdMcpAuditOptions, type ThingdMcpAuditMetadata, type ThingdMcpAuditOptions, type ThingdMcpHardeningOptions, type ThingdMcpServerOptions, } from "@thingd/node";
+export type { ResolvedThingdClusterOptions, ThingdClusterDiscovery, ThingdClusterMode, ThingdClusterOptions, ThingdClusterStatus, } from "./cluster.js";
+export type { RunningThingdHttpServer, ThingdHttpServerOptions } from "./http.js";
+export { startThingdHttpServer } from "./http.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":"AACA,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,cAAc,CAAC;AAGtB,YAAY,EACV,4BAA4B,EAC5B,sBAAsB,EACtB,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAClF,OAAO,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC"}

package/dist/mcp/index.js

@@ -0,0 +1,3 @@
+// Re-export core MCP logic from the SDK
+export { appendMcpAuditEvent, createThingdMcpServer, jsonResult, parseCollectionAllowlist, parsePayloadSizeLimit, readMcpHardeningOptionsFromEnv, registerThingdTools, resolveThingdMcpAuditOptions, } from "@thingd/node";
+export { startThingdHttpServer } from "./http.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";
+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,QAAQ,CAAC;AAErC,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"}