@thingd/cli 0.70.0 → 0.72.0

package/dist/dashboard/server.js

@@ -1,663 +0,0 @@
-import { existsSync, promises as fs, statSync } from "node:fs";
-import { createServer } from "node:http";
-import { createRequire } from "node:module";
-import { dirname, extname, isAbsolute, join, relative } from "node:path";
-import { fileURLToPath } from "node:url";
-import { handleRestRequest, ThingD } from "@thingd/sdk";
-import { readCloudConfig } from "../lib/cloud-config.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const _require = createRequire(__filename);
-let pkgVersion = "0.0.0";
-try {
-    const pkg = _require("../../package.json");
-    pkgVersion = pkg.version || "0.0.0";
-}
-catch {
-    // fallback — try relative to dist
-    try {
-        const pkg = _require("../package.json");
-        pkgVersion = pkg.version || "0.0.0";
-    }
-    catch {
-        // leave default
-    }
-}
-// Candidate public folders to support both tsx dev and compiled dist packaging
-const publicDirCandidates = [
-    join(__dirname, "public"),
-    join(__dirname, "../public"),
-    join(__dirname, "../../../src/dashboard/public"),
-    join(__dirname, "../../src/dashboard/public"),
-];
-let publicDir = "";
-for (const cand of publicDirCandidates) {
-    if (existsSync(cand)) {
-        publicDir = cand;
-        break;
-    }
-}
-const MIME_TYPES = {
-    ".html": "text/html",
-    ".css": "text/css",
-    ".js": "application/javascript",
-    ".json": "application/json",
-    ".png": "image/png",
-    ".ico": "image/x-icon",
-    ".svg": "image/svg+xml",
-    ".webmanifest": "application/manifest+json",
-};
-async function readBody(req) {
-    return new Promise((resolvePromise, rejectPromise) => {
-        let body = "";
-        req.on("data", (chunk) => {
-            body += chunk;
-        });
-        req.on("end", () => {
-            resolvePromise(body);
-        });
-        req.on("error", (err) => {
-            rejectPromise(err);
-        });
-    });
-}
-function sendError(res, status, message) {
-    res.writeHead(status, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ error: message }));
-}
-function isCloudPath(path) {
-    return path.startsWith("http://") || path.startsWith("https://") || path.startsWith("thingd://");
-}
-export async function startDashboardServer(connectionOptions, port) {
-    // 1. Maintain dynamic active database options
-    let activeOptions = { ...connectionOptions };
-    let db = await ThingD.open({
-        path: activeOptions.path,
-        url: activeOptions.cloud ? activeOptions.path : undefined,
-        driver: activeOptions.driver,
-        authToken: activeOptions.authToken,
-        instanceSlug: activeOptions.instanceSlug,
-    });
-    // 2. Create HTTP Server
-    const server = createServer(async (req, res) => {
-        try {
-            const url = new URL(req.url || "", `http://${req.headers.host || "localhost"}`);
-            const pathname = url.pathname;
-            // Handle CORS for ease of developer integrations
-            const allowedOrigins = [
-                "http://localhost:8757",
-                "http://localhost:8758",
-                "http://127.0.0.1:8757",
-                "http://127.0.0.1:8758",
-            ];
-            const origin = req.headers.origin;
-            if (origin && allowedOrigins.includes(origin)) {
-                res.setHeader("Access-Control-Allow-Origin", origin);
-            }
-            else {
-                res.setHeader("Access-Control-Allow-Origin", "*");
-            }
-            res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
-            res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
-            if (req.method === "OPTIONS") {
-                res.writeHead(204);
-                res.end();
-                return;
-            }
-            // CSRF protection: state-changing requests must come from a known origin
-            if (req.method !== "GET" && req.method !== "OPTIONS" && req.method !== "HEAD") {
-                const requestOrigin = req.headers.origin;
-                if (requestOrigin && !allowedOrigins.includes(requestOrigin)) {
-                    sendError(res, 403, "Cross-origin state-changing requests are not allowed");
-                    return;
-                }
-            }
-            // Security Gate middleware for API endpoints
-            const isApiRoute = pathname.startsWith("/api/");
-            const isConnectRoute = pathname === "/api/connect";
-            const isRestRoute = pathname.startsWith("/v1/");
-            if ((isApiRoute || isRestRoute) && !isConnectRoute && activeOptions.authToken) {
-                const authHeader = req.headers.authorization;
-                const expectedHeader = `Bearer ${activeOptions.authToken}`;
-                if (!authHeader || authHeader !== expectedHeader) {
-                    res.writeHead(401, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify({ error: "Unauthorized. Valid auth token is required." }));
-                    return;
-                }
-            }
-            // REST API Routes
-            if (pathname.startsWith("/api/")) {
-                // POST /api/connect (Dynamic connection swapping)
-                if (pathname === "/api/connect" && req.method === "POST") {
-                    const bodyStr = await readBody(req);
-                    const { path, driver, authToken, instanceSlug } = JSON.parse(bodyStr);
-                    if (!path || !driver) {
-                        sendError(res, 400, "Fields 'path' and 'driver' are required.");
-                        return;
-                    }
-                    const cloudMode = isCloudPath(path);
-                    const resolvedToken = authToken || (cloudMode ? readCloudConfig()?.token : undefined);
-                    const resolvedInstanceSlug = instanceSlug || activeOptions.instanceSlug;
-                    // Safely shut down the old db instance
-                    await db.close();
-                    // Spawn new db connection dynamically
-                    db = await ThingD.open({
-                        path,
-                        url: cloudMode ? path : undefined,
-                        driver,
-                        authToken: resolvedToken,
-                        instanceSlug: resolvedInstanceSlug,
-                    });
-                    activeOptions = {
-                        path,
-                        driver,
-                        authToken: resolvedToken,
-                        cloud: cloudMode,
-                        instanceSlug: resolvedInstanceSlug,
-                    };
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify({ success: true, path, driver }));
-                    return;
-                }
-                // GET /api/status
-                if (pathname === "/api/status" && req.method === "GET") {
-                    const [objects, events, activeJobs, deadJobs] = await Promise.all([
-                        db.countObjects(),
-                        db.countEvents(),
-                        db.countActiveJobs(),
-                        db.countDeadJobs(),
-                    ]);
-                    let dbSize = "N/A (in-memory)";
-                    if (activeOptions.driver === "native" && existsSync(activeOptions.path)) {
-                        try {
-                            const stats = statSync(activeOptions.path);
-                            dbSize = `${(stats.size / 1024).toFixed(1)} KB`;
-                        }
-                        catch {
-                            dbSize = "N/A (error)";
-                        }
-                    }
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify({
-                        version: pkgVersion,
-                        mode: activeOptions.cloud ? "cloud" : "local",
-                        driver: activeOptions.driver || "memory",
-                        path: activeOptions.path,
-                        metrics: { objects, events, activeJobs, deadJobs, dbSize },
-                        authRequired: !!activeOptions.authToken,
-                    }));
-                    return;
-                }
-                // GET /api/collections
-                if (pathname === "/api/collections" && req.method === "GET") {
-                    const collections = await db.listCollections();
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify(collections));
-                    return;
-                }
-                // GET/POST/DELETE /api/objects
-                if (pathname === "/api/objects") {
-                    if (req.method === "GET") {
-                        const collection = url.searchParams.get("collection");
-                        if (!collection) {
-                            sendError(res, 400, "Query parameter 'collection' is required.");
-                            return;
-                        }
-                        const objects = await db.listObjects(collection);
-                        res.writeHead(200, { "Content-Type": "application/json" });
-                        res.end(JSON.stringify(objects));
-                        return;
-                    }
-                    if (req.method === "POST") {
-                        const bodyStr = await readBody(req);
-                        const { collection, id, text, data } = JSON.parse(bodyStr);
-                        if (!collection || !id) {
-                            sendError(res, 400, "Fields 'collection' and 'id' are required.");
-                            return;
-                        }
-                        const result = await db.put(collection, { id, text, ...data });
-                        res.writeHead(200, { "Content-Type": "application/json" });
-                        res.end(JSON.stringify(result));
-                        return;
-                    }
-                    if (req.method === "DELETE") {
-                        const collection = url.searchParams.get("collection");
-                        const id = url.searchParams.get("id");
-                        if (!collection || !id) {
-                            sendError(res, 400, "Query parameters 'collection' and 'id' are required.");
-                            return;
-                        }
-                        const result = await db.delete(collection, id);
-                        res.writeHead(200, { "Content-Type": "application/json" });
-                        res.end(JSON.stringify(result));
-                        return;
-                    }
-                }
-                // GET/POST /api/events
-                if (pathname === "/api/events") {
-                    if (req.method === "GET") {
-                        const stream = url.searchParams.get("stream") || undefined;
-                        const limitVal = url.searchParams.get("limit");
-                        const limit = limitVal ? Number.parseInt(limitVal, 10) : undefined;
-                        const events = await db.events.list(stream);
-                        const sliced = limit ? events.slice(0, limit) : events;
-                        res.writeHead(200, { "Content-Type": "application/json" });
-                        res.end(JSON.stringify(sliced));
-                        return;
-                    }
-                    if (req.method === "POST") {
-                        const bodyStr = await readBody(req);
-                        const { stream, type, text, data } = JSON.parse(bodyStr);
-                        if (!stream || !type) {
-                            sendError(res, 400, "Fields 'stream' and 'type' are required.");
-                            return;
-                        }
-                        const result = await db.events.append(stream, { type, text, ...data });
-                        res.writeHead(200, { "Content-Type": "application/json" });
-                        res.end(JSON.stringify(result));
-                        return;
-                    }
-                }
-                // GET /api/events/streams
-                if (pathname === "/api/events/streams" && req.method === "GET") {
-                    const streams = await db.listStreams();
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify(streams));
-                    return;
-                }
-                // GET /api/queues
-                if (pathname === "/api/queues" && req.method === "GET") {
-                    const queues = await db.listQueues();
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify(queues));
-                    return;
-                }
-                // GET /api/queues/jobs
-                if (pathname === "/api/queues/jobs" && req.method === "GET") {
-                    const queue = url.searchParams.get("queue");
-                    const status = url.searchParams.get("status");
-                    if (!queue) {
-                        sendError(res, 400, "Query parameter 'queue' is required.");
-                        return;
-                    }
-                    const q = db.queue(queue);
-                    const jobs = status === "dead" ? await q.dead() : await q.list();
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify(jobs));
-                    return;
-                }
-                // GET /api/queues/stats
-                if (pathname === "/api/queues/stats" && req.method === "GET") {
-                    const queue = url.searchParams.get("queue");
-                    if (!queue) {
-                        sendError(res, 400, "Query parameter 'queue' is required.");
-                        return;
-                    }
-                    const q = db.queue(queue);
-                    const [activeJobs, deadJobs] = await Promise.all([q.list(), q.dead()]);
-                    const leased = activeJobs.filter((j) => j.status === "leased").length;
-                    const ready = activeJobs.filter((j) => j.status === "ready").length;
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify({
-                        queue,
-                        totalActive: activeJobs.length,
-                        ready,
-                        leased,
-                        dead: deadJobs.length,
-                    }));
-                    return;
-                }
-                // POST /api/queues/push
-                if (pathname === "/api/queues/push" && req.method === "POST") {
-                    const bodyStr = await readBody(req);
-                    const { queue, payload, delayMs, maxAttempts, idempotencyKey } = JSON.parse(bodyStr);
-                    if (!queue || !payload) {
-                        sendError(res, 400, "Fields 'queue' and 'payload' are required.");
-                        return;
-                    }
-                    const q = db.queue(queue);
-                    const result = await q.push(payload, { delayMs, maxAttempts, idempotencyKey });
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify(result));
-                    return;
-                }
-                // POST /api/queues/claim
-                if (pathname === "/api/queues/claim" && req.method === "POST") {
-                    const bodyStr = await readBody(req);
-                    const { queue, leaseMs } = JSON.parse(bodyStr);
-                    if (!queue) {
-                        sendError(res, 400, "Field 'queue' is required.");
-                        return;
-                    }
-                    const q = db.queue(queue);
-                    const job = await q.claim({ leaseMs });
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify(job || null));
-                    return;
-                }
-                // POST /api/queues/ack
-                if (pathname === "/api/queues/ack" && req.method === "POST") {
-                    const bodyStr = await readBody(req);
-                    const { queue, jobId } = JSON.parse(bodyStr);
-                    if (!queue || !jobId) {
-                        sendError(res, 400, "Fields 'queue' and 'jobId' are required.");
-                        return;
-                    }
-                    const q = db.queue(queue);
-                    const result = await q.ack(jobId);
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify(result));
-                    return;
-                }
-                // POST /api/queues/nack
-                if (pathname === "/api/queues/nack" && req.method === "POST") {
-                    const bodyStr = await readBody(req);
-                    const { queue, jobId, error, delayMs } = JSON.parse(bodyStr);
-                    if (!queue || !jobId) {
-                        sendError(res, 400, "Fields 'queue' and 'jobId' are required.");
-                        return;
-                    }
-                    const q = db.queue(queue);
-                    const result = await q.nack(jobId, { error, delayMs });
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify(result));
-                    return;
-                }
-                // GET /api/search
-                if (pathname === "/api/search" && req.method === "GET") {
-                    const query = url.searchParams.get("query");
-                    const limitVal = url.searchParams.get("limit");
-                    const collectionsStr = url.searchParams.get("collections");
-                    const filterStr = url.searchParams.get("filter");
-                    if (!query) {
-                        sendError(res, 400, "Query parameter 'query' is required.");
-                        return;
-                    }
-                    const limit = limitVal ? Number.parseInt(limitVal, 10) : undefined;
-                    const collections = collectionsStr ? collectionsStr.split(",") : undefined;
-                    const filter = filterStr ? JSON.parse(filterStr) : undefined;
-                    const results = await db.search(query, { limit, collections, filter });
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify(results));
-                    return;
-                }
-                // GET /api/schema
-                if (pathname === "/api/schema" && req.method === "GET") {
-                    const collection = url.searchParams.get("collection") || undefined;
-                    const schemas = await db.schema(collection);
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify(schemas));
-                    return;
-                }
-                // POST /api/nlq
-                if (pathname === "/api/nlq" && req.method === "POST") {
-                    const bodyStr = await readBody(req);
-                    const { question, collection, model, endpoint, apiKey } = JSON.parse(bodyStr);
-                    if (!question) {
-                        sendError(res, 400, "Field 'question' is required.");
-                        return;
-                    }
-                    const llmModel = model || "llama3";
-                    const llmEndpoint = (endpoint || "http://localhost:11434/v1").replace(/\/+$/, "");
-                    const llmApiKey = apiKey || "";
-                    // Step 1: Reflect schema
-                    const schemas = await db.schema(collection || undefined);
-                    if (!schemas || schemas.length === 0) {
-                        sendError(res, 400, "No collections found. Add objects first or specify a valid collection.");
-                        return;
-                    }
-                    // Step 2: Build prompt and call LLM
-                    const systemPrompt = `You are a data analysis assistant. The user has a thingd database with these collections and inferred schemas:
-
-${JSON.stringify(schemas, null, 2)}
-
-You can perform these operations on the data:
-- "aggregate": count/sum/avg/min/max with optional groupBy
-- "timeseries": time-bucketed aggregation by hour/day/week/month
-- "search": full-text search across objects
-
-Respond with ONLY a JSON object (no markdown, no explanation) matching this type:
-{
-  "action": "aggregate" | "timeseries" | "search",
-  "collection": "string (collection name)",
-  "function": "count" | "sum" | "avg" | "min" | "max" (omit for search)",
-  "field": "string (field name for sum/avg/min/max, omit for count)",
-  "groupBy": "string (field name to group by, optional)",
-  "bucket": "hour" | "day" | "week" | "month" (only for timeseries)",
-  "query": "string (search query, only for search action)",
-  "limit": number (optional, max 100)
-}}
-
-Example: { "action": "aggregate", "collection": "orders", "function": "sum", "field": "revenue", "groupBy": "region" }`;
-                    const llmResponse = await fetch(`${llmEndpoint}/chat/completions`, {
-                        method: "POST",
-                        headers: {
-                            "Content-Type": "application/json",
-                            ...(llmApiKey ? { Authorization: `Bearer ${llmApiKey}` } : {}),
-                        },
-                        body: JSON.stringify({
-                            model: llmModel,
-                            messages: [
-                                { role: "system", content: systemPrompt },
-                                { role: "user", content: question },
-                            ],
-                            max_tokens: 1024,
-                            temperature: 0.1,
-                        }),
-                    });
-                    if (!llmResponse.ok) {
-                        const errText = await llmResponse.text();
-                        sendError(res, 502, `LLM returned ${llmResponse.status}: ${errText}`);
-                        return;
-                    }
-                    const llmData = await llmResponse.json();
-                    const llmText = llmData.choices?.[0]?.message?.content;
-                    if (!llmText) {
-                        sendError(res, 502, "LLM returned no choices");
-                        return;
-                    }
-                    // Step 3: Parse intent
-                    const cleaned = llmText
-                        .trim()
-                        .replace(/^```(?:json)?\s*/, "")
-                        .replace(/\s*```$/, "")
-                        .trim();
-                    let intent;
-                    try {
-                        intent = JSON.parse(cleaned);
-                    }
-                    catch {
-                        sendError(res, 502, `Failed to parse LLM response as JSON: ${cleaned}`);
-                        return;
-                    }
-                    // Step 4: Execute
-                    let data;
-                    switch (intent.action) {
-                        case "aggregate": {
-                            const fn = intent.function || "count";
-                            const col = intent.collection;
-                            if (fn === "count") {
-                                data = await db.aggregate.count(col, {
-                                    groupBy: intent.groupBy,
-                                });
-                            }
-                            else if (fn === "sum") {
-                                data = await db.aggregate.sum(col, intent.field, {
-                                    groupBy: intent.groupBy,
-                                });
-                            }
-                            else if (fn === "avg") {
-                                data = await db.aggregate.avg(col, intent.field, {
-                                    groupBy: intent.groupBy,
-                                });
-                            }
-                            else if (fn === "min") {
-                                data = await db.aggregate.min(col, intent.field, {
-                                    groupBy: intent.groupBy,
-                                });
-                            }
-                            else {
-                                data = await db.aggregate.max(col, intent.field, {
-                                    groupBy: intent.groupBy,
-                                });
-                            }
-                            break;
-                        }
-                        case "timeseries": {
-                            const bucket = (intent.bucket || "day");
-                            data = await db.timeseries(intent.collection, {
-                                function: (intent.function || "count"),
-                                bucket,
-                                field: intent.field,
-                            });
-                            break;
-                        }
-                        case "search": {
-                            data = await db.search(intent.query || question, {
-                                collections: [intent.collection],
-                                limit: intent.limit || 10,
-                            });
-                            break;
-                        }
-                        default:
-                            sendError(res, 400, `Unknown action: ${intent.action}`);
-                            return;
-                    }
-                    const result = {
-                        answer: formatAnswer(intent, data),
-                        data,
-                        intent,
-                    };
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify(result));
-                    return;
-                }
-                // GET /api/db/checkpoint
-                if (pathname === "/api/db/checkpoint" && req.method === "GET") {
-                    try {
-                        const result = db.walCheckpoint();
-                        res.writeHead(200, { "Content-Type": "application/json" });
-                        res.end(JSON.stringify(result));
-                    }
-                    catch (e) {
-                        sendError(res, 400, e instanceof Error ? e.message : String(e));
-                    }
-                    return;
-                }
-                // GET /api/db/integrity
-                if (pathname === "/api/db/integrity" && req.method === "GET") {
-                    try {
-                        await db.countObjects();
-                        res.writeHead(200, { "Content-Type": "application/json" });
-                        res.end(JSON.stringify({ ok: true, message: "Database is accessible" }));
-                    }
-                    catch (e) {
-                        res.writeHead(200, { "Content-Type": "application/json" });
-                        res.end(JSON.stringify({ ok: false, message: e instanceof Error ? e.message : String(e) }));
-                    }
-                    return;
-                }
-                // POST /api/backup
-                if (pathname === "/api/backup" && req.method === "POST") {
-                    try {
-                        let body = "";
-                        for await (const chunk of req) {
-                            body += chunk;
-                        }
-                        const { path: backupPath } = JSON.parse(body);
-                        if (!backupPath) {
-                            sendError(res, 400, "Missing 'path' in request body");
-                            return;
-                        }
-                        db.backupTo(backupPath);
-                        const { statSync } = await import("node:fs");
-                        const stats = statSync(backupPath);
-                        res.writeHead(200, { "Content-Type": "application/json" });
-                        res.end(JSON.stringify({ path: backupPath, sizeBytes: stats.size }));
-                    }
-                    catch (e) {
-                        sendError(res, 500, e instanceof Error ? e.message : String(e));
-                    }
-                    return;
-                }
-                // GET /api/config/error-mode
-                if (pathname === "/api/config/error-mode" && req.method === "GET") {
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify({ productionMode: false }));
-                    return;
-                }
-                sendError(res, 404, `Endpoint ${req.method} ${pathname} not found.`);
-                return;
-            }
-            // REST API Routes (/v1/*)
-            if (pathname.startsWith("/v1/")) {
-                await handleRestRequest(db, req, res, pathname);
-                return;
-            }
-            // Static File Server
-            const targetFilePath = pathname === "/" ? "index.html" : pathname.replace(/^\//, "");
-            const fullFilePath = join(publicDir, targetFilePath);
-            // Security: ensure the resolved path is inside the public folder
-            const relativePath = relative(publicDir, fullFilePath);
-            if (isAbsolute(relativePath) || relativePath.startsWith("..")) {
-                res.writeHead(403);
-                res.end("Forbidden");
-                return;
-            }
-            if (existsSync(fullFilePath)) {
-                const fileContent = await fs.readFile(fullFilePath);
-                const ext = extname(fullFilePath).toLowerCase();
-                const contentType = MIME_TYPES[ext] || "application/octet-stream";
-                res.writeHead(200, { "Content-Type": contentType });
-                res.end(fileContent);
-            }
-            else {
-                res.writeHead(404);
-                res.end("Not Found");
-            }
-        }
-        catch (err) {
-            console.error("Dashboard server exception:", err);
-            sendError(res, 500, err instanceof Error ? err.message : String(err));
-        }
-    });
-    return new Promise((resolvePromise, rejectPromise) => {
-        server.listen(port, () => {
-            resolvePromise({
-                server,
-                close: async () => {
-                    await new Promise((closeRes) => server.close(() => closeRes()));
-                    await db.close();
-                },
-            });
-        });
-        server.on("error", (err) => {
-            rejectPromise(err);
-        });
-    });
-}
-function formatAnswer(intent, data) {
-    const fnName = intent.function || "count";
-    const field = intent.field || "objects";
-    switch (intent.action) {
-        case "aggregate": {
-            const d = data;
-            const total = d?.total ?? 0;
-            const groups = d?.groups?.length ?? 0;
-            if (groups > 0) {
-                return `${fnName} of ${field} = ${total}, grouped by ${intent.groupBy} into ${groups} groups`;
-            }
-            return `${fnName} of ${field} = ${total}`;
-        }
-        case "timeseries": {
-            const d = data;
-            return `Time series with ${d?.buckets?.length ?? 0} buckets`;
-        }
-        case "search": {
-            const hits = data?.length ?? 0;
-            return `Found ${hits} results`;
-        }
-        default:
-            return "Query executed.";
-    }
-}

package/dist/data-movement.d.ts

@@ -1,6 +0,0 @@
-import { type CliContext } from "./index.js";
-export declare function runExport(context: CliContext): Promise<void>;
-export declare function runImport(context: CliContext): Promise<void>;
-export declare function runSnapshot(context: CliContext): Promise<void>;
-export declare function runBackup(context: CliContext): Promise<void>;
-//# sourceMappingURL=data-movement.d.ts.map

package/dist/data-movement.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-movement.d.ts","sourceRoot":"","sources":["../src/data-movement.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,KAAK,UAAU,EAAwD,MAAM,YAAY,CAAC;AAwEnG,wBAAsB,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAyClE;AAED,wBAAsB,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAsFlE;AAoND,wBAAsB,WAAW,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAmHpE;AAED,wBAAsB,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAyClE"}