@thingd/cli 0.31.0

package/dist/dashboard/server.js

@@ -0,0 +1,385 @@
+import { existsSync, promises as fs, statSync } from "node:fs";
+import { createServer } from "node:http";
+import { dirname, extname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { handleRestRequest, ThingD } from "@thingd/node";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// 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",
+};
+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,
+    });
+    // 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
+            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;
+            }
+            // 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 } = JSON.parse(bodyStr);
+                    if (!path || !driver) {
+                        sendError(res, 400, "Fields 'path' and 'driver' are required.");
+                        return;
+                    }
+                    // Safely shut down the old db instance
+                    await db.close();
+                    // Spawn new db connection dynamically
+                    db = await ThingD.open({
+                        path,
+                        url: isCloudPath(path) ? path : undefined,
+                        driver,
+                        authToken,
+                    });
+                    activeOptions = {
+                        path,
+                        driver,
+                        authToken,
+                        cloud: isCloudPath(path),
+                    };
+                    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({
+                        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;
+                }
+                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
+            if (!fullFilePath.startsWith(publicDir)) {
+                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);
+        });
+    });
+}

package/dist/data-movement.d.ts

@@ -0,0 +1,5 @@
+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>;
+//# sourceMappingURL=data-movement.d.ts.map

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

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

package/dist/data-movement.js

@@ -0,0 +1,257 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { hasFlag, requiredFlag, stringFlag, withDb, writeJson } from "./index.js";
+const DEFAULT_REDACT_KEYS = [
+    "password",
+    "secret",
+    "token",
+    "key",
+    "auth",
+    "credential",
+    "email",
+    "phone",
+    "session",
+    "cookie",
+    "signature",
+    "private",
+    "cert",
+    "api",
+];
+function redactText(text) {
+    let res = text;
+    // Redact emails
+    res = res.replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, "[REDACTED_EMAIL]");
+    // Redact API keys matching sk-...
+    res = res.replace(/sk-[a-zA-Z0-9]{20,}/g, "[REDACTED_KEY]");
+    // Redact Bearer tokens
+    res = res.replace(/bearer\s+[a-zA-Z0-9\-._~+/]+=*/gi, "Bearer [REDACTED]");
+    return res;
+}
+function redactValue(val, redactKeys) {
+    if (val === null || val === undefined) {
+        return val;
+    }
+    if (Array.isArray(val)) {
+        return val.map((item) => redactValue(item, redactKeys));
+    }
+    if (typeof val === "object") {
+        const obj = val;
+        const result = {};
+        for (const [k, v] of Object.entries(obj)) {
+            const lowerKey = k.toLowerCase();
+            const shouldRedact = redactKeys.some((rKey) => lowerKey.includes(rKey.toLowerCase()));
+            if (shouldRedact) {
+                result[k] = "[REDACTED]";
+            }
+            else if (v && typeof v === "object") {
+                result[k] = redactValue(v, redactKeys);
+            }
+            else if (typeof v === "string" && k === "text") {
+                result[k] = redactText(v);
+            }
+            else {
+                result[k] = v;
+            }
+        }
+        return result;
+    }
+    return val;
+}
+export async function runExport(context) {
+    const isEvents = hasFlag(context.parsed, "events");
+    const collection = stringFlag(context.parsed, "collection");
+    const outPath = requiredFlag(context.parsed, "out");
+    if (!isEvents && !collection) {
+        throw new Error("Must specify either --collection <name> or --events for export.");
+    }
+    if (isEvents && collection) {
+        throw new Error("Cannot specify both --collection <name> and --events.");
+    }
+    await withDb(context, async (db) => {
+        const redactFlag = stringFlag(context.parsed, "redact");
+        const isRedact = hasFlag(context.parsed, "redact");
+        const redactKeys = isRedact
+            ? redactFlag
+                ? redactFlag.split(",").map((k) => k.trim())
+                : DEFAULT_REDACT_KEYS
+            : null;
+        let lines = [];
+        if (collection) {
+            const objects = await db.listObjects(collection);
+            lines = objects.map((obj) => {
+                const finalObj = redactKeys ? redactValue(obj, redactKeys) : obj;
+                return JSON.stringify(finalObj);
+            });
+        }
+        else {
+            const stream = stringFlag(context.parsed, "stream");
+            const events = await db.events.list(stream);
+            lines = events.map((ev) => {
+                const finalEv = redactKeys ? redactValue(ev, redactKeys) : ev;
+                return JSON.stringify(finalEv);
+            });
+        }
+        writeFileSync(resolve(outPath), `${lines.join("\n")}\n`, "utf8");
+        writeJson(context.stdout, { success: true, count: lines.length, out: outPath }, context.pretty);
+    });
+}
+export async function runImport(context) {
+    const collection = requiredFlag(context.parsed, "collection");
+    const inPath = requiredFlag(context.parsed, "in");
+    const resolvedPath = resolve(inPath);
+    if (!existsSync(resolvedPath)) {
+        throw new Error(`Input file not found: ${inPath}`);
+    }
+    const content = readFileSync(resolvedPath, "utf8");
+    const lines = content
+        .split("\n")
+        .map((l) => l.trim())
+        .filter(Boolean);
+    // Detect file type
+    const isCsv = inPath.endsWith(".csv");
+    await withDb(context, async (db) => {
+        let count = 0;
+        if (isCsv) {
+            // Parse CSV
+            const headers = lines[0]?.split(",").map((h) => h.trim()) ?? [];
+            for (let i = 1; i < lines.length; i++) {
+                const values = lines[i]?.split(",") ?? [];
+                const obj = {};
+                for (let j = 0; j < headers.length; j++) {
+                    const key = headers[j];
+                    if (!key) {
+                        continue;
+                    }
+                    const val = values[j]?.trim() ?? "";
+                    // Try to infer types
+                    if (val === "" || val === "null") {
+                        obj[key] = null;
+                    }
+                    else if (val === "true") {
+                        obj[key] = true;
+                    }
+                    else if (val === "false") {
+                        obj[key] = false;
+                    }
+                    else if (!Number.isNaN(Number(val))) {
+                        obj[key] = Number(val);
+                    }
+                    else {
+                        obj[key] = val;
+                    }
+                }
+                // Add row index as ID if not present
+                if (!obj.id) {
+                    obj.id = `row-${i}`;
+                }
+                await db.put(collection, obj);
+                count += 1;
+            }
+        }
+        else {
+            // Parse JSONL
+            for (const line of lines) {
+                const parsedObj = JSON.parse(line);
+                if (!parsedObj.id || typeof parsedObj.id !== "string") {
+                    throw new Error("Imported object must contain a string 'id' field.");
+                }
+                await db.put(collection, parsedObj);
+                count += 1;
+            }
+        }
+        writeJson(context.stdout, { success: true, count, collection, format: isCsv ? "csv" : "jsonl" }, context.pretty);
+    });
+}
+export async function runSnapshot(context) {
+    const subCommand = context.parsed.tokens[1];
+    if (subCommand === "create") {
+        const outPath = requiredFlag(context.parsed, "out");
+        await withDb(context, async (db) => {
+            const collectionsMap = {};
+            const cols = await db.listCollections();
+            for (const col of cols) {
+                collectionsMap[col] = await db.listObjects(col);
+            }
+            const eventsList = await db.events.list();
+            const queuesMap = {};
+            const queues = await db.listQueues();
+            for (const q of queues) {
+                const queue = db.queue(q);
+                const [active, dead] = await Promise.all([queue.list(), queue.dead()]);
+                queuesMap[q] = { active, dead };
+            }
+            const snapshot = {
+                version: "1.0.0",
+                timestamp: new Date().toISOString(),
+                collections: collectionsMap,
+                events: eventsList,
+                queues: queuesMap,
+            };
+            writeFileSync(resolve(outPath), JSON.stringify(snapshot, null, 2), "utf8");
+            writeJson(context.stdout, { success: true, out: outPath }, context.pretty);
+        });
+    }
+    else if (subCommand === "restore") {
+        const inPath = requiredFlag(context.parsed, "in");
+        const resolvedPath = resolve(inPath);
+        if (!existsSync(resolvedPath)) {
+            throw new Error(`Snapshot file not found: ${inPath}`);
+        }
+        const snapshot = JSON.parse(readFileSync(resolvedPath, "utf8"));
+        if (snapshot.version !== "1.0.0") {
+            throw new Error(`Unsupported snapshot version: ${snapshot.version}`);
+        }
+        await withDb(context, async (db) => {
+            // 1. Restore Collections (clear existing first for true restore)
+            if (snapshot.collections) {
+                for (const [colName, objects] of Object.entries(snapshot.collections)) {
+                    const currentObjs = await db.listObjects(colName);
+                    for (const obj of currentObjs) {
+                        await db.delete(colName, obj.id);
+                    }
+                    for (const obj of objects) {
+                        const cleanObj = { ...obj };
+                        delete cleanObj.collection;
+                        delete cleanObj.createdAt;
+                        delete cleanObj.updatedAt;
+                        delete cleanObj.version;
+                        await db.put(colName, cleanObj);
+                    }
+                }
+            }
+            // 2. Restore Events
+            if (snapshot.events) {
+                for (const ev of snapshot.events) {
+                    const cleanEv = { ...ev };
+                    delete cleanEv.id;
+                    delete cleanEv.createdAt;
+                    delete cleanEv.stream;
+                    await db.events.append(ev.stream, cleanEv);
+                }
+            }
+            // 3. Restore Queues
+            if (snapshot.queues) {
+                for (const [qName, jobsData] of Object.entries(snapshot.queues)) {
+                    const queue = db.queue(qName);
+                    const { active, dead } = jobsData;
+                    for (const job of active) {
+                        await queue.push(job.payload, {
+                            idempotencyKey: job.id,
+                            maxAttempts: job.maxAttempts,
+                        });
+                    }
+                    for (const job of dead) {
+                        await queue.push(job.payload, {
+                            idempotencyKey: job.id,
+                            maxAttempts: job.maxAttempts,
+                        });
+                    }
+                }
+            }
+            writeJson(context.stdout, { success: true, in: inPath }, context.pretty);
+        });
+    }
+    else {
+        throw new Error(`Unknown snapshot command: ${subCommand}. Expected 'create' or 'restore'.`);
+    }
+}

package/dist/doctor.d.ts

@@ -0,0 +1,3 @@
+import { type CliContext } from "./index.js";
+export declare function runDoctor(context: CliContext): Promise<void>;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../src/doctor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,UAAU,EAAqB,MAAM,YAAY,CAAC;AAEhE,wBAAsB,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAwIlE"}