deepline 0.3.294 → 0.3.296

package/dist/cli/client-CZDA4JKO.mjs

@@ -0,0 +1,20 @@
+import {
+  DeeplineClient,
+  MONITOR_JOB_PHASES,
+  MONITOR_JOB_RECONCILIATION_STATES,
+  MONITOR_JOB_STATES
+} from "./chunk-J2D3VDOU.mjs";
+import "./chunk-CBVIJSHF.mjs";
+import "./chunk-NPPJX3BL.mjs";
+import "./chunk-DLIRSHV6.mjs";
+import "./chunk-QSIO4TX2.mjs";
+import "./chunk-GVUJJJ5G.mjs";
+import "./chunk-NXGCO4JB.mjs";
+import "./chunk-WZYKRD7T.mjs";
+import "./chunk-KRD6H754.mjs";
+export {
+  DeeplineClient,
+  MONITOR_JOB_PHASES,
+  MONITOR_JOB_RECONCILIATION_STATES,
+  MONITOR_JOB_STATES
+};

package/dist/cli/client-IZGIN2ZA.js

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _chunk2C3AVPTYjs = require('./chunk-2C3AVPTY.js');
+require('./chunk-LA46MMTL.js');
+require('./chunk-6HPEDBSJ.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-LIKFCE7Z.js');
+require('./chunk-6A3TJUWC.js');
+require('./chunk-7P5AA3SN.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+exports.DeeplineClient = _chunk2C3AVPTYjs.DeeplineClient; exports.MONITOR_JOB_PHASES = _chunk2C3AVPTYjs.MONITOR_JOB_PHASES; exports.MONITOR_JOB_RECONCILIATION_STATES = _chunk2C3AVPTYjs.MONITOR_JOB_RECONCILIATION_STATES; exports.MONITOR_JOB_STATES = _chunk2C3AVPTYjs.MONITOR_JOB_STATES;

package/dist/cli/csv-6KOMZA2H.mjs

@@ -0,0 +1,585 @@
+import {
+  clip,
+  csvStringFromRows,
+  printCommandEnvelope,
+  printJson,
+  readCsvRows
+} from "./chunk-NTEZFZLE.mjs";
+import "./chunk-NPPJX3BL.mjs";
+import "./chunk-DLIRSHV6.mjs";
+import "./chunk-QSIO4TX2.mjs";
+import "./chunk-NXGCO4JB.mjs";
+import "./chunk-WZYKRD7T.mjs";
+import "./chunk-KRD6H754.mjs";
+
+// src/cli/commands/csv.ts
+import { Option } from "commander";
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+function parseRowRange(raw) {
+  const source = raw?.trim() || "0:19";
+  const [startRaw, endRaw] = source.split(":", 2);
+  const start = Number.parseInt(startRaw ?? "", 10);
+  const end = Number.parseInt(endRaw ?? "", 10);
+  if (!Number.isFinite(start) || !Number.isFinite(end) || start < 0 || end < start) {
+    throw new Error(
+      `Invalid --rows value: ${source} (expected start:end, e.g. 0:19).`
+    );
+  }
+  return [start, end];
+}
+function selectRows(rows, start, end) {
+  return rows.slice(start, end + 1);
+}
+function selectColumns(rows, rawColumns, rawExcludeColumns, availableColumns) {
+  const parseNames = (raw, flag) => {
+    if (raw === void 0) return null;
+    const names = raw.split(",").map((part) => part.trim());
+    if (names.some((name) => !name)) {
+      throw new Error(
+        `Invalid ${flag} value: provide comma-separated column names.`
+      );
+    }
+    const missing = names.filter((name) => !availableColumns.includes(name));
+    if (missing.length > 0) {
+      throw new Error(`Unknown ${flag} value(s): ${missing.join(", ")}.`);
+    }
+    return [...new Set(names)];
+  };
+  const included = parseNames(rawColumns, "--columns") ?? availableColumns;
+  const excluded = new Set(
+    parseNames(rawExcludeColumns, "--exclude-columns") ?? []
+  );
+  const requested = included.filter((name) => !excluded.has(name));
+  if (requested.length === 0 && availableColumns.length > 0) {
+    throw new Error("No columns remain after --columns and --exclude-columns.");
+  }
+  return {
+    columns: requested,
+    rows: rows.map((row) => {
+      const next = {};
+      for (const column of requested) next[column] = row[column] ?? "";
+      return next;
+    })
+  };
+}
+function summarizeColumns(rows, columns) {
+  return columns.map((column) => {
+    let missing = 0;
+    const counts = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const value = row[column] ?? "";
+      if (!value.trim()) {
+        missing += 1;
+      } else {
+        counts.set(value, (counts.get(value) ?? 0) + 1);
+      }
+    }
+    const present = rows.length - missing;
+    const ranked = [...counts.entries()].sort((a, b) => b[1] - a[1]);
+    const top = counts.size < present ? ranked.slice(0, 3) : [];
+    const topCount = top.reduce((sum, [, count]) => sum + count, 0);
+    return {
+      column,
+      present,
+      missing,
+      present_percent: rows.length ? Math.round(present / rows.length * 100) : 0,
+      unique: counts.size,
+      top_values: top.map(([value, count]) => ({
+        value,
+        count,
+        percent: rows.length ? Math.round(count / rows.length * 100) : 0
+      })),
+      other_count: top.length > 0 ? present - topCount : 0
+    };
+  });
+}
+function summaryDisplayRows(summaries) {
+  return summaries.map((summary) => ({
+    column: summary.column,
+    present: String(summary.present),
+    missing: String(summary.missing),
+    present_percent: `${summary.present_percent}%`,
+    unique: String(summary.unique),
+    top_values: summary.top_values.map(({ value, count, percent }) => `${value}: ${count} (${percent}%)`).join(", "),
+    other_count: String(summary.other_count)
+  }));
+}
+function renderTable(rows, totalRows, verbose, footer = `showing ${rows.length} row(s) of ${totalRows}`) {
+  const columns = Object.keys(rows[0] ?? {});
+  if (columns.length === 0) return "No rows.";
+  const widths = Object.fromEntries(
+    columns.map((column) => [
+      column,
+      Math.max(
+        column.length,
+        ...rows.map((row) => {
+          const value = row[column] ?? "";
+          return (verbose ? value : clip(value, 42)).length;
+        })
+      )
+    ])
+  );
+  const header = columns.map((column) => column.padEnd(widths[column])).join(" | ");
+  const divider = columns.map((column) => "-".repeat(widths[column])).join("-+-");
+  const body = rows.map(
+    (row) => columns.map((column) => {
+      const raw = row[column] ?? "";
+      const display = verbose ? raw : clip(raw, 42);
+      return display.padEnd(widths[column]);
+    }).join(" | ")
+  );
+  return [header, divider, ...body, "", footer].join("\n");
+}
+async function handleCsvShow(path, options, command) {
+  if (path !== void 0 && options.csv !== void 0) {
+    command.error(
+      "Specify one CSV path: deepline csv show <path>. Do not combine it with --csv.",
+      { exitCode: 2 }
+    );
+  }
+  const csvPath = path ?? options.csv;
+  if (!csvPath) {
+    command.error(
+      "Missing CSV path. Usage: deepline csv show <path> [options]",
+      { exitCode: 2 }
+    );
+  }
+  const allRows = readCsvRows(csvPath);
+  const [rowStart, rowEnd] = parseRowRange(options.rows);
+  const rows = options.summary && options.rows === void 0 ? allRows : selectRows(allRows, rowStart, rowEnd);
+  const { rows: selected, columns } = selectColumns(
+    rows,
+    options.columns,
+    options.excludeColumns,
+    Object.keys(allRows[0] ?? {})
+  );
+  const format = options.format ?? "json";
+  if (options.summary) {
+    const summaries = summarizeColumns(selected, columns);
+    if (format === "json") {
+      printJson({
+        rows: summaries,
+        total_rows: selected.length,
+        source_total_rows: allRows.length
+      });
+      return;
+    }
+    const displayRows = summaryDisplayRows(summaries);
+    if (format === "csv") {
+      process.stdout.write(csvStringFromRows(displayRows));
+      return;
+    }
+    process.stdout.write(
+      `${renderTable(
+        displayRows,
+        selected.length,
+        Boolean(options.verbose),
+        `summarized ${summaries.length} column(s) across ${selected.length} row(s) of ${allRows.length}`
+      )}
+`
+    );
+    return;
+  }
+  if (format === "json") {
+    printJson({
+      rows: selected.map((row, index) => ({ __row: rowStart + index, ...row }))
+    });
+    return;
+  }
+  if (format === "csv") {
+    const columns2 = Object.keys(selected[0] ?? {});
+    process.stdout.write(`${columns2.join(",")}
+`);
+    for (const row of selected) {
+      process.stdout.write(
+        `${columns2.map((column) => JSON.stringify(row[column] ?? "")).join(",")}
+`
+      );
+    }
+    return;
+  }
+  process.stdout.write(
+    `${renderTable(selected, allRows.length, Boolean(options.verbose))}
+`
+  );
+}
+function csvRenderStatePath() {
+  return join(homedir(), ".local", "deepline", "runtime", "csv-render.json");
+}
+function csvRenderLogPath() {
+  return join(homedir(), ".local", "deepline", "runtime", "csv-render.log");
+}
+function ensureCsvRenderStateDir() {
+  mkdirSync(join(homedir(), ".local", "deepline", "runtime"), {
+    recursive: true
+  });
+}
+function readCsvRenderState() {
+  try {
+    const parsed = JSON.parse(readFileSync(csvRenderStatePath(), "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeCsvRenderState(state) {
+  ensureCsvRenderStateDir();
+  writeFileSync(csvRenderStatePath(), `${JSON.stringify(state, null, 2)}
+`);
+}
+function parseCsvRenderPort(raw) {
+  const value = Number.parseInt(String(raw ?? "4174").replace(/^:/, ""), 10);
+  if (!Number.isInteger(value) || value <= 0 || value > 65535) {
+    throw new Error(`Invalid --port value: ${raw ?? ""}`);
+  }
+  return value;
+}
+function processAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isOwnedCsvRenderHealth(health, state) {
+  return Boolean(health?.ok) && Number.isInteger(state.pid) && health?.pid === state.pid && Boolean(state.token) && health?.token === state.token;
+}
+async function fetchCsvRenderHealth(url) {
+  try {
+    const response = await fetch(`${url}/health`);
+    if (!response.ok) {
+      return null;
+    }
+    const parsed = await response.json();
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function waitForRenderHealth(url, state) {
+  const deadline = Date.now() + 15e3;
+  while (Date.now() < deadline) {
+    if (isOwnedCsvRenderHealth(await fetchCsvRenderHealth(url), state)) {
+      return true;
+    }
+    if (state.pid && !processAlive(state.pid)) {
+      return false;
+    }
+    await new Promise((resolveDelay) => setTimeout(resolveDelay, 100));
+  }
+  return false;
+}
+async function waitForRenderStopped(url) {
+  const deadline = Date.now() + 2e3;
+  while (Date.now() < deadline) {
+    try {
+      await fetch(`${url}/health`);
+    } catch {
+      return;
+    }
+    await new Promise((resolveDelay) => setTimeout(resolveDelay, 100));
+  }
+}
+var CSV_RENDER_SERVER_SOURCE = String.raw`
+const http = require('node:http');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const port = Number.parseInt(process.env.DEEPLINE_CSV_RENDER_PORT || '4174', 10);
+const csvPath = process.env.DEEPLINE_CSV_RENDER_CSV || '';
+const token = process.env.DEEPLINE_CSV_RENDER_TOKEN || '';
+
+function send(res, status, contentType, body) {
+  res.writeHead(status, {
+    'content-type': contentType,
+    'cache-control': 'no-store',
+  });
+  res.end(body);
+}
+
+function readCsvText() {
+  if (!csvPath) return '';
+  try {
+    return fs.readFileSync(csvPath, 'utf8');
+  } catch (error) {
+    return 'Unable to read CSV: ' + (error && error.message ? error.message : String(error));
+  }
+}
+
+const server = http.createServer((req, res) => {
+  const url = new URL(req.url || '/', 'http://127.0.0.1:' + port);
+  if (url.pathname === '/health') {
+    send(res, 200, 'application/json', JSON.stringify({ ok: true, pid: process.pid, csvPath, token }));
+    return;
+  }
+  if (url.pathname === '/csv.txt') {
+    send(res, 200, 'text/plain; charset=utf-8', readCsvText());
+    return;
+  }
+  if (url.pathname === '/csv.json') {
+    send(res, 200, 'application/json', JSON.stringify({ csvPath, text: readCsvText() }));
+    return;
+  }
+  const title = csvPath ? path.basename(csvPath) : 'CSV renderer';
+  const escapedTitle = title.replace(/[&<>"]/g, (ch) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[ch]));
+  const escapedCsv = readCsvText().replace(/[&<>]/g, (ch) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;' }[ch]));
+  send(res, 200, 'text/html; charset=utf-8', '<!doctype html><html><head><meta charset="utf-8"><title>' + escapedTitle + '</title><style>body{font:14px system-ui,sans-serif;margin:24px}pre{white-space:pre-wrap;border:1px solid #ddd;padding:16px;border-radius:8px}</style></head><body><h1>' + escapedTitle + '</h1><pre>' + escapedCsv + '</pre></body></html>');
+});
+
+server.listen(port, '127.0.0.1');
+server.on('error', (error) => {
+  console.error(error && error.stack ? error.stack : error);
+  process.exit(1);
+});
+process.on('SIGTERM', () => server.close(() => process.exit(0)));
+process.on('SIGINT', () => server.close(() => process.exit(0)));
+`;
+async function openBrowser(url) {
+  const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  const child = spawn(opener, args, { detached: true, stdio: "ignore" });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+async function handleCsvRenderStart(options) {
+  const port = parseCsvRenderPort(options.port);
+  const csvPath = options.csv ? resolve(options.csv) : "";
+  if (csvPath && !existsSync(csvPath)) {
+    throw new Error(`CSV not found: ${csvPath}`);
+  }
+  const url = `http://127.0.0.1:${port}`;
+  const existing = readCsvRenderState();
+  if (processAlive(existing.pid) && existing.url) {
+    const existingOwned = isOwnedCsvRenderHealth(
+      await fetchCsvRenderHealth(existing.url),
+      existing
+    );
+    const sameUrl = existing.url === url;
+    const sameCsv = !csvPath || existing.csvPath === csvPath;
+    if (existingOwned && (!sameUrl || !sameCsv)) {
+      try {
+        process.kill(existing.pid, "SIGTERM");
+      } catch {
+      }
+      await waitForRenderStopped(existing.url);
+      if (processAlive(existing.pid)) {
+        try {
+          process.kill(existing.pid, "SIGKILL");
+        } catch {
+        }
+      }
+      rmSync(csvRenderStatePath(), { force: true });
+    } else if (existingOwned) {
+      process.stdout.write(
+        "CSV render is already running; reusing current process.\n"
+      );
+      process.stdout.write(`Render URL: ${existing.url}
+`);
+      if (options.open) {
+        await openBrowser(existing.url);
+      }
+      return;
+    } else {
+      rmSync(csvRenderStatePath(), { force: true });
+    }
+  }
+  ensureCsvRenderStateDir();
+  const logPath = csvRenderLogPath();
+  const logFd = openSync(logPath, "w");
+  const token = randomUUID();
+  const child = spawn(process.execPath, ["-e", CSV_RENDER_SERVER_SOURCE], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: {
+      ...process.env,
+      DEEPLINE_CSV_RENDER_PORT: String(port),
+      DEEPLINE_CSV_RENDER_CSV: csvPath,
+      DEEPLINE_CSV_RENDER_TOKEN: token
+    }
+  });
+  closeSync(logFd);
+  child.unref();
+  const state = {
+    pid: child.pid ?? null,
+    port,
+    url,
+    csvPath,
+    logPath,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    token
+  };
+  const started = await waitForRenderHealth(url, state);
+  if (!started) {
+    if (processAlive(child.pid)) {
+      process.kill(child.pid, "SIGTERM");
+    }
+    let detail = "";
+    try {
+      const log = readFileSync(logPath, "utf8").trim();
+      if (log) {
+        detail = `
+CSV render log:
+${clip(log, 2e3)}`;
+      }
+    } catch {
+    }
+    throw new Error(
+      `Timed out waiting for CSV render to start at ${url}.${detail}`
+    );
+  }
+  writeCsvRenderState(state);
+  writeFileSync(
+    logPath,
+    `CSV render started at ${state.startedAt} on ${url}
+`
+  );
+  process.stdout.write("CSV render is running.\n");
+  process.stdout.write(`Render PID: ${child.pid}
+`);
+  process.stdout.write(`Render URL: ${url}
+`);
+  if (options.open) {
+    await openBrowser(url);
+  }
+}
+async function handleCsvRenderStatus(options) {
+  const state = readCsvRenderState();
+  const processExists = processAlive(state.pid);
+  const url = state.url ?? "";
+  let health = "unknown";
+  let owned = false;
+  if (processExists && url) {
+    const renderHealth = await fetchCsvRenderHealth(url);
+    owned = isOwnedCsvRenderHealth(renderHealth, state);
+    health = owned ? "healthy" : "unhealthy";
+  }
+  const status = processExists && owned ? "running" : processExists ? "unhealthy" : "stopped";
+  const payload = {
+    status,
+    pid: owned ? state.pid : null,
+    process_alive: owned,
+    url,
+    log_path: state.logPath ?? "",
+    mode: "background",
+    started_at: owned ? state.startedAt ?? "" : "",
+    health_status: health,
+    health_checked_at: (/* @__PURE__ */ new Date()).toISOString(),
+    stale_cleaned: true
+  };
+  const lines = [`Render Status: ${payload.status}`];
+  if (payload.pid) lines.push(`Render PID: ${payload.pid}`);
+  if (payload.url) lines.push(`Render URL: ${payload.url}`);
+  lines.push(`Render Health: ${payload.health_status}`);
+  printCommandEnvelope(payload, {
+    json: options.json,
+    text: `${lines.join("\n")}
+`
+  });
+}
+function terminateRenderProcess(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return false;
+  }
+  return true;
+}
+async function handleCsvRenderStop(options) {
+  const state = readCsvRenderState();
+  const stopped = [];
+  const failed = [];
+  const owned = processAlive(state.pid) && Boolean(state.url) && isOwnedCsvRenderHealth(await fetchCsvRenderHealth(state.url), state);
+  if (owned && processAlive(state.pid)) {
+    if (terminateRenderProcess(state.pid)) {
+      stopped.push(state.pid);
+    } else {
+      failed.push(state.pid);
+    }
+  }
+  rmSync(csvRenderStatePath(), { force: true });
+  const payload = {
+    ok: failed.length === 0,
+    stopped_count: stopped.length,
+    failed_count: failed.length,
+    stopped_pids: stopped,
+    failed_pids: failed
+  };
+  const text = stopped.length > 0 ? `Stopped CSV render process(es): ${stopped.join(" ")}
+` : "No running CSV render process found.\n";
+  printCommandEnvelope(payload, { json: options.json, text });
+}
+async function handleCsvRender(action, options) {
+  const normalized = action ?? "start";
+  if (normalized === "start") {
+    await handleCsvRenderStart(options);
+    return;
+  }
+  if (normalized === "status") {
+    await handleCsvRenderStatus(options);
+    return;
+  }
+  if (normalized === "stop") {
+    await handleCsvRenderStop(options);
+    return;
+  }
+  throw new Error(`Unknown csv render action: ${normalized}`);
+}
+function registerCsvCommands(program) {
+  const csv = program.command("csv").description("Inspect local CSV files.").addHelpText(
+    "after",
+    `
+Notes:
+  Local-only inspection helpers. These commands do not upload CSV files or call
+  Deepline APIs.
+
+Examples:
+  deepline csv show leads.csv --rows 0:10 --format table
+  deepline csv show leads.csv --summary
+`
+  );
+  csv.command("show").argument("[path]", "Input CSV path").usage("<path> [options]").allowExcessArguments(false).description("Display rows from a CSV file in json, csv, or table form.").addHelpText(
+    "after",
+    `
+Notes:
+  Reads a local CSV path. By default, rows show 0:19 (first 20 rows), while
+  --summary analyzes the whole file. An explicit --rows start:end range applies
+  to either mode. Column selection and --format apply to both; JSON is default.
+
+Examples:
+  deepline csv show leads.csv
+  deepline csv show leads.csv --rows 20:39 --columns name,email --format table
+  deepline csv show leads.csv --exclude-columns raw_response,attempts --format table
+  deepline csv show leads.csv --summary
+`
+  ).addOption(
+    new Option("--csv <path>", "Input CSV path (legacy alias)").hideHelp()
+  ).option("--format <format>", "Output format: json, csv, or table", "json").option(
+    "--rows <range>",
+    "Inclusive row range start:end (show defaults to 0:19)"
+  ).option("--columns <names>", "Comma-separated column names to include").option("--exclude-columns <names>", "Comma-separated column names to omit").option(
+    "--summary",
+    "Summarize selected columns as one row per column; defaults to all rows"
+  ).option("--verbose", "Do not truncate long values in table output").action(handleCsvShow);
+  const render = csv.command("render").description("Start, inspect, or stop a local CSV renderer.").argument("[action]", "start, status, or stop", "start").option("--port <port>", "Local renderer port.", "4174").option("--csv <path>", "CSV path to display.").option("--open", "Open the renderer in a browser.").option("--json", "Emit JSON for status/stop.").action(handleCsvRender);
+  render.showHelpAfterError();
+}
+export {
+  registerCsvCommands
+};