avorelo 0.1.0

package/scripts/lib/local-package-smoke.js

@@ -0,0 +1,423 @@
+"use strict";
+
+// Local package smoke: pack tarball, install it in an isolated temp project,
+// then verify the real first-use CLI path without mutating the source repo,
+// touching the network, or writing to the user's real home directory.
+
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const { nowIso } = require("./fsx");
+const { appendProductLearningEvent } = require("./product-learning-events");
+const {
+  createTempDir,
+  readPackageJson,
+  runNpm,
+  runNpx,
+  collectRuntimeDependencyGraph,
+  findMissingRuntimeDependencies,
+  getPublicRuntimeEntryFiles,
+  redactPathsInValue,
+} = require("./package-runtime");
+
+const CONTRACT = "avorelo.localPackageSmoke.v1";
+const SCHEMA_VERSION = 1;
+const ARTIFACT_DIR_REL = ".claude/cco/orchestration/public-distribution";
+const ARTIFACT_REL = ARTIFACT_DIR_REL + "/latest-local-package-smoke.json";
+const EXEC_TIMEOUT = 120000;
+const ACTIVATE_CONTRACT = "avorelo.alphaActivation.v1";
+
+function buildLocalPackageSmokePlan() {
+  return {
+    steps: [
+      "create_temp_dir",
+      "audit_runtime_dependencies",
+      "npm_pack_to_temp",
+      "create_temp_project",
+      "npm_install_tarball_into_temp_project",
+      "run_activate_help",
+      "run_status_help",
+      "run_dashboard_help",
+      "run_activate_json",
+      "run_status_text",
+      "run_dashboard_json",
+      "verify_source_repo_untouched",
+      "cleanup",
+    ],
+    notes: [
+      "Never runs npm publish.",
+      "Runs the packed CLI only inside an isolated temp project.",
+      "Redirects USERPROFILE/HOME to a temp home so no real global config is touched.",
+      "Uses a temp npm cache so PowerShell/npm cache permissions do not leak into the smoke result.",
+      "Cleans up temp files unless debug mode is enabled.",
+    ],
+  };
+}
+
+function buildCommandRecord(command, result, tempPaths) {
+  return redactPathsInValue({
+    command,
+    success: result.success,
+    stdout: (result.stdout || "").slice(0, 1200),
+    stderr: (result.stderr || "").slice(0, 1200),
+    combinedOutput: (result.combinedOutput || "").slice(0, 1200),
+  }, tempPaths);
+}
+
+function repoStatusSnapshot(cwd) {
+  const result = spawnSync("git", ["status", "--short"], {
+    cwd,
+    encoding: "utf8",
+    timeout: 30000,
+    stdio: "pipe",
+  });
+  return result.status === 0 ? (result.stdout || "").trim() : null;
+}
+
+function cleanup(tmpDir, debug, result) {
+  if (!debug && tmpDir) {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  }
+  return result;
+}
+
+function buildBaseResult(overrides = {}) {
+  return {
+    contract: CONTRACT,
+    schemaVersion: SCHEMA_VERSION,
+    generatedAt: nowIso(),
+    status: "fail",
+    passed: false,
+    tarballCreated: false,
+    installSucceeded: false,
+    activateHelpSucceeded: false,
+    statusHelpSucceeded: false,
+    dashboardHelpSucceeded: false,
+    realActivationSucceeded: false,
+    realStatusSucceeded: false,
+    realDashboardSucceeded: false,
+    tempProjectRedacted: true,
+    sourceRepoUntouched: false,
+    runtimeDependenciesOk: false,
+    runtimeExternalDependencies: [],
+    missingRuntimeDependencies: [],
+    missingLocalRuntimeFiles: [],
+    commandOutputsSummarized: {
+      activateHelp: null,
+      statusHelp: null,
+      dashboardHelp: null,
+      realActivation: null,
+      realStatus: null,
+      realDashboard: null,
+    },
+    commands: [],
+    installError: null,
+    safeNextAction: "Local package smoke failed.",
+    noPublicLaunchClaim: true,
+    redacted: true,
+    ...overrides,
+  };
+}
+
+function buildSkippedResult(reason, overrides = {}) {
+  return buildBaseResult({
+    status: "skip",
+    safeNextAction: "Smoke test skipped: " + reason,
+    ...overrides,
+  });
+}
+
+function buildFailResult(reason, overrides = {}) {
+  return buildBaseResult({
+    status: "fail",
+    safeNextAction: reason,
+    ...overrides,
+  });
+}
+
+function writeTempProject(projectDir) {
+  fs.mkdirSync(projectDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(projectDir, "package.json"),
+    JSON.stringify({
+      name: "avorelo-packed-smoke-project",
+      version: "1.0.0",
+      private: true,
+    }, null, 2),
+    "utf8"
+  );
+  fs.mkdirSync(path.join(projectDir, ".git"), { recursive: true });
+}
+
+function parseJsonOutput(result) {
+  if (!result || !result.success) return null;
+  try {
+    return JSON.parse(result.stdout || "");
+  } catch {
+    return null;
+  }
+}
+
+function didRealPackedCliSmokePass(smoke) {
+  return !!(
+    smoke &&
+    smoke.installSucceeded === true &&
+    smoke.runtimeDependenciesOk === true &&
+    smoke.activateHelpSucceeded === true &&
+    smoke.statusHelpSucceeded === true &&
+    smoke.dashboardHelpSucceeded === true &&
+    smoke.realActivationSucceeded === true &&
+    smoke.realStatusSucceeded === true &&
+    smoke.realDashboardSucceeded === true &&
+    smoke.tempProjectRedacted === true &&
+    smoke.sourceRepoUntouched === true &&
+    Array.isArray(smoke.missingRuntimeDependencies) &&
+    smoke.missingRuntimeDependencies.length === 0 &&
+    Array.isArray(smoke.missingLocalRuntimeFiles) &&
+    smoke.missingLocalRuntimeFiles.length === 0
+  );
+}
+
+function runPackedCliSmoke(tempDir, tarballPath, sourceRepoCwd) {
+  const pkg = readPackageJson(sourceRepoCwd);
+  const runtimeGraph = collectRuntimeDependencyGraph(sourceRepoCwd, {
+    entryFiles: getPublicRuntimeEntryFiles(sourceRepoCwd),
+  });
+  const missingRuntimeDependencies = findMissingRuntimeDependencies(pkg, runtimeGraph);
+  const tempProjectDir = path.join(tempDir, "project");
+  const tempHomeDir = path.join(tempDir, "home");
+  const cacheDir = path.join(tempDir, "npm-cache");
+  const tempPaths = [tempDir, tempProjectDir, tempHomeDir, cacheDir, tarballPath];
+  const sourceRepoStatusBefore = repoStatusSnapshot(sourceRepoCwd);
+
+  fs.mkdirSync(tempHomeDir, { recursive: true });
+  fs.mkdirSync(cacheDir, { recursive: true });
+  writeTempProject(tempProjectDir);
+
+  const sharedEnv = {
+    USERPROFILE: tempHomeDir,
+    HOME: tempHomeDir,
+    AVORELO_PLAN: "free",
+  };
+
+  const installResult = runNpm([
+    "install",
+    "--no-package-lock",
+    "--ignore-scripts",
+    "--no-save",
+    tarballPath,
+  ], {
+    cwd: tempProjectDir,
+    timeoutMs: EXEC_TIMEOUT,
+    cacheDir,
+    env: sharedEnv,
+  });
+
+  if (!installResult.success) {
+    return {
+      installSucceeded: false,
+      installError: redactPathsInValue(installResult.errorSummary, tempPaths),
+      commands: [],
+      sourceRepoUntouched: repoStatusSnapshot(sourceRepoCwd) === sourceRepoStatusBefore,
+      tempProjectRedacted: true,
+      runtimeDependenciesOk: missingRuntimeDependencies.length === 0 && runtimeGraph.missingLocalFiles.length === 0,
+      runtimeExternalDependencies: runtimeGraph.externalPackages,
+      missingRuntimeDependencies,
+      missingLocalRuntimeFiles: runtimeGraph.missingLocalFiles,
+      tempPaths,
+    };
+  }
+
+  const commandSpecs = [
+    { id: "activateHelp", command: ["activate", "--help"] },
+    { id: "statusHelp", command: ["status", "--help"] },
+    { id: "dashboardHelp", command: ["dashboard", "--help"] },
+    { id: "realActivation", command: ["activate", "--json"] },
+    { id: "realStatus", command: ["status", "--text"] },
+    { id: "realDashboard", command: ["dashboard", "--json"] },
+  ];
+
+  const commandResults = commandSpecs.map((spec) => {
+    const result = runNpx(["--no-install", "avorelo", ...spec.command], {
+      cwd: tempProjectDir,
+      timeoutMs: EXEC_TIMEOUT,
+      cacheDir,
+      env: sharedEnv,
+    });
+    return {
+      id: spec.id,
+      command: `npx --no-install avorelo ${spec.command.join(" ")}`,
+      raw: result,
+      record: buildCommandRecord(`npx --no-install avorelo ${spec.command.join(" ")}`, result, tempPaths),
+    };
+  });
+
+  const getResult = (id) => commandResults.find((entry) => entry.id === id);
+  const activationPayload = parseJsonOutput(getResult("realActivation").raw);
+  const dashboardPayload = parseJsonOutput(getResult("realDashboard").raw);
+
+  const realActivationSucceeded = !!(
+    getResult("realActivation").raw.success &&
+    activationPayload &&
+    activationPayload.contract === ACTIVATE_CONTRACT
+  );
+  const realStatusSucceeded = !!(
+    getResult("realStatus").raw.success &&
+    String(getResult("realStatus").raw.combinedOutput || "").trim().length > 0
+  );
+  const realDashboardSucceeded = !!(
+    getResult("realDashboard").raw.success &&
+    dashboardPayload &&
+    typeof dashboardPayload === "object"
+  );
+  const sourceRepoUntouched = repoStatusSnapshot(sourceRepoCwd) === sourceRepoStatusBefore;
+  const redactedCommands = commandResults.map((entry) => entry.record);
+  const redactedSerialized = JSON.stringify(redactedCommands);
+  const tempProjectRedacted = !tempPaths.some((tempPath) => redactedSerialized.includes(String(tempPath)));
+
+  return {
+    installSucceeded: true,
+    installError: null,
+    commands: redactedCommands,
+    activateHelpSucceeded: getResult("activateHelp").raw.success,
+    statusHelpSucceeded: getResult("statusHelp").raw.success,
+    dashboardHelpSucceeded: getResult("dashboardHelp").raw.success,
+    realActivationSucceeded,
+    realStatusSucceeded,
+    realDashboardSucceeded,
+    sourceRepoUntouched,
+    tempProjectRedacted,
+    runtimeDependenciesOk: missingRuntimeDependencies.length === 0 && runtimeGraph.missingLocalFiles.length === 0,
+    runtimeExternalDependencies: runtimeGraph.externalPackages,
+    missingRuntimeDependencies,
+    missingLocalRuntimeFiles: runtimeGraph.missingLocalFiles,
+    commandOutputsSummarized: {
+      activateHelp: getResult("activateHelp").record.combinedOutput || null,
+      statusHelp: getResult("statusHelp").record.combinedOutput || null,
+      dashboardHelp: getResult("dashboardHelp").record.combinedOutput || null,
+      realActivation: getResult("realActivation").record.combinedOutput || null,
+      realStatus: getResult("realStatus").record.combinedOutput || null,
+      realDashboard: getResult("realDashboard").record.combinedOutput || null,
+    },
+  };
+}
+
+function runLocalPackageSmoke(cwd, options = {}) {
+  if (options.forcedResult) return options.forcedResult;
+
+  const npmCheck = runNpm(["--version"], {
+    cwd,
+    timeoutMs: 30000,
+    cacheLabel: "package-smoke-version",
+  });
+  if (!npmCheck.success) {
+    return buildSkippedResult("npm not available: " + (npmCheck.errorSummary || "unknown"));
+  }
+
+  const debug = !!options.debug;
+  const tmpDir = createTempDir("avorelo-smoke-");
+  let tarballPath = null;
+  let tarballCreated = false;
+
+  try {
+    const cacheDir = path.join(tmpDir, "npm-cache");
+    const packResult = runNpm(["pack", "--pack-destination", tmpDir], {
+      cwd,
+      timeoutMs: EXEC_TIMEOUT,
+      cacheDir,
+    });
+
+    if (packResult.success) {
+      const tgzName = (packResult.stdout || "").trim().split("\n").pop().trim();
+      const candidate = path.join(tmpDir, tgzName);
+      if (fs.existsSync(candidate)) {
+        tarballPath = candidate;
+        tarballCreated = true;
+      }
+    }
+
+    if (!tarballCreated || !tarballPath) {
+      return cleanup(tmpDir, debug, buildFailResult("npm pack did not produce a .tgz file."));
+    }
+
+    const smokeResult = runPackedCliSmoke(tmpDir, tarballPath, cwd);
+    const result = buildBaseResult({
+      status: "fail",
+      tarballCreated,
+      installSucceeded: smokeResult.installSucceeded,
+      activateHelpSucceeded: smokeResult.activateHelpSucceeded === true,
+      statusHelpSucceeded: smokeResult.statusHelpSucceeded === true,
+      dashboardHelpSucceeded: smokeResult.dashboardHelpSucceeded === true,
+      realActivationSucceeded: smokeResult.realActivationSucceeded === true,
+      realStatusSucceeded: smokeResult.realStatusSucceeded === true,
+      realDashboardSucceeded: smokeResult.realDashboardSucceeded === true,
+      tempProjectRedacted: smokeResult.tempProjectRedacted === true,
+      sourceRepoUntouched: smokeResult.sourceRepoUntouched === true,
+      runtimeDependenciesOk: smokeResult.runtimeDependenciesOk === true,
+      runtimeExternalDependencies: smokeResult.runtimeExternalDependencies || [],
+      missingRuntimeDependencies: smokeResult.missingRuntimeDependencies || [],
+      missingLocalRuntimeFiles: smokeResult.missingLocalRuntimeFiles || [],
+      commandOutputsSummarized: smokeResult.commandOutputsSummarized || {},
+      commands: smokeResult.commands || [],
+      installError: smokeResult.installError,
+    });
+
+    result.passed = didRealPackedCliSmokePass(result);
+    result.status = result.passed ? "pass" : "fail";
+    result.safeNextAction = result.passed
+      ? "Local packed CLI smoke passed. Proceed to install claim check."
+      : result.missingRuntimeDependencies.length > 0
+        ? "Move missing runtime packages into dependencies or remove the runtime import."
+        : result.missingLocalRuntimeFiles.length > 0
+          ? "Fix missing local runtime files required by the public CLI."
+          : !result.realActivationSucceeded
+            ? "Fix the packed real activation path before claiming ready_to_publish."
+            : !result.realStatusSucceeded
+              ? "Fix the packed real status path before claiming ready_to_publish."
+              : !result.realDashboardSucceeded
+                ? "Fix the packed real dashboard path before claiming ready_to_publish."
+                : !result.sourceRepoUntouched
+                  ? "The packed CLI mutated the source repo. Isolate the smoke further before publish."
+                  : !result.tempProjectRedacted
+                    ? "Redact temp absolute paths from smoke output before publish."
+                    : "Local packed CLI smoke failed. Check the tarball install and the real first-use commands.";
+
+    return cleanup(tmpDir, debug, result);
+  } catch (error) {
+    return cleanup(tmpDir, debug, buildFailResult(String(error).slice(0, 200), {
+      tarballCreated,
+      installSucceeded: false,
+    }));
+  }
+}
+
+function writeLocalPackageSmoke(cwd, smoke) {
+  const dir = path.join(cwd, ARTIFACT_DIR_REL);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(cwd, ARTIFACT_REL), JSON.stringify(smoke, null, 2));
+}
+
+function formatLocalPackageSmokeText(smoke) {
+  const commandCount = (smoke.commands || []).length;
+  const passedCount = (smoke.commands || []).filter((command) => command.success).length;
+  return [
+    "Local Package Smoke [" + String(smoke.status || "unknown").toUpperCase() + "]",
+    "  Tarball created: " + smoke.tarballCreated,
+    "  Install succeeded: " + smoke.installSucceeded,
+    "  Commands passed: " + passedCount + "/" + (commandCount || 6),
+    "  Real activation/status/dashboard: " + [smoke.realActivationSucceeded, smoke.realStatusSucceeded, smoke.realDashboardSucceeded].join("/"),
+    "  Runtime dependencies OK: " + smoke.runtimeDependenciesOk,
+    "  Source repo untouched: " + smoke.sourceRepoUntouched,
+    "  Next: " + smoke.safeNextAction,
+  ].join("\n");
+}
+
+module.exports = {
+  ACTIVATE_CONTRACT,
+  buildLocalPackageSmokePlan,
+  didRealPackedCliSmokePass,
+  runLocalPackageSmoke,
+  runPackedCliSmoke,
+  writeLocalPackageSmoke,
+  formatLocalPackageSmokeText,
+};