run-analysis.ts

import { SpawnOptions, spawn } from "node:child_process";
import path from "node:path";

import { Account } from "@tago-io/sdk";

import { getEnvironmentConfig, IEnvironment, resolveCLIPath } from "../../lib/config-file.js";
import { detectRuntime } from "../../lib/current-runtime.js";
import { errorHandler, highlightMSG, successMSG } from "../../lib/messages.js";
import { requireLocalScope } from "../../lib/resolve-scope.js";
import { searchName } from "../../lib/search-name.js";
import { pickAnalysisFromConfig } from "../../prompt/pick-analysis-from-config.js";

/**
 * Builds the command to run the analysis.
 * @param options - The options to configure the command.
 * @param options.tsnd - Whether to use `tsnd` to run the command.
 * @param options.debug - Whether to enable debugging for the command.
 * @param options.clear - Whether to clear the console before running the command.
 * @param options.runtime - The runtime to use ('deno' or 'node').
 * @returns The built command as a string.
 */
function _buildCMD(options: { tsnd: boolean; debug: boolean; clear: boolean }, runtimeParam: string): string {
  let cmd: string = "";
  const runtime = runtimeParam === "--deno" ? "deno" : "node";

  if (runtime === "deno") {
    cmd = `deno run --allow-all --watch `;
    if (options.debug) {
      cmd += "--inspect ";
    }
  } else {
    switch (options.tsnd) {
      case true: {
        cmd = `tsnd `;
        if (options.debug) {
          cmd += "--inspect -- ";
        }
        break;
      }

      default: {
        // tsx wraps node with a CJS/ESM-aware TypeScript loader. Needed
        // because Node's native --experimental-transform-types forces ESM
        // resolution, which breaks legacy analyses that import CJS
        // subpaths without a `.js` extension (e.g. "@tago-io/sdk/lib/types").
        cmd = `node ${resolveCLIPath("/node_modules/tsx/dist/cli.mjs")} watch `;
        if (options.debug) {
          cmd += "--inspect ";
        }
        break;
      }
    }
    if (options.clear) {
      cmd += "--clear ";
    }
  }

  return cmd;
}

/**
 * Runs an analysis script.
 * @param scriptName - The name of the script to run.
 * @param options - The options for running the script.
 * @returns void
 */
async function runAnalysis(
  scriptName: string | undefined,
  options: { environment: string; debug: boolean; clear: boolean; tsnd: boolean; deno: boolean; node: boolean },
) {
  // Analysis development requires a project directory.
  const scope = requireLocalScope("analysis-run");

  const config = getEnvironmentConfig(options.environment);
  if (!config || !config.profileToken) {
    errorHandler("Environment not found");
  }

  const analysisList = (config.analysisList ?? []).filter((x) => x.fileName);
  let scriptToRun: NonNullable<IEnvironment["analysisList"]>[number];
  if (scriptName) {
    scriptName = scriptName.toLowerCase();
    scriptToRun = searchName(
      scriptName,
      analysisList.map((x) => ({ names: [x.name, x.fileName], value: x })),
    );
  } else {
    scriptToRun = await pickAnalysisFromConfig(analysisList);
  }

  if (!scriptToRun || !scriptToRun.id) {
    errorHandler(`Analysis couldn't be found: ${scriptName}`);
  }

  const account = new Account({ token: config.profileToken, region: config.profileRegion });

  let { token: analysisToken, run_on, name, runtime: runtimeParam } = await account.analysis.info(scriptToRun.id);
  const tokenSuffix = analysisToken ? ` [${highlightMSG(analysisToken)}]` : "";
  successMSG(`> Analysis found: ${highlightMSG(scriptToRun.fileName)} (${name})${tokenSuffix}.`);

  const analysisEnv: { [key: string]: string } = {
    ...process.env,
    T_EXTERNAL: "external",
    T_ANALYSIS_TOKEN: analysisToken,
    T_ANALYSIS_ID: scriptToRun.id,
  };

  if (typeof config.profileRegion === "object") {
    analysisEnv.TAGOIO_API = config.profileRegion.api;
    if (config.profileRegion.sse) {
      analysisEnv.TAGOIO_SSE = config.profileRegion.sse;
    }
  }

  const spawnOptions: SpawnOptions = {
    shell: true,
    cwd: scope.root,
    stdio: "inherit",
    env: analysisEnv,
  };

  let scriptPath;
  if (scriptToRun.path) {
    scriptPath = path.join(config.analysisPath.concat("/", scriptToRun.path + "/"), scriptToRun.fileName).normalize();
  } else {
    scriptPath = path.join(config.analysisPath, scriptToRun.fileName).normalize();
  }

  let runtime;
  if (options.deno && options.node) {
    errorHandler("Cannot specify both --deno and --node flags");
  } else if (options.deno) {
    runtime = "--deno";
  } else if (options.node) {
    runtime = "--node";
  } else {
    runtime = detectRuntime(runtimeParam || "");
  }

  const cmd = _buildCMD(options, runtime);

  if (run_on === "tago") {
    await account.analysis.edit(scriptToRun.id, { run_on: "external" });
    await new Promise((resolve) => setTimeout(resolve, 200)); // sleep
    ({ token: analysisToken, run_on, name } = await account.analysis.info(scriptToRun.id));
    if (spawnOptions?.env) {
      spawnOptions.env.T_ANALYSIS_TOKEN = analysisToken;
    }
  }
  const spawnProccess = spawn(`${cmd}${scriptPath}`, spawnOptions);

  const killAnalysis = async () => await account.analysis.edit(scriptToRun.id, { run_on: "tago" });
  spawnProccess.on("close", killAnalysis);
  spawnProccess.on("SIGINT", killAnalysis);
}
export { runAnalysis, _buildCMD };