@depctdev/depct 0.1.0

package/README.md

@@ -0,0 +1,34 @@
+# depct CLI (MVP)
+
+Run Node applications with Depct instrumentation without manually setting `NODE_OPTIONS`.
+
+## Usage
+
+```bash
+npx @kiranpoudel/depct run -- node server.js
+```
+
+That command auto-injects `depct-loader` and defaults to verbose diagnostics to match your manual setup:
+
+- `DEPCT_DEBUG=true` (unless already set)
+- `DEPCT_DEBUG_EVENTS=true` (unless already set)
+- `DEPCT_PROJECT_ROOT=$PWD` (unless already set)
+
+## Options
+
+- `--project-root <path>` -> `DEPCT_PROJECT_ROOT`
+- `--project-id <id>` -> `DEPCT_PROJECT_ID`
+- `--server-url <url>` -> `DEPCT_SERVER_URL`
+- `--events-path <path>` -> `DEPCT_EVENTS_PATH`
+- `--flush-max-events <n>` -> `DEPCT_FLUSH_MAX_EVENTS`
+- `--flush-interval-ms <n>` -> `DEPCT_FLUSH_INTERVAL_MS`
+- `--sample-rate <0..1>` -> `DEPCT_SAMPLE_RATE`
+- `--debug` / `--no-debug`
+- `--debug-events` / `--no-debug-events`
+
+Examples:
+
+```bash
+npx @kiranpoudel/depct run --project-id my-api -- node server.js
+npx @kiranpoudel/depct run --no-debug-events -- node server.js
+```

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@depctdev/depct",
+  "version": "0.1.0",
+  "description": "CLI for running Node apps with Depct instrumentation",
+  "bin": {
+    "depct": "src/index.cjs"
+  },
+  "type": "commonjs",
+  "main": "./src/index.cjs",
+  "files": [
+    "src"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "depct-loader": "0.1.0"
+  }
+}

package/src/index.cjs

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawn } = require("node:child_process");
+
+const HELP = `depct CLI
+
+Usage:
+  depct run [options] -- <command> [args...]
+  depct run [options] <command> [args...]
+
+Examples:
+  depct run -- node server.js
+  depct run --project-id my-api --server-url http://localhost:3100 -- node server.js
+  depct run --no-debug-events -- node server.js
+
+Options:
+  --project-root <path>          Set DEPCT_PROJECT_ROOT (default: current directory)
+  --project-id <id>              Set DEPCT_PROJECT_ID
+  --server-url <url>             Set DEPCT_SERVER_URL
+  --events-path <path>           Set DEPCT_EVENTS_PATH
+  --flush-max-events <n>         Set DEPCT_FLUSH_MAX_EVENTS
+  --flush-interval-ms <n>        Set DEPCT_FLUSH_INTERVAL_MS
+  --sample-rate <0..1>           Set DEPCT_SAMPLE_RATE
+  --debug / --no-debug           Set DEPCT_DEBUG (default: true)
+  --debug-events / --no-debug-events
+                                 Set DEPCT_DEBUG_EVENTS (default: true)
+  -h, --help                     Show help
+`;
+
+function fail(message) {
+  process.stderr.write(`depct: ${message}\n`);
+  process.stderr.write("Run `depct --help` for usage.\n");
+  process.exit(1);
+}
+
+function printHelp(exitCode = 0) {
+  process.stdout.write(`${HELP}\n`);
+  process.exit(exitCode);
+}
+
+function quoteNodeOptionValue(value) {
+  const escaped = String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `"${escaped}"`;
+}
+
+function resolveLoaderEntry() {
+  try {
+    return require.resolve("depct-loader");
+  } catch {
+    const fallback = path.resolve(__dirname, "../../loader/src/index.cjs");
+    if (fs.existsSync(fallback)) return fallback;
+  }
+
+  fail(
+    "Unable to resolve loader entrypoint. Ensure `depct-loader` is installed or available in the monorepo."
+  );
+}
+
+function withNodeOptions(existingValue, loaderEntry) {
+  const trimmed = String(existingValue || "").trim();
+  if (trimmed.includes(loaderEntry)) {
+    return trimmed;
+  }
+
+  const requireOpt = `--require ${quoteNodeOptionValue(loaderEntry)}`;
+  return trimmed ? `${trimmed} ${requireOpt}` : requireOpt;
+}
+
+function inferProjectIdFromPackageJson(rootDir) {
+  try {
+    const packageJsonPath = path.resolve(rootDir, "package.json");
+    const raw = fs.readFileSync(packageJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.name === "string" && parsed.name.trim()) {
+      return parsed.name.trim();
+    }
+  } catch {
+    // no-op
+  }
+
+  return undefined;
+}
+
+function parseRunArgs(argv) {
+  const options = {
+    debug: undefined,
+    debugEvents: undefined,
+  };
+
+  let i = 0;
+  let command = [];
+
+  while (i < argv.length) {
+    const arg = argv[i];
+
+    if (arg === "--") {
+      command = argv.slice(i + 1);
+      break;
+    }
+
+    if (!arg.startsWith("-")) {
+      command = argv.slice(i);
+      break;
+    }
+
+    const next = argv[i + 1];
+    const readValue = (flag) => {
+      if (next == null || next.startsWith("-")) {
+        fail(`Missing value for ${flag}`);
+      }
+      i += 1;
+      return next;
+    };
+
+    if (arg === "-h" || arg === "--help") {
+      printHelp(0);
+    } else if (arg === "--project-root") {
+      options.projectRoot = readValue(arg);
+    } else if (arg === "--project-id") {
+      options.projectId = readValue(arg);
+    } else if (arg === "--server-url") {
+      options.serverUrl = readValue(arg);
+    } else if (arg === "--events-path") {
+      options.eventsPath = readValue(arg);
+    } else if (arg === "--flush-max-events") {
+      options.flushMaxEvents = readValue(arg);
+    } else if (arg === "--flush-interval-ms") {
+      options.flushIntervalMs = readValue(arg);
+    } else if (arg === "--sample-rate") {
+      options.sampleRate = readValue(arg);
+    } else if (arg === "--debug") {
+      options.debug = true;
+    } else if (arg === "--no-debug") {
+      options.debug = false;
+    } else if (arg === "--debug-events") {
+      options.debugEvents = true;
+    } else if (arg === "--no-debug-events") {
+      options.debugEvents = false;
+    } else {
+      fail(`Unknown option: ${arg}`);
+    }
+
+    i += 1;
+  }
+
+  if (command.length === 0) {
+    fail("Missing target command. Use `depct run -- node server.js`.");
+  }
+
+  return {
+    options,
+    command,
+  };
+}
+
+function applyEnvOptions(baseEnv, options) {
+  const env = { ...baseEnv };
+  const setIfProvided = (key, value) => {
+    if (value !== undefined) env[key] = String(value);
+  };
+
+  setIfProvided("DEPCT_PROJECT_ROOT", options.projectRoot && path.resolve(options.projectRoot));
+  setIfProvided("DEPCT_PROJECT_ID", options.projectId);
+  setIfProvided("DEPCT_SERVER_URL", options.serverUrl);
+  setIfProvided("DEPCT_EVENTS_PATH", options.eventsPath);
+  setIfProvided("DEPCT_FLUSH_MAX_EVENTS", options.flushMaxEvents);
+  setIfProvided("DEPCT_FLUSH_INTERVAL_MS", options.flushIntervalMs);
+  setIfProvided("DEPCT_SAMPLE_RATE", options.sampleRate);
+
+  if (!env.DEPCT_PROJECT_ROOT) {
+    env.DEPCT_PROJECT_ROOT = process.cwd();
+  }
+
+  if (!env.DEPCT_PROJECT_ID) {
+    const inferredProjectId = inferProjectIdFromPackageJson(env.DEPCT_PROJECT_ROOT);
+    if (inferredProjectId) {
+      env.DEPCT_PROJECT_ID = inferredProjectId;
+    }
+  }
+
+  // Keep verbose parity with the manual command unless explicitly disabled.
+  if (options.debug !== undefined) {
+    env.DEPCT_DEBUG = options.debug ? "true" : "false";
+  } else if (!env.DEPCT_DEBUG) {
+    env.DEPCT_DEBUG = "true";
+  }
+
+  if (options.debugEvents !== undefined) {
+    env.DEPCT_DEBUG_EVENTS = options.debugEvents ? "true" : "false";
+  } else if (!env.DEPCT_DEBUG_EVENTS) {
+    env.DEPCT_DEBUG_EVENTS = "true";
+  }
+
+  return env;
+}
+
+function run(argv) {
+  if (argv.length === 0 || argv[0] === "-h" || argv[0] === "--help") {
+    printHelp(0);
+  }
+
+  const commandName = argv[0];
+  if (commandName !== "run") {
+    fail(`Unknown command: ${commandName}`);
+  }
+
+  const { options, command } = parseRunArgs(argv.slice(1));
+  const [execPath, ...execArgs] = command;
+  const loaderEntry = resolveLoaderEntry();
+  const env = applyEnvOptions(process.env, options);
+  env.NODE_OPTIONS = withNodeOptions(env.NODE_OPTIONS, loaderEntry);
+
+  const child = spawn(execPath, execArgs, {
+    stdio: "inherit",
+    cwd: process.cwd(),
+    env,
+    shell: false,
+  });
+
+  child.on("error", (error) => {
+    fail(`Failed to launch command "${execPath}": ${error.message}`);
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code ?? 0);
+  });
+}
+
+run(process.argv.slice(2));