@askexenow/exe-os 0.9.280 → 0.9.281

package/dist/chunk-QAOGJRZD.js

@@ -0,0 +1,369 @@
+import {
+  resolveSupportAdminToken,
+  supportAdminHeaders
+} from "./chunk-2XZ6X3PJ.js";
+import {
+  markSupportReportSentSync
+} from "./chunk-MMRUBN3I.js";
+import {
+  loadLicense,
+  readCachedLicenseToken
+} from "./chunk-EAPUSVKS.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
+};

package/dist/chunk-QC3LAEI7.js

@@ -0,0 +1,197 @@
+import {
+  initStore
+} from "./chunk-AXOREWVL.js";
+import {
+  getClient,
+  isInitialized
+} from "./chunk-WUKEXVOR.js";
+
+// src/lib/schedules.ts
+import crypto from "crypto";
+import { execSync } from "child_process";
+var CRON_FIELD = /^[\d*/,\-]+$/;
+function isValidCron(cron) {
+  const fields = cron.trim().split(/\s+/);
+  if (fields.length !== 5) return false;
+  return fields.every((f) => CRON_FIELD.test(f));
+}
+var SAFE_ID = /^[a-zA-Z0-9_\-]+$/;
+function isValidScheduleId(id) {
+  return SAFE_ID.test(id) && id.length <= 128;
+}
+async function ensureDb() {
+  if (!isInitialized()) {
+    await initStore();
+  }
+}
+function parseHumanCron(input) {
+  const s = input.toLowerCase().trim();
+  if (/^[\d*\/,-]+\s+[\d*\/,-]+\s+[\d*\/,-]+\s+[\d*\/,-]+\s+[\d*\/,-]+$/.test(s)) {
+    return s;
+  }
+  const dayMap = {
+    sunday: "0",
+    sun: "0",
+    monday: "1",
+    mon: "1",
+    tuesday: "2",
+    tue: "2",
+    wednesday: "3",
+    wed: "3",
+    thursday: "4",
+    thu: "4",
+    friday: "5",
+    fri: "5",
+    saturday: "6",
+    sat: "6"
+  };
+  const everyMatch = s.match(/every\s+(\d+)\s*([mh])/);
+  if (everyMatch) {
+    const n = everyMatch[1];
+    const unit = everyMatch[2];
+    if (unit === "m") return `*/${n} * * * *`;
+    if (unit === "h") return `0 */${n} * * *`;
+  }
+  let hour = -1;
+  let minute = 0;
+  if (/midnight/.test(s)) {
+    hour = 0;
+  } else if (/noon/.test(s)) {
+    hour = 12;
+  } else {
+    const timeMatch = s.match(/(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/);
+    if (timeMatch) {
+      hour = parseInt(timeMatch[1], 10);
+      minute = timeMatch[2] ? parseInt(timeMatch[2], 10) : 0;
+      if (timeMatch[3] === "pm" && hour < 12) hour += 12;
+      if (timeMatch[3] === "am" && hour === 12) hour = 0;
+    }
+  }
+  if (hour === -1) hour = 0;
+  let dow = "*";
+  if (/weekday|weekdays/.test(s)) {
+    dow = "1-5";
+  } else if (/weekend|weekends/.test(s)) {
+    dow = "0,6";
+  } else {
+    for (const [name, val] of Object.entries(dayMap)) {
+      if (s.includes(name)) {
+        dow = val;
+        break;
+      }
+    }
+  }
+  return `${minute} ${hour} * * ${dow}`;
+}
+async function createSchedule(input) {
+  if (!isValidCron(input.cron)) {
+    throw new Error(`Invalid cron expression: ${input.cron}. Must be 5 fields with only digits, *, /, -, comma.`);
+  }
+  await ensureDb();
+  const client = getClient();
+  const id = crypto.randomUUID().slice(0, 8);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const prompt = input.prompt ?? input.description;
+  await client.execute({
+    sql: `INSERT INTO schedules (id, cron, description, job_type, prompt, assigned_to, project_name, active, use_crontab, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, 1, ?, ?)`,
+    args: [
+      id,
+      input.cron,
+      input.description,
+      input.jobType ?? "report",
+      prompt,
+      input.assignedTo ?? null,
+      input.projectName ?? null,
+      input.useCrontab ? 1 : 0,
+      now
+    ]
+  });
+  if (input.useCrontab) {
+    addToCrontab(id, input.cron, prompt, input.projectName);
+  }
+  return {
+    id,
+    cron: input.cron,
+    description: input.description,
+    jobType: input.jobType ?? "report",
+    prompt,
+    assignedTo: input.assignedTo,
+    projectName: input.projectName,
+    active: true,
+    useCrontab: input.useCrontab ?? false,
+    createdAt: now
+  };
+}
+async function listSchedules(activeOnly = true) {
+  await ensureDb();
+  const client = getClient();
+  const sql = activeOnly ? "SELECT * FROM schedules WHERE active = 1 ORDER BY created_at ASC" : "SELECT * FROM schedules ORDER BY created_at ASC";
+  const result = await client.execute({ sql, args: [] });
+  return result.rows.map((row) => ({
+    id: String(row.id),
+    cron: String(row.cron),
+    description: String(row.description),
+    jobType: String(row.job_type),
+    prompt: row.prompt ? String(row.prompt) : void 0,
+    assignedTo: row.assigned_to ? String(row.assigned_to) : void 0,
+    projectName: row.project_name ? String(row.project_name) : void 0,
+    active: Number(row.active) === 1,
+    useCrontab: Number(row.use_crontab) === 1,
+    createdAt: String(row.created_at)
+  }));
+}
+async function deleteSchedule(id) {
+  await ensureDb();
+  const client = getClient();
+  const existing = await client.execute({
+    sql: "SELECT use_crontab FROM schedules WHERE id = ?",
+    args: [id]
+  });
+  if (existing.rows.length === 0) return false;
+  const usesCrontab = Number(existing.rows[0].use_crontab) === 1;
+  await client.execute({
+    sql: "DELETE FROM schedules WHERE id = ?",
+    args: [id]
+  });
+  if (usesCrontab) {
+    removeFromCrontab(id);
+  }
+  return true;
+}
+function addToCrontab(id, cron, prompt, projectDir) {
+  if (!isValidCron(cron)) {
+    throw new Error(`Invalid cron expression: ${cron}`);
+  }
+  if (!isValidScheduleId(id)) {
+    throw new Error(`Invalid schedule ID: ${id}`);
+  }
+  try {
+    const cwd = projectDir ? `cd ${JSON.stringify(projectDir)} && ` : "";
+    const escapedPrompt = prompt.replace(/"/g, '\\"');
+    const entry = `${cron} ${cwd}claude -p --dangerously-skip-permissions "${escapedPrompt}" # exe-schedule:${id}`;
+    execSync(
+      `(crontab -l 2>/dev/null; echo ${JSON.stringify(entry)}) | crontab -`,
+      { timeout: 5e3, stdio: "ignore" }
+    );
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("Invalid")) throw err;
+  }
+}
+function removeFromCrontab(id) {
+  if (!isValidScheduleId(id)) return;
+  try {
+    execSync(
+      `crontab -l 2>/dev/null | grep -v "exe-schedule:${id}" | crontab -`,
+      { timeout: 5e3, stdio: "ignore" }
+    );
+  } catch {
+  }
+}
+
+export {
+  parseHumanCron,
+  createSchedule,
+  listSchedules,
+  deleteSchedule
+};