@oxygen-agent/cli 1.1014.136 → 1.1014.618

package/dist/commands/supabase.js

@@ -0,0 +1,128 @@
+import { markStdinConsumed } from "../auto-update.js";
+import { readCsvOption } from "../command-support.js";
+import { requestOxygen } from "../http-client.js";
+import { readOption } from "../util.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+function parseSupabaseTableSelection(value) {
+    const entries = readCsvOption(value);
+    if (entries.length === 0)
+        return undefined;
+    const seen = new Set();
+    return entries.map((entry) => {
+        const separator = entry.indexOf(".");
+        const schema = separator > 0 ? entry.slice(0, separator).trim() : "";
+        const table = separator > 0 ? entry.slice(separator + 1).trim() : "";
+        if (!schema || !table) {
+            throw new OxygenError("invalid_request", `Expected schema.table, received ${entry}.`, {
+                details: { value: entry }, exitCode: 1,
+            });
+        }
+        const key = `${schema}\0${table}`;
+        if (seen.has(key)) {
+            throw new OxygenError("invalid_request", `Duplicate Supabase table: ${entry}.`, { exitCode: 1 });
+        }
+        seen.add(key);
+        return { schema, table };
+    });
+}
+export function registerSupabaseFamily(program, handleAsyncAction) {
+    program
+        .command("supabase")
+        .description("Connect a read-only Supabase database and import selected base tables into durable Oxygen Tables. Catalog, preview, import, status, cancel, and retry all consume 0 credits; imports never write to Supabase.")
+        .addCommand(new Command("connect")
+        .description("Validate and encrypt a managed Supabase PostgreSQL URL. The database role must be read-only; Oxygen refuses writable credentials. Read the URL from stdin to keep it out of shell history and process arguments. Run `oxygen integrations connect supabase --json` first for copyable role setup SQL and the secure web path.")
+        .requiredOption("--database-url-stdin", "Read the Supabase PostgreSQL URL from stdin.")
+        .option("--schemas <schemas>", "Comma-separated user schemas (default: public). Managed/system schemas are refused.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("supabase connect", options, () => {
+            if (options.databaseUrlStdin !== true)
+                throw new Error("--database-url-stdin is required.");
+            markStdinConsumed();
+            const databaseUrl = readFileSync(0, "utf8").trim();
+            if (!databaseUrl)
+                throw new Error("No Supabase database URL was provided on stdin.");
+            return requestOxygen("/api/cli/integrations/connect", {
+                method: "POST",
+                body: {
+                    integration_id: "supabase",
+                    database_url: databaseUrl,
+                    ...(readOption(options.schemas) ? { schemas: readOption(options.schemas) } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("catalog")
+        .description("Inspect readable base tables, columns, PostgreSQL types, primary keys, and estimated rows through the saved read-only connection.")
+        .option("--connection-id <id>", "Use a specific Supabase connection; defaults to the active default.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("supabase catalog", options, () => requestOxygen("/api/cli/supabase/catalog", {
+            method: "POST",
+            body: readOption(options.connectionId) ? { connection_id: readOption(options.connectionId) } : {},
+        }));
+    }))
+        .addCommand(new Command("plan")
+        .description("Preview exact Oxygen Table creates/refreshes, row-limit posture, deletion semantics, and the schema fingerprint required to start. No writes and 0 credits.")
+        .option("--connection-id <id>", "Use a specific Supabase connection.")
+        .option("--tables <schema.tables>", "Comma-separated schema.table names; at most 50 per import. Omit to preview every readable table.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("supabase imports plan", options, () => {
+            const tables = parseSupabaseTableSelection(options.tables);
+            return requestOxygen("/api/cli/supabase/imports/plan", {
+                method: "POST",
+                body: {
+                    ...(readOption(options.connectionId) ? { connection_id: readOption(options.connectionId) } : {}),
+                    ...(tables ? { tables } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("import")
+        .description("Start the previously previewed snapshot/refresh as durable Postgres-backed work. Creates one Oxygen Table per new source; refreshes primary-keyed sources in place and marks missing source rows instead of deleting them. Consumes 0 credits.")
+        .requiredOption("--tables <schema.tables>", "Comma-separated schema.table names from the plan; at most 50 per import.")
+        .requiredOption("--catalog-fingerprint <sha256>", "Fingerprint returned by the latest plan; prevents importing against a changed schema.")
+        .option("--connection-id <id>", "Use a specific Supabase connection.")
+        .option("--project <id-or-slug>", "Create new Oxygen Tables in this project/folder.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("supabase imports start", options, () => {
+            const tables = parseSupabaseTableSelection(options.tables);
+            if (!tables)
+                throw new Error("--tables is required.");
+            return requestOxygen("/api/cli/supabase/imports", {
+                method: "POST",
+                body: {
+                    tables,
+                    catalog_fingerprint: readOption(options.catalogFingerprint),
+                    ...(readOption(options.connectionId) ? { connection_id: readOption(options.connectionId) } : {}),
+                    ...(readOption(options.project) ? { project: readOption(options.project) } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("get")
+        .description("Get aggregate and per-table status, row counts, failures, and deep-links for a Supabase import.")
+        .argument("<import_id>", "Supabase import id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (importId, options) => {
+        await handleAsyncAction("supabase imports get", options, () => requestOxygen(`/api/cli/supabase/imports/${encodeURIComponent(importId)}`));
+    }))
+        .addCommand(new Command("cancel")
+        .description("Request cancellation of every still-active child table run in an import.")
+        .argument("<import_id>", "Supabase import id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (importId, options) => {
+        await handleAsyncAction("supabase imports cancel", options, () => requestOxygen(`/api/cli/supabase/imports/${encodeURIComponent(importId)}/cancel`, { method: "POST", body: {} }));
+    }))
+        .addCommand(new Command("retry")
+        .description("Retry failed child table items without duplicating already-upserted source rows.")
+        .argument("<import_id>", "Supabase import id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (importId, options) => {
+        await handleAsyncAction("supabase imports retry", options, () => requestOxygen(`/api/cli/supabase/imports/${encodeURIComponent(importId)}/retry`, { method: "POST", body: {} }));
+    }));
+}

package/dist/commands/support.d.ts

@@ -0,0 +1,3 @@
+import { ExtractedCommandActionHandler } from "../command-support.js";
+import { Command } from "commander";
+export declare function registerSupportFamily(program: Command, handleAsyncAction: ExtractedCommandActionHandler): void;