@insforge/cli 0.1.31 → 0.1.32

package/dist/index.js

@@ -3084,6 +3084,594 @@ function formatSize2(gb) {
   return `${gb.toFixed(2)} GB`;
 }
 
+// src/commands/diagnose/metrics.ts
+var METRIC_LABELS = {
+  cpu_usage: "CPU Usage",
+  memory_usage: "Memory Usage",
+  disk_usage: "Disk Usage",
+  network_in: "Network In",
+  network_out: "Network Out"
+};
+var NETWORK_METRICS = /* @__PURE__ */ new Set(["network_in", "network_out"]);
+function formatValue(metric, value) {
+  if (NETWORK_METRICS.has(metric)) {
+    return formatBytes(value) + "/s";
+  }
+  return `${value.toFixed(1)}%`;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes.toFixed(1)} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function computeStats(data) {
+  if (data.length === 0) return { latest: 0, avg: 0, max: 0 };
+  const latest = data[data.length - 1].value;
+  let sum = 0;
+  let max = -Infinity;
+  for (const d of data) {
+    sum += d.value;
+    if (d.value > max) max = d.value;
+  }
+  return { latest, avg: sum / data.length, max };
+}
+function aggregateByMetric(series) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const s of series) {
+    const existing = grouped.get(s.metric);
+    if (existing) existing.push(s);
+    else grouped.set(s.metric, [s]);
+  }
+  const result = [];
+  for (const [metric, group] of grouped) {
+    if (group.length === 1 || !NETWORK_METRICS.has(metric)) {
+      result.push(group[0]);
+      continue;
+    }
+    const tsMap = /* @__PURE__ */ new Map();
+    for (const s of group) {
+      for (const d of s.data) {
+        tsMap.set(d.timestamp, (tsMap.get(d.timestamp) ?? 0) + d.value);
+      }
+    }
+    const merged = [...tsMap.entries()].sort((a, b) => a[0] - b[0]).map(([timestamp, value]) => ({ timestamp, value }));
+    result.push({ metric, instance_id: "aggregate", data: merged });
+  }
+  return result;
+}
+async function fetchMetricsSummary(projectId, apiUrl) {
+  const res = await platformFetch(`/projects/v1/${projectId}/metrics?range=1h`, {}, apiUrl);
+  return await res.json();
+}
+function registerDiagnoseMetricsCommand(diagnoseCmd2) {
+  diagnoseCmd2.command("metrics").description("Display EC2 instance metrics (CPU, memory, disk, network)").option("--range <range>", "Time range: 1h, 6h, 24h, 7d", "1h").option("--metrics <list>", "Comma-separated metrics to query").action(async (opts, cmd) => {
+    const { json, apiUrl } = getRootOpts(cmd);
+    try {
+      await requireAuth(apiUrl);
+      const config = getProjectConfig();
+      if (!config) throw new ProjectNotLinkedError();
+      if (config.project_id === "oss-project") {
+        throw new CLIError(
+          "Metrics requires InsForge Platform login. Not available when linked via --api-key."
+        );
+      }
+      const params = new URLSearchParams({ range: opts.range });
+      if (opts.metrics) params.set("metrics", opts.metrics);
+      const res = await platformFetch(
+        `/projects/v1/${config.project_id}/metrics?${params.toString()}`,
+        {},
+        apiUrl
+      );
+      const data = await res.json();
+      const aggregated = aggregateByMetric(data.metrics);
+      if (json) {
+        const enriched = {
+          ...data,
+          metrics: aggregated.map((m) => {
+            const stats = computeStats(m.data);
+            return { ...m, latest: stats.latest, avg: stats.avg, max: stats.max };
+          })
+        };
+        outputJson(enriched);
+      } else {
+        if (!aggregated.length) {
+          console.log("No metrics data available.");
+          return;
+        }
+        const headers = ["Metric", "Latest", "Avg", "Max", "Range"];
+        const rows = aggregated.map((m) => {
+          const stats = computeStats(m.data);
+          return [
+            METRIC_LABELS[m.metric] ?? m.metric,
+            formatValue(m.metric, stats.latest),
+            formatValue(m.metric, stats.avg),
+            formatValue(m.metric, stats.max),
+            data.range
+          ];
+        });
+        outputTable(headers, rows);
+      }
+      await reportCliUsage("cli.diagnose.metrics", true);
+    } catch (err) {
+      await reportCliUsage("cli.diagnose.metrics", false);
+      handleError(err, json);
+    }
+  });
+}
+
+// src/commands/diagnose/advisor.ts
+async function fetchAdvisorSummary(projectId, apiUrl) {
+  const res = await platformFetch(`/projects/v1/${projectId}/advisor/latest`, {}, apiUrl);
+  return await res.json();
+}
+function registerDiagnoseAdvisorCommand(diagnoseCmd2) {
+  diagnoseCmd2.command("advisor").description("Display latest advisor scan results and issues").option("--severity <level>", "Filter by severity: critical, warning, info").option("--category <cat>", "Filter by category: security, performance, health").option("--limit <n>", "Maximum number of issues to return", "50").action(async (opts, cmd) => {
+    const { json, apiUrl } = getRootOpts(cmd);
+    try {
+      await requireAuth(apiUrl);
+      const config = getProjectConfig();
+      if (!config) throw new ProjectNotLinkedError();
+      if (config.project_id === "oss-project") {
+        throw new CLIError(
+          "Advisor requires InsForge Platform login. Not available when linked via --api-key."
+        );
+      }
+      const projectId = config.project_id;
+      const scanRes = await platformFetch(
+        `/projects/v1/${projectId}/advisor/latest`,
+        {},
+        apiUrl
+      );
+      const scan = await scanRes.json();
+      const issueParams = new URLSearchParams();
+      if (opts.severity) issueParams.set("severity", opts.severity);
+      if (opts.category) issueParams.set("category", opts.category);
+      issueParams.set("limit", opts.limit);
+      const issuesRes = await platformFetch(
+        `/projects/v1/${projectId}/advisor/latest/issues?${issueParams.toString()}`,
+        {},
+        apiUrl
+      );
+      const issuesData = await issuesRes.json();
+      if (json) {
+        outputJson({ scan, issues: issuesData.issues });
+      } else {
+        const date = new Date(scan.scannedAt).toLocaleDateString();
+        const s = scan.summary;
+        console.log(
+          `Scan: ${date} (${scan.status}) \u2014 ${s.critical} critical, ${s.warning} warning, ${s.info} info
+`
+        );
+        if (!issuesData.issues || issuesData.issues.length === 0) {
+          console.log("No issues found.");
+          return;
+        }
+        const headers = ["Severity", "Category", "Affected Object", "Title"];
+        const rows = issuesData.issues.map((issue) => [
+          issue.severity,
+          issue.category,
+          issue.affectedObject,
+          issue.title
+        ]);
+        outputTable(headers, rows);
+      }
+      await reportCliUsage("cli.diagnose.advisor", true);
+    } catch (err) {
+      await reportCliUsage("cli.diagnose.advisor", false);
+      handleError(err, json);
+    }
+  });
+}
+
+// src/commands/diagnose/db.ts
+var DB_CHECKS = {
+  connections: {
+    label: "Connections",
+    sql: `SELECT
+      (SELECT count(*) FROM pg_stat_activity WHERE state IS NOT NULL) AS active,
+      (SELECT setting::int FROM pg_settings WHERE name = 'max_connections') AS max`,
+    format(rows) {
+      const r = rows[0] ?? {};
+      console.log(`  Active: ${r.active} / ${r.max}`);
+    }
+  },
+  "slow-queries": {
+    label: "Slow Queries (>5s)",
+    sql: `SELECT pid, now() - query_start AS duration, substring(query for 80) AS query
+      FROM pg_stat_activity
+      WHERE state = 'active' AND now() - query_start > interval '5 seconds'
+      ORDER BY query_start ASC`,
+    format(rows) {
+      if (rows.length === 0) {
+        console.log("  None");
+        return;
+      }
+      const headers = ["PID", "Duration", "Query"];
+      const tableRows = rows.map((r) => [
+        String(r.pid ?? ""),
+        String(r.duration ?? ""),
+        String(r.query ?? "")
+      ]);
+      outputTable(headers, tableRows);
+    }
+  },
+  bloat: {
+    label: "Table Bloat (top 10)",
+    sql: `SELECT schemaname || '.' || relname AS table, n_dead_tup AS dead_tuples
+      FROM pg_stat_user_tables
+      ORDER BY n_dead_tup DESC
+      LIMIT 10`,
+    format(rows) {
+      if (rows.length === 0) {
+        console.log("  No user tables found.");
+        return;
+      }
+      const headers = ["Table", "Dead Tuples"];
+      const tableRows = rows.map((r) => [
+        String(r.table ?? ""),
+        String(r.dead_tuples ?? 0)
+      ]);
+      outputTable(headers, tableRows);
+    }
+  },
+  size: {
+    label: "Table Sizes (top 10)",
+    sql: `SELECT schemaname || '.' || relname AS table,
+        pg_size_pretty(pg_total_relation_size(relid)) AS size
+      FROM pg_stat_user_tables
+      ORDER BY pg_total_relation_size(relid) DESC
+      LIMIT 10`,
+    format(rows) {
+      if (rows.length === 0) {
+        console.log("  No user tables found.");
+        return;
+      }
+      const headers = ["Table", "Size"];
+      const tableRows = rows.map((r) => [
+        String(r.table ?? ""),
+        String(r.size ?? "")
+      ]);
+      outputTable(headers, tableRows);
+    }
+  },
+  "index-usage": {
+    label: "Index Usage (worst 10)",
+    sql: `SELECT schemaname || '.' || relname AS table, idx_scan, seq_scan,
+        CASE WHEN (idx_scan + seq_scan) > 0
+          THEN round(100.0 * idx_scan / (idx_scan + seq_scan), 1)
+          ELSE 0 END AS idx_ratio
+      FROM pg_stat_user_tables
+      WHERE (idx_scan + seq_scan) > 0
+      ORDER BY idx_ratio ASC
+      LIMIT 10`,
+    format(rows) {
+      if (rows.length === 0) {
+        console.log("  No scan data available.");
+        return;
+      }
+      const headers = ["Table", "Index Scans", "Seq Scans", "Index Ratio"];
+      const tableRows = rows.map((r) => [
+        String(r.table ?? ""),
+        String(r.idx_scan ?? 0),
+        String(r.seq_scan ?? 0),
+        `${r.idx_ratio ?? 0}%`
+      ]);
+      outputTable(headers, tableRows);
+    }
+  },
+  locks: {
+    label: "Waiting Locks",
+    sql: `SELECT pid, mode, relation::regclass AS relation, granted
+      FROM pg_locks
+      WHERE NOT granted`,
+    format(rows) {
+      if (rows.length === 0) {
+        console.log("  None");
+        return;
+      }
+      const headers = ["PID", "Mode", "Relation", "Granted"];
+      const tableRows = rows.map((r) => [
+        String(r.pid ?? ""),
+        String(r.mode ?? ""),
+        String(r.relation ?? ""),
+        String(r.granted ?? "")
+      ]);
+      outputTable(headers, tableRows);
+    }
+  },
+  "cache-hit": {
+    label: "Cache Hit Ratio",
+    sql: `SELECT CASE WHEN sum(heap_blks_hit + heap_blks_read) > 0
+        THEN round(100.0 * sum(heap_blks_hit) / sum(heap_blks_hit + heap_blks_read), 1)
+        ELSE 0 END AS ratio
+      FROM pg_statio_user_tables`,
+    format(rows) {
+      const ratio = rows[0]?.ratio ?? 0;
+      console.log(`  ${ratio}%`);
+    }
+  }
+};
+var ALL_CHECKS = Object.keys(DB_CHECKS);
+async function runDbChecks() {
+  const results = {};
+  for (const key of ALL_CHECKS) {
+    try {
+      const { rows } = await runRawSql(DB_CHECKS[key].sql, true);
+      results[key] = rows;
+    } catch {
+      results[key] = [];
+    }
+  }
+  return results;
+}
+function registerDiagnoseDbCommand(diagnoseCmd2) {
+  diagnoseCmd2.command("db").description("Run database health checks (connections, bloat, index usage, etc.)").option("--check <checks>", "Comma-separated checks: " + ALL_CHECKS.join(", "), "all").action(async (opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      await requireAuth();
+      if (!getProjectConfig()) throw new ProjectNotLinkedError();
+      const checkNames = opts.check === "all" ? ALL_CHECKS : opts.check.split(",").map((s) => s.trim());
+      const results = {};
+      for (const name of checkNames) {
+        const check = DB_CHECKS[name];
+        if (!check) {
+          console.error(`Unknown check: ${name}. Available: ${ALL_CHECKS.join(", ")}`);
+          continue;
+        }
+        try {
+          const { rows } = await runRawSql(check.sql, true);
+          results[name] = rows;
+        } catch (err) {
+          results[name] = [];
+          if (!json) {
+            console.error(`  Failed to run ${name}: ${err instanceof Error ? err.message : err}`);
+          }
+        }
+      }
+      if (json) {
+        outputJson(results);
+      } else {
+        for (const name of checkNames) {
+          const check = DB_CHECKS[name];
+          if (!check) continue;
+          console.log(`
+\u2500\u2500 ${check.label} ${"\u2500".repeat(Math.max(0, 40 - check.label.length))}`);
+          check.format(results[name] ?? []);
+        }
+        console.log("");
+      }
+      await reportCliUsage("cli.diagnose.db", true);
+    } catch (err) {
+      await reportCliUsage("cli.diagnose.db", false);
+      handleError(err, json);
+    }
+  });
+}
+
+// src/commands/diagnose/logs.ts
+var LOG_SOURCES = ["insforge.logs", "postgREST.logs", "postgres.logs", "function.logs"];
+var ERROR_PATTERN = /\b(error|fatal|panic)\b/i;
+function parseLogEntry(entry) {
+  if (typeof entry === "string") {
+    return { ts: "", msg: entry };
+  }
+  const e = entry;
+  const ts = String(e.timestamp ?? e.time ?? "");
+  const msg = String(e.message ?? e.msg ?? e.log ?? JSON.stringify(e));
+  return { ts, msg };
+}
+async function fetchSourceLogs(source, limit) {
+  const res = await ossFetch(`/api/logs/${encodeURIComponent(source)}?limit=${limit}`);
+  const data = await res.json();
+  const logs = Array.isArray(data) ? data : data.logs ?? [];
+  const errors = [];
+  for (const entry of logs) {
+    const { ts, msg } = parseLogEntry(entry);
+    if (ERROR_PATTERN.test(msg)) {
+      errors.push({ timestamp: ts, message: msg, source });
+    }
+  }
+  return { source, total: logs.length, errors };
+}
+async function fetchLogsSummary(limit = 100) {
+  const results = [];
+  for (const source of LOG_SOURCES) {
+    try {
+      results.push(await fetchSourceLogs(source, limit));
+    } catch {
+      results.push({ source, total: 0, errors: [] });
+    }
+  }
+  return results;
+}
+function registerDiagnoseLogsCommand(diagnoseCmd2) {
+  diagnoseCmd2.command("logs").description("Aggregate error-level logs from all backend sources").option("--source <name>", "Specific log source to check").option("--limit <n>", "Number of log entries per source", "100").action(async (opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      await requireAuth();
+      if (!getProjectConfig()) throw new ProjectNotLinkedError();
+      const limit = parseInt(opts.limit, 10) || 100;
+      const sources = opts.source ? [opts.source] : [...LOG_SOURCES];
+      const summaries = [];
+      for (const source of sources) {
+        try {
+          summaries.push(await fetchSourceLogs(source, limit));
+        } catch {
+          summaries.push({ source, total: 0, errors: [] });
+        }
+      }
+      if (json) {
+        outputJson({ sources: summaries });
+      } else {
+        const headers = ["Source", "Total", "Errors"];
+        const rows = summaries.map((s) => [s.source, String(s.total), String(s.errors.length)]);
+        outputTable(headers, rows);
+        const allErrors = summaries.flatMap((s) => s.errors);
+        if (allErrors.length > 0) {
+          console.log("\n\u2500\u2500 Error Details " + "\u2500".repeat(30));
+          for (const err of allErrors) {
+            const prefix = err.timestamp ? `[${err.source}] ${err.timestamp}` : `[${err.source}]`;
+            console.log(`
+  ${prefix}`);
+            console.log(`  ${err.message}`);
+          }
+          console.log("");
+        }
+      }
+      await reportCliUsage("cli.diagnose.logs", true);
+    } catch (err) {
+      await reportCliUsage("cli.diagnose.logs", false);
+      handleError(err, json);
+    }
+  });
+}
+
+// src/commands/diagnose/index.ts
+function sectionHeader(title) {
+  return `\u2500\u2500 ${title} ${"\u2500".repeat(Math.max(0, 44 - title.length))}`;
+}
+function registerDiagnoseCommands(diagnoseCmd2) {
+  diagnoseCmd2.description("Backend diagnostics \u2014 run with no subcommand for a full health report").action(async (_opts, cmd) => {
+    const { json, apiUrl } = getRootOpts(cmd);
+    try {
+      await requireAuth(apiUrl);
+      const config = getProjectConfig();
+      if (!config) throw new ProjectNotLinkedError();
+      const projectId = config.project_id;
+      const projectName = config.project_name;
+      const ossMode = config.project_id === "oss-project";
+      const metricsPromise = ossMode ? Promise.reject(new Error("Platform login required (linked via --api-key)")) : fetchMetricsSummary(projectId, apiUrl);
+      const advisorPromise = ossMode ? Promise.reject(new Error("Platform login required (linked via --api-key)")) : fetchAdvisorSummary(projectId, apiUrl);
+      const [metricsResult, advisorResult, dbResult, logsResult] = await Promise.allSettled([
+        metricsPromise,
+        advisorPromise,
+        runDbChecks(),
+        fetchLogsSummary(100)
+      ]);
+      if (json) {
+        const report = { project: projectName, errors: [] };
+        const errors = [];
+        if (metricsResult.status === "fulfilled") {
+          const data = metricsResult.value;
+          report.metrics = data.metrics.map((m) => {
+            if (m.data.length === 0) return { metric: m.metric, latest: null, avg: null, max: null };
+            let sum = 0;
+            let max = -Infinity;
+            for (const d of m.data) {
+              sum += d.value;
+              if (d.value > max) max = d.value;
+            }
+            return {
+              metric: m.metric,
+              latest: m.data[m.data.length - 1].value,
+              avg: sum / m.data.length,
+              max
+            };
+          });
+        } else {
+          report.metrics = null;
+          errors.push(metricsResult.reason?.message ?? "Metrics unavailable");
+        }
+        if (advisorResult.status === "fulfilled") {
+          report.advisor = advisorResult.value;
+        } else {
+          report.advisor = null;
+          errors.push(advisorResult.reason?.message ?? "Advisor unavailable");
+        }
+        if (dbResult.status === "fulfilled") {
+          report.db = dbResult.value;
+        } else {
+          report.db = null;
+          errors.push(dbResult.reason?.message ?? "DB checks unavailable");
+        }
+        if (logsResult.status === "fulfilled") {
+          report.logs = logsResult.value;
+        } else {
+          report.logs = null;
+          errors.push(logsResult.reason?.message ?? "Logs unavailable");
+        }
+        report.errors = errors;
+        outputJson(report);
+      } else {
+        console.log(`
+  InsForge Health Report \u2014 ${projectName}
+`);
+        console.log(sectionHeader("System Metrics (last 1h)"));
+        if (metricsResult.status === "fulfilled") {
+          const metrics = metricsResult.value.metrics;
+          if (metrics.length === 0) {
+            console.log("  No metrics data available.");
+          } else {
+            const vals = {};
+            for (const m of metrics) {
+              if (m.data.length > 0) vals[m.metric] = m.data[m.data.length - 1].value;
+            }
+            const cpu = vals.cpu_usage !== void 0 ? `${vals.cpu_usage.toFixed(1)}%` : "N/A";
+            const mem = vals.memory_usage !== void 0 ? `${vals.memory_usage.toFixed(1)}%` : "N/A";
+            const disk = vals.disk_usage !== void 0 ? `${vals.disk_usage.toFixed(1)}%` : "N/A";
+            const netIn = vals.network_in !== void 0 ? formatBytesCompact(vals.network_in) + "/s" : "N/A";
+            const netOut = vals.network_out !== void 0 ? formatBytesCompact(vals.network_out) + "/s" : "N/A";
+            console.log(`  CPU: ${cpu}   Memory: ${mem}`);
+            console.log(`  Disk: ${disk}  Network: \u2193${netIn} \u2191${netOut}`);
+          }
+        } else {
+          console.log(`  N/A \u2014 ${metricsResult.reason?.message ?? "unavailable"}`);
+        }
+        console.log("\n" + sectionHeader("Advisor Scan"));
+        if (advisorResult.status === "fulfilled") {
+          const scan = advisorResult.value;
+          const s = scan.summary;
+          const date = new Date(scan.scannedAt).toLocaleDateString();
+          console.log(`  ${date} (${scan.status}) \u2014 ${s.critical} critical \xB7 ${s.warning} warning \xB7 ${s.info} info`);
+        } else {
+          console.log(`  N/A \u2014 ${advisorResult.reason?.message ?? "unavailable"}`);
+        }
+        console.log("\n" + sectionHeader("Database"));
+        if (dbResult.status === "fulfilled") {
+          const db = dbResult.value;
+          const conn = db.connections?.[0];
+          const cache = db["cache-hit"]?.[0];
+          const deadTuples = (db.bloat ?? []).reduce(
+            (sum, r) => sum + (Number(r.dead_tuples) || 0),
+            0
+          );
+          const lockCount = (db.locks ?? []).length;
+          console.log(
+            `  Connections: ${conn?.active ?? "?"}/${conn?.max ?? "?"}  Cache Hit: ${cache?.ratio ?? "?"}%`
+          );
+          console.log(
+            `  Dead tuples: ${deadTuples.toLocaleString()}   Locks waiting: ${lockCount}`
+          );
+        } else {
+          console.log(`  N/A \u2014 ${dbResult.reason?.message ?? "unavailable"}`);
+        }
+        console.log("\n" + sectionHeader("Recent Errors (last 100 logs/source)"));
+        if (logsResult.status === "fulfilled") {
+          const summaries = logsResult.value;
+          const parts = summaries.map((s) => `${s.source}: ${s.errors.length}`);
+          console.log(`  ${parts.join("  ")}`);
+        } else {
+          console.log(`  N/A \u2014 ${logsResult.reason?.message ?? "unavailable"}`);
+        }
+        console.log("");
+      }
+      await reportCliUsage("cli.diagnose", true);
+    } catch (err) {
+      await reportCliUsage("cli.diagnose", false);
+      handleError(err, json);
+    }
+  });
+  registerDiagnoseMetricsCommand(diagnoseCmd2);
+  registerDiagnoseAdvisorCommand(diagnoseCmd2);
+  registerDiagnoseDbCommand(diagnoseCmd2);
+  registerDiagnoseLogsCommand(diagnoseCmd2);
+}
+function formatBytesCompact(bytes) {
+  if (bytes < 1024) return `${bytes.toFixed(0)}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
 // src/index.ts
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(readFileSync6(join7(__dirname, "../package.json"), "utf-8"));
@@ -3151,6 +3739,8 @@ registerSecretsUpdateCommand(secretsCmd);
 registerSecretsDeleteCommand(secretsCmd);
 registerLogsCommand(program);
 registerMetadataCommand(program);
+var diagnoseCmd = program.command("diagnose");
+registerDiagnoseCommands(diagnoseCmd);
 var schedulesCmd = program.command("schedules").description("Manage scheduled tasks (cron jobs)");
 registerSchedulesListCommand(schedulesCmd);
 registerSchedulesGetCommand(schedulesCmd);