avorelo 0.1.0 → 0.2.0

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

@@ -1,423 +0,0 @@
-"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,
-};