@askexenow/exe-os 0.9.279 → 0.9.281

package/dist/chunk-52HOURUP.js

@@ -0,0 +1,369 @@
+import {
+  resolveSupportAdminToken,
+  supportAdminHeaders
+} from "./chunk-2XZ6X3PJ.js";
+import {
+  markSupportReportSentSync
+} from "./chunk-MMRUBN3I.js";
+import {
+  loadLicense,
+  readCachedLicenseToken
+} from "./chunk-PD3Q525F.js";
+import {
+  EXE_AI_DIR,
+  loadConfig
+} from "./chunk-T3B5RK4H.js";
+
+// src/bin/exe-support.ts
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import path from "path";
+import { randomUUID } from "crypto";
+var DEFAULT_BUG_ENDPOINT = "https://api.askexe.com/v1/support/bug-reports";
+var DEFAULT_ADMIN_ENDPOINT = "https://api.askexe.com/admin/support/bug-reports";
+async function main(argv = process.argv.slice(2)) {
+  const command = argv[0] && !argv[0].startsWith("--") ? argv[0] : "health";
+  const json = argv.includes("--json");
+  const project = getArg(argv, "--project") ?? "support-smoke";
+  if (command === "help" || argv.includes("--help") || argv.includes("-h")) {
+    printHelp();
+    return;
+  }
+  if (command === "health") {
+    const result = await runHealth();
+    output(result, json, "health");
+    process.exitCode = hasFailures(result) ? 1 : 0;
+    return;
+  }
+  if (command === "test") {
+    const result = await runTest(project);
+    output(result, json, "test");
+    process.exitCode = hasFailures(result) ? 1 : 0;
+    return;
+  }
+  if (command === "flush") {
+    await runFlush(json);
+    return;
+  }
+  if (command === "status") {
+    await runStatus(json);
+    return;
+  }
+  console.error("Usage: exe-os support health|test|flush|status [--project <name>] [--json]");
+  process.exitCode = 1;
+}
+async function runHealth() {
+  const checks = [];
+  const endpoints = await resolveEndpoints();
+  checks.push(checkLocalWrite());
+  checks.push({
+    check: "license_key_present",
+    level: loadLicense() ? "pass" : "fail",
+    detail: loadLicense() ? "license.key found" : "missing ~/.exe-os/license.key; run exe-os setup or exe-os cloud setup",
+    next: loadLicense() ? void 0 : "Run `exe-os setup` or ask AskExe for the customer license key."
+  });
+  checks.push({
+    check: "license_token_cached",
+    level: readCachedLicenseToken() ? "pass" : "warn",
+    detail: readCachedLicenseToken() ? "cached license token found" : "no cached token yet; support can still use license.key",
+    next: readCachedLicenseToken() ? void 0 : "This is OK if license.key exists. It refreshes after cloud/license validation."
+  });
+  try {
+    const res = await fetch(endpoints.healthEndpoint, { method: "GET", signal: AbortSignal.timeout(1e4) });
+    const body = await safeJson(res);
+    checks.push({
+      check: "support_health_endpoint",
+      level: res.ok && body?.status !== "down" ? "pass" : "fail",
+      detail: `${res.status} ${body?.status ?? res.statusText}`,
+      next: res.ok ? void 0 : "Check internet access, DNS, or AskExe support status."
+    });
+    for (const remote of body?.checks ?? []) {
+      const name = remote.name ?? "unknown";
+      checks.push({
+        check: `server_${name}`,
+        level: remote.ok === true ? "pass" : name === "admin_inbox_configured" ? "warn" : "fail",
+        detail: remote.detail ?? (remote.ok ? "ok" : "failed"),
+        next: remote.ok ? void 0 : "AskExe must fix this server-side."
+      });
+    }
+  } catch (err) {
+    checks.push({
+      check: "support_health_endpoint",
+      level: "fail",
+      detail: err instanceof Error ? err.message : String(err),
+      next: "Check internet access, then run `exe-os support health` again."
+    });
+  }
+  return checks;
+}
+async function runTest(project) {
+  const checks = await runHealth();
+  const endpoints = await resolveEndpoints();
+  const config = await loadConfig();
+  const licenseKey = loadLicense();
+  const licenseToken = readCachedLicenseToken();
+  const id = randomUUID();
+  const version = readPackageVersion();
+  const reportPath = writeLocalTestReport(id, project, version);
+  checks.push({ check: "local_report_file", level: "pass", detail: reportPath });
+  if (!licenseKey && !licenseToken) {
+    checks.push({
+      check: "upstream_post",
+      level: "fail",
+      detail: "not sent because this device has no license key/token",
+      next: "Run `exe-os setup` or ask AskExe to provision this customer device."
+    });
+    return checks;
+  }
+  const payload = {
+    id,
+    title: `TEST \u2014 ${project} support intake (${version})`,
+    classification: "unclear",
+    severity: "p3",
+    summary: "Synthetic exe-os support intake smoke test. Safe to close.",
+    customer_impact: "No customer impact; diagnostic only.",
+    reproduction_steps: ["Run exe-os support test"],
+    expected: "The report reaches AskExe support intake and can be triaged.",
+    actual: "Smoke test submitted by exe-os support test.",
+    package_version: `@askexenow/exe-os@${version}`,
+    project_name: project,
+    agent_id: "support-test",
+    agent_role: "diagnostic",
+    report_path: reportPath,
+    markdown: readFileSync(reportPath, "utf8")
+  };
+  try {
+    const headers = {
+      "content-type": "application/json",
+      ...supportAdminHeaders(config)
+    };
+    if (licenseKey) headers["x-exe-license-key"] = licenseKey;
+    if (licenseToken) headers["x-exe-license-token"] = licenseToken;
+    const res = await fetch(endpoints.bugEndpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(15e3)
+    });
+    const data = await safeJson(res);
+    checks.push({
+      check: "upstream_post",
+      level: res.ok ? "pass" : "fail",
+      detail: res.ok ? `sent id=${String(data?.id ?? id)}` : summarizeHttpFailure(res.status, data),
+      next: res.ok ? void 0 : nextForPostFailure(res.status)
+    });
+    if (res.ok) {
+      markSupportReportSentSync(reportPath);
+      checks.push(await maybeCloseAdmin(String(data?.id ?? id), endpoints.adminEndpoint, version, config));
+    }
+  } catch (err) {
+    checks.push({
+      check: "upstream_post",
+      level: "fail",
+      detail: err instanceof Error ? err.message : String(err),
+      next: "Check internet access, then run `exe-os support test` again."
+    });
+  }
+  return checks;
+}
+async function resolveEndpoints() {
+  const config = await loadConfig();
+  const bugEndpoint = process.env.EXE_SUPPORT_BUG_REPORT_ENDPOINT ?? config.support?.bugReportEndpoint ?? DEFAULT_BUG_ENDPOINT;
+  const healthEndpoint = process.env.EXE_SUPPORT_HEALTH_ENDPOINT ?? bugEndpoint.replace(/\/bug-reports\/?$/, "/health");
+  const adminEndpoint = process.env.ASKEXE_SUPPORT_ADMIN_ENDPOINT ?? process.env.EXE_SUPPORT_ADMIN_ENDPOINT ?? DEFAULT_ADMIN_ENDPOINT;
+  return { bugEndpoint, healthEndpoint, adminEndpoint };
+}
+function checkLocalWrite() {
+  const dir = path.join(EXE_AI_DIR, "bug-reports");
+  const testPath = path.join(dir, ".support-write-test");
+  try {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    writeFileSync(testPath, "ok\n", { mode: 384 });
+    unlinkSync(testPath);
+    return { check: "local_bug_report_dir_writable", level: "pass", detail: dir };
+  } catch (err) {
+    return {
+      check: "local_bug_report_dir_writable",
+      level: "fail",
+      detail: err instanceof Error ? err.message : String(err),
+      next: "Fix permissions on ~/.exe-os or rerun setup on a writable user account."
+    };
+  }
+}
+function writeLocalTestReport(id, project, version) {
+  const dir = path.join(EXE_AI_DIR, "bug-reports");
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const filePath = path.join(dir, `${date}-support-intake-test-${id.slice(0, 8)}.md`);
+  writeFileSync(filePath, `# TEST \u2014 ${project} support intake
+
+Report ID: ${id}
+Package: @askexenow/exe-os@${version}
+
+Synthetic smoke test from \`exe-os support test\`. Safe to close.
+`, { mode: 384 });
+  return filePath;
+}
+async function maybeCloseAdmin(id, adminEndpoint, version, config) {
+  const token = resolveSupportAdminToken(config);
+  if (!token) {
+    return { check: "askexe_admin_autoclose", level: "warn", detail: "skipped; admin token is AskExe-only" };
+  }
+  try {
+    const res = await fetch(`${adminEndpoint}/${encodeURIComponent(id)}`, {
+      method: "PATCH",
+      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+      body: JSON.stringify({
+        status: "closed",
+        triage_notes: "Auto-closed synthetic support smoke test.",
+        fixed_version: version
+      }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    return {
+      check: "askexe_admin_autoclose",
+      level: res.ok ? "pass" : "warn",
+      detail: res.ok ? "closed" : `${res.status} ${await res.text()}`,
+      next: res.ok ? void 0 : "Report was sent; AskExe can close the smoke report manually."
+    };
+  } catch (err) {
+    return {
+      check: "askexe_admin_autoclose",
+      level: "warn",
+      detail: err instanceof Error ? err.message : String(err),
+      next: "Report was sent; AskExe can close the smoke report manually."
+    };
+  }
+}
+function readPackageVersion() {
+  let dir = path.dirname(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 6; i++) {
+    const pkg = path.join(dir, "package.json");
+    try {
+      const parsed = JSON.parse(readFileSync(pkg, "utf8"));
+      if (parsed.version) return parsed.version;
+    } catch {
+    }
+    dir = path.dirname(dir);
+  }
+  return "unknown";
+}
+async function safeJson(res) {
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+function getArg(argv, name) {
+  const idx = argv.indexOf(name);
+  if (idx >= 0) return argv[idx + 1];
+  const prefix = `${name}=`;
+  const found = argv.find((arg) => arg.startsWith(prefix));
+  return found?.slice(prefix.length);
+}
+function hasFailures(rows) {
+  return rows.some((row) => row.level === "fail");
+}
+function summarizeHttpFailure(status, data) {
+  const error = data?.error;
+  return `${status} ${error?.message ?? JSON.stringify(data)}`;
+}
+function nextForPostFailure(status) {
+  if (status === 401) return "License credentials were not sent. Run `exe-os support health` and check license_key_present.";
+  if (status === 403) return "License is valid locally but not accepted by support intake. AskExe must check server-side license provisioning.";
+  if (status >= 500) return "AskExe support intake is unhealthy server-side. Try again shortly and report the local file path.";
+  return "Run `exe-os support health`; if it passes, send this output to AskExe.";
+}
+async function runFlush(json) {
+  const { flushSupportOutbox } = await import("./support-outbox-YLXLMEKF.js");
+  const result = await flushSupportOutbox({ maxPerFlush: 10 });
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log("\nexe-os support flush\n");
+  console.log(`  Bug reports sent:      ${result.bugsSent}`);
+  console.log(`  Feature requests sent: ${result.featuresSent}`);
+  console.log(`  Errors:                ${result.errors}`);
+  console.log(`  Skipped:               ${result.skipped}`);
+  console.log("");
+  const total = result.bugsSent + result.featuresSent;
+  if (total > 0) {
+    console.log(`Flushed ${total} item(s) to AskExe.`);
+  } else if (result.errors > 0) {
+    console.log("Nothing sent \u2014 network errors occurred. Retry later.");
+  } else {
+    console.log("Outbox is empty \u2014 nothing to flush.");
+  }
+  console.log("");
+}
+async function runStatus(json) {
+  const { getOutboxStatus } = await import("./support-outbox-YLXLMEKF.js");
+  const status = await getOutboxStatus();
+  if (json) {
+    console.log(JSON.stringify(status, null, 2));
+    return;
+  }
+  console.log("\nexe-os support status\n");
+  const bugs = status.bugReports;
+  const features = status.featureRequests;
+  console.log(`  Bug reports:      ${bugs.unsent} unsent / ${bugs.total} total${bugs.oldest ? ` (oldest: ${bugs.oldest.slice(0, 10)})` : ""}`);
+  console.log(`  Feature requests: ${features.unsent} unsent / ${features.total} total${features.oldest ? ` (oldest: ${features.oldest.slice(0, 10)})` : ""}`);
+  console.log("");
+  const totalUnsent = bugs.unsent + features.unsent;
+  if (totalUnsent > 0) {
+    console.log(`${totalUnsent} unsent item(s). Run \`exe-os support flush\` to send manually.`);
+  } else {
+    console.log("All items sent \u2014 outbox is clear.");
+  }
+  console.log("");
+}
+function printHelp() {
+  console.log(`
+exe-os support
+
+Customer-safe diagnostics for AskExe support intake.
+
+Commands:
+  exe-os support health              Check local setup + AskExe support server health
+  exe-os support test --project hygo Send a safe smoke report end-to-end
+  exe-os support flush               Force-flush unsent bug reports + feature requests
+  exe-os support status              Show outbox status (unsent counts)
+
+What success means:
+  health = this device looks ready
+  test   = AskExe received a real report from this device
+  flush  = all unsent items attempted delivery
+  status = visibility into what's queued
+`);
+}
+function output(rows, json, command) {
+  if (json) {
+    console.log(JSON.stringify({ ok: !hasFailures(rows), checks: rows }, null, 2));
+    return;
+  }
+  console.log(`
+exe-os support ${command}
+`);
+  for (const row of rows) {
+    const icon = row.level === "pass" ? "\u2705" : row.level === "warn" ? "\u26A0\uFE0F " : "\u274C";
+    console.log(`${icon} ${row.check}: ${row.detail}`);
+    if (row.next) console.log(`   \u2192 ${row.next}`);
+  }
+  console.log("");
+  if (hasFailures(rows)) {
+    console.log("Result: not ready. Fix the failed item(s), then rerun this command.");
+  } else if (rows.some((row) => row.level === "warn")) {
+    console.log("Result: ready with warnings. Bug reports can be sent; warnings are informational unless AskExe asked for stricter validation.");
+  } else {
+    console.log(command === "test" ? "Result: ready. AskExe received the test report." : "Result: ready. Run `exe-os support test --project <customer>` for an end-to-end send test.");
+  }
+  console.log("");
+}
+
+export {
+  main,
+  runHealth,
+  runTest,
+  hasFailures
+};