deepline 0.3.293 → 0.3.295

package/dist/cli/db-CLODWCOB.mjs

@@ -0,0 +1,486 @@
+import {
+  DeeplineClient
+} from "./chunk-XL2FO6CW.mjs";
+import "./chunk-CBVIJSHF.mjs";
+import {
+  argsWantJson,
+  dataExportColumns,
+  dataExportCsvString,
+  dataExportRows,
+  markdownTableFromRows,
+  printCommandEnvelope,
+  recordRows
+} from "./chunk-6O5YZOVN.mjs";
+import "./chunk-EACVZI6N.mjs";
+import "./chunk-DLIRSHV6.mjs";
+import "./chunk-LDWT7RJK.mjs";
+import "./chunk-GVUJJJ5G.mjs";
+import {
+  DeeplineError
+} from "./chunk-NXGCO4JB.mjs";
+import "./chunk-WZYKRD7T.mjs";
+import "./chunk-KRD6H754.mjs";
+
+// src/cli/commands/db.ts
+import { readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+var CUSTOMER_DB_QUERY_FORMATS = /* @__PURE__ */ new Set(["table", "json", "csv", "markdown"]);
+var CUSTOMER_DB_QUERY_MAX_ROWS = 1e3;
+function parsePositiveInteger(value, flagName) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${flagName} must be a positive integer.`);
+  }
+  return parsed;
+}
+function parseMaxRows(value) {
+  const parsed = parsePositiveInteger(value, "--max-rows");
+  if (parsed > CUSTOMER_DB_QUERY_MAX_ROWS) {
+    throw new Error(
+      `--max-rows must be ${CUSTOMER_DB_QUERY_MAX_ROWS} or less. Add LIMIT/OFFSET to page larger exports.`
+    );
+  }
+  return parsed;
+}
+function formatCell(value) {
+  if (value === null || value === void 0) return "";
+  const text = typeof value === "object" ? JSON.stringify(value) : String(value);
+  return text.length > 80 ? `${text.slice(0, 77)}...` : text;
+}
+function tableLines(result) {
+  const rows = dataExportRows(customerDbRows(result));
+  const responseColumns = dataExportColumns(
+    rows,
+    customerDbColumnNames(result)
+  );
+  const businessColumns = responseColumns.filter(
+    (column) => !column.startsWith("_")
+  );
+  const columns = businessColumns.length > 0 ? businessColumns : responseColumns;
+  const hiddenColumns = responseColumns.filter(
+    (column) => !columns.includes(column)
+  );
+  const lines = [
+    `${result.command} returned ${result.row_count_returned} row(s)` + (result.truncated ? " (truncated)" : "")
+  ];
+  if (hiddenColumns.length > 0) {
+    lines.push(
+      `Showing ${columns.length}/${responseColumns.length} columns; hidden metadata: ${hiddenColumns.join(", ")}`
+    );
+    lines.push(
+      "Use --json or select metadata columns explicitly when you need run ids/errors/stages."
+    );
+  }
+  if (rows.length === 0) {
+    return lines;
+  }
+  const widths = columns.map(
+    (column) => Math.min(
+      80,
+      Math.max(
+        column.length,
+        ...rows.slice(0, 20).map((row) => formatCell(row[column]).length)
+      )
+    )
+  );
+  lines.push(
+    columns.map((column, index) => column.padEnd(widths[index])).join("  ")
+  );
+  lines.push(widths.map((width) => "-".repeat(width)).join("  "));
+  for (const row of rows) {
+    lines.push(
+      columns.map((column, index) => formatCell(row[column]).padEnd(widths[index])).join("  ")
+    );
+  }
+  return lines;
+}
+function customerDbRows(result) {
+  return recordRows(result.rows);
+}
+function customerDbColumnNames(result) {
+  return result.columns.map((column) => column.name).filter(Boolean);
+}
+function errorMessage(value) {
+  return value instanceof Error ? value.message : String(value ?? "");
+}
+function resolveDbQuerySql(rawSql, readFile = (path) => readFileSync(path, "utf8")) {
+  const value = rawSql.trim();
+  if (!value.startsWith("@")) return value;
+  const filePath = value.slice(1).trim();
+  if (!filePath) {
+    throw new Error("--sql @file requires a file path after `@`.");
+  }
+  return readFile(resolve(filePath)).trim();
+}
+function collectErrorText(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return errorMessage(value);
+  }
+  const record = value;
+  return [
+    errorMessage(value),
+    typeof record.error === "string" ? record.error : "",
+    typeof record.message === "string" ? record.message : "",
+    typeof record.detail === "string" ? record.detail : "",
+    typeof record.hint === "string" ? record.hint : "",
+    typeof record.code === "string" ? record.code : "",
+    record.response ? collectErrorText(record.response) : "",
+    record.details ? collectErrorText(record.details) : ""
+  ].filter(Boolean).join("\n");
+}
+function formatDbQueryError(sql, error) {
+  const text = collectErrorText(error);
+  const lower = text.toLowerCase();
+  const referencesStorage = /"storage"\.|storage\./i.test(sql);
+  const runIdColumnMissing = /column\s+"?run_id"?\s+does not exist/i.test(text) || /run_id.*does not exist/i.test(lower);
+  const relationMissing = /relation\s+["']?[^"']*storage[^"']*["']?\s+does not exist/i.test(text) || /42p01/i.test(text);
+  if (referencesStorage && relationMissing) {
+    return [
+      "Customer DB query failed: the referenced storage table does not exist.",
+      "Play dataset tables are created only when the corresponding ctx.dataset(...).run(...) call executes. Pilot branches, early returns, and runs that fail before the dataset do not create that table.",
+      "Use `deepline runs get <run-id> --full --json` to inspect returned dataset handles, then export them with `deepline runs export <run-id> --dataset result.rows --out rows.csv`.",
+      `Original error: ${errorMessage(error)}`
+    ].join("\n");
+  }
+  if (referencesStorage && runIdColumnMissing) {
+    return [
+      "Customer DB query failed: storage dataset tables use `_run_id`, not `run_id`.",
+      "Prefer `deepline runs export <run-id> --dataset result.rows --out rows.csv` unless you are doing deep table debugging.",
+      `Original error: ${errorMessage(error)}`
+    ].join("\n");
+  }
+  if (error instanceof DeeplineError) {
+    return error.message;
+  }
+  return errorMessage(error);
+}
+function dbRepairHumanLines(result) {
+  const repair = result.repair;
+  return [
+    "Workspace storage repair completed.",
+    ...repair ? [
+      `Location changed: ${repair.location.changed ? "yes" : "no"}`,
+      `Storage contract: ${repair.storage_contract.current ? "current" : "not ready"}`,
+      `Runtime migration: ${repair.runtime_migration.current ? "current" : "not ready"}`,
+      `Runtime capability probe: ${repair.runtime_capabilities.after.runtime_capabilities_ready ? "passed" : "failed"}`,
+      `Materialized table grants reconciled: ${repair.materialized_tables.repaired_count}`
+    ] : [
+      "Runtime capability probe: unavailable from this server version",
+      `Materialized table grants reconciled: ${result.count}`
+    ],
+    `Runtime role: ${result.connection_grants.runtime_role}`,
+    `Customer DB role: ${result.connection_grants.customer_db_role}`
+  ];
+}
+function dbRepairPlainText(result) {
+  return result.repair ? "Workspace storage repair completed. Runtime capability probe passed.\n" : `Workspace storage repair completed. ${result.count} materialized table grant(s) reconciled; runtime capability probe unavailable.
+`;
+}
+function writeCustomerDbCsv(result, outPath) {
+  const resolved = resolve(outPath);
+  writeFileSync(
+    resolved,
+    dataExportCsvString(customerDbRows(result), customerDbColumnNames(result)),
+    "utf-8"
+  );
+  return resolved;
+}
+function dbQueryExportEnvelope(input) {
+  const destination = input.outPath ?? "stdout";
+  return {
+    command: input.result.command,
+    format: input.format,
+    row_count: input.result.row_count,
+    row_count_returned: input.result.row_count_returned,
+    truncated: input.result.truncated,
+    ...input.outPath ? { file: input.outPath, local: { file: input.outPath } } : {},
+    next: { toolEquivalent: input.toolCommand },
+    render: {
+      sections: [
+        {
+          title: "customer db export",
+          lines: [
+            `Rendered ${input.result.row_count_returned} row(s) as ${input.format} to ${destination}`
+          ]
+        }
+      ],
+      actions: [{ label: "Tool equivalent", command: input.toolCommand }]
+    }
+  };
+}
+async function handleDbQuery(args) {
+  const sqlIndex = args.indexOf("--sql");
+  const rawSql = sqlIndex >= 0 ? args[sqlIndex + 1]?.trim() : "";
+  if (!rawSql) {
+    console.error(
+      'Usage: deepline db query --sql "select * from table limit 20"|@query.sql [--max-rows N] [--json]'
+    );
+    return 1;
+  }
+  let sql;
+  try {
+    sql = resolveDbQuerySql(rawSql);
+  } catch (error) {
+    console.error(errorMessage(error));
+    return 1;
+  }
+  if (!sql) {
+    console.error("SQL file is empty.");
+    return 1;
+  }
+  const maxRowsIndex = args.indexOf("--max-rows");
+  const maxRows = maxRowsIndex >= 0 && args[maxRowsIndex + 1] ? parseMaxRows(args[maxRowsIndex + 1]) : void 0;
+  const formatIndex = args.indexOf("--format");
+  const format = formatIndex >= 0 ? args[formatIndex + 1]?.trim().toLowerCase() : "";
+  if (format && !CUSTOMER_DB_QUERY_FORMATS.has(format)) {
+    console.error(
+      'Usage: deepline db query --sql "select * from table limit 20" [--format table|json|csv|markdown] [--out path]'
+    );
+    return 1;
+  }
+  const outIndex = args.indexOf("--out");
+  const outPath = outIndex >= 0 ? args[outIndex + 1]?.trim() : "";
+  if (outIndex >= 0 && !outPath) {
+    console.error("--out requires a path.");
+    return 1;
+  }
+  const jsonOutput = argsWantJson(args);
+  const explicitJsonOutput = args.includes("--json");
+  const client = new DeeplineClient();
+  let result;
+  try {
+    result = await client.db.query({ sql, maxRows });
+  } catch (error) {
+    console.error(formatDbQueryError(sql, error));
+    return 1;
+  }
+  const toolCommand = `deepline tools execute query_customer_db --payload ${JSON.stringify(
+    {
+      sql,
+      ...maxRows ? { max_rows: maxRows } : {}
+    }
+  )} --json`;
+  if (format === "csv") {
+    if (outPath) {
+      const exportedPath = writeCustomerDbCsv(result, outPath);
+      printCommandEnvelope(
+        dbQueryExportEnvelope({
+          result,
+          format,
+          outPath: exportedPath,
+          toolCommand
+        }),
+        {
+          json: jsonOutput,
+          text: `Exported ${result.row_count_returned} row(s) to ${exportedPath}
+`
+        }
+      );
+      return 0;
+    }
+    printCommandEnvelope(
+      dbQueryExportEnvelope({
+        result,
+        format,
+        outPath: null,
+        toolCommand
+      }),
+      {
+        json: explicitJsonOutput,
+        text: dataExportCsvString(
+          customerDbRows(result),
+          customerDbColumnNames(result)
+        )
+      }
+    );
+    return 0;
+  }
+  if (format === "markdown") {
+    const content = markdownTableFromRows(
+      customerDbRows(result),
+      customerDbColumnNames(result)
+    );
+    if (outPath) {
+      const exportedPath = resolve(outPath);
+      writeFileSync(exportedPath, content, "utf-8");
+      printCommandEnvelope(
+        dbQueryExportEnvelope({
+          result,
+          format,
+          outPath: exportedPath,
+          toolCommand
+        }),
+        {
+          json: jsonOutput,
+          text: `Exported ${result.row_count_returned} row(s) to ${exportedPath}
+`
+        }
+      );
+      return 0;
+    }
+    printCommandEnvelope(
+      dbQueryExportEnvelope({
+        result,
+        format,
+        outPath: null,
+        toolCommand
+      }),
+      {
+        json: explicitJsonOutput,
+        text: content
+      }
+    );
+    return 0;
+  }
+  printCommandEnvelope(
+    {
+      ...result,
+      next: { toolEquivalent: toolCommand },
+      render: {
+        sections: [{ title: "customer db query", lines: tableLines(result) }],
+        actions: [{ label: "Tool equivalent", command: toolCommand }]
+      }
+    },
+    {
+      json: explicitJsonOutput || format === "json" || format !== "table" && jsonOutput
+    }
+  );
+  return 0;
+}
+async function handleDbRepair(args) {
+  const providerIndex = args.indexOf("--provider");
+  const provider = providerIndex >= 0 ? args[providerIndex + 1]?.trim() : void 0;
+  const jsonOutput = argsWantJson(args);
+  const client = new DeeplineClient();
+  let result;
+  try {
+    result = await client.repairIngestionStorage(
+      provider ? { provider } : void 0
+    );
+  } catch (error) {
+    if (error instanceof DeeplineError && error.statusCode === 403) {
+      console.error(
+        "deepline db repair requires org admin. Ask an organization admin to run it."
+      );
+      return 1;
+    }
+    console.error(errorMessage(error));
+    return 1;
+  }
+  printCommandEnvelope(
+    {
+      command: "db repair",
+      status: result.status,
+      repaired: result.repaired,
+      count: result.count,
+      connection_grants: result.connection_grants,
+      repair: result.repair,
+      render: {
+        sections: [
+          {
+            title: "storage contract repair",
+            lines: dbRepairHumanLines(result)
+          }
+        ]
+      }
+    },
+    {
+      json: jsonOutput,
+      text: dbRepairPlainText(result)
+    }
+  );
+  return 0;
+}
+function registerDbCommands(program) {
+  const db = program.command("db").description("Query the tenant customer database.").addHelpText(
+    "after",
+    `
+  Notes:
+  Agent-safe SQL for the active workspace customer database.
+  Use --sql @query.sql for multiline or shell-sensitive SQL (portable across macOS and Windows).
+  Reads: SELECT, EXPLAIN, and read-only WITH can inspect permitted schemas.
+  Writes: CREATE TABLE, INSERT, UPDATE, DELETE, ALTER, DROP, TRUNCATE, and
+  CREATE INDEX must target schema-qualified storage tables, such as storage.agent_notes.
+  If CREATE TABLE blocked (...) fails, use CREATE TABLE storage.blocked (...).
+  Results are bounded by the server and --max-rows. Use --json for stable output.
+  Use --format csv or --format markdown for agent-readable exports and display tables.
+
+Examples:
+  deepline db query --sql "select * from companies limit 20"
+  deepline db query --sql "select domain, name from companies limit 20" --json
+  deepline db query --sql "create table if not exists storage.agent_notes (id text primary key, note text not null)"
+  deepline db query --sql "select * from contacts" --max-rows 100 --json
+  deepline db query --sql @query.sql --json
+  deepline db query --sql "select * from contacts limit 20" --format csv --out contacts.csv
+  deepline db query --sql "select domain, name from companies limit 20" --format markdown
+`
+  );
+  db.command("query").description("Run SQL against the tenant customer database.").addHelpText(
+    "after",
+    `
+  Notes:
+  Requires --sql (inline SQL or @file.sql). Output defaults to a compact table in a terminal
+  and JSON when stdout is piped. --format table forces a table even in pipes.
+  --json overrides --format for stdout. The active auth workspace determines scope.
+  Read permitted schemas with SELECT, EXPLAIN, or read-only WITH.
+  Write only to schema-qualified storage tables. For example, use
+  CREATE TABLE storage.blocked (...) instead of CREATE TABLE blocked (...).
+  --format csv and --format markdown are explicit data/display formats and can
+  be written directly with --out.
+
+Examples:
+  deepline db query --sql "select * from companies limit 20"
+  deepline db query --sql "select domain, name from companies limit 20" --json
+  deepline db query --sql "create table if not exists storage.agent_notes (id text primary key, note text not null)"
+  deepline db query --sql "select count(*) from contacts" --json
+  deepline db query --sql @query.sql --json
+  deepline db query --sql "select * from contacts limit 20" --format csv --out contacts.csv
+  deepline db query --sql "select domain, name from companies limit 20" --format markdown
+`
+  ).requiredOption("--sql <sql>", "SQL statement").option("--max-rows <n>", "Maximum returned rows").option("--format <format>", "Output format: table, json, csv, or markdown").option("--out <path>", "Write csv or markdown output to a file").option(
+    "--json",
+    "Emit raw JSON response. Also automatic when stdout is piped"
+  ).action(async (options) => {
+    process.exitCode = await handleDbQuery([
+      "--sql",
+      options.sql,
+      ...options.maxRows ? ["--max-rows", options.maxRows] : [],
+      ...options.format ? ["--format", options.format] : [],
+      ...options.out ? ["--out", options.out] : [],
+      ...options.json ? ["--json"] : []
+    ]);
+  });
+  db.command("repair").description(
+    "Repair this workspace storage contract (role/DB grants). Org admin only."
+  ).addHelpText(
+    "after",
+    `
+Notes:
+  Re-establishes tenant runtime and customer-db role grants plus materialized
+  table grants for the active workspace. Run this after a play run fails with
+  WORKSPACE_STORAGE_NOT_READY, then re-run the play. Requires org admin.
+
+Examples:
+  deepline db repair
+  deepline db repair --json
+`
+  ).option(
+    "--provider <provider>",
+    "Limit materialized-table repair to one provider"
+  ).option(
+    "--json",
+    "Emit raw JSON response. Also automatic when stdout is piped"
+  ).action(async (options) => {
+    process.exitCode = await handleDbRepair([
+      ...options.provider ? ["--provider", options.provider] : [],
+      ...options.json ? ["--json"] : []
+    ]);
+  });
+}
+export {
+  dbRepairHumanLines,
+  dbRepairPlainText,
+  registerDbCommands,
+  resolveDbQuerySql,
+  writeCustomerDbCsv
+};