create-tradejs 1.0.10

package/README.md

@@ -0,0 +1,19 @@
+# create-tradejs
+
+Create a local TradeJS project, start Redis and Timescale, and open the Web UI.
+On the first launch, choose the local `root` password on the install page. The
+app then opens the dashboard, where **Create backtest** starts the first
+backtest flow.
+
+```bash
+npx create-tradejs
+```
+
+The default project directory is `tradejs-project`. Pass a name to choose a
+different directory:
+
+```bash
+npx create-tradejs my-trading-project
+```
+
+Docker with the Compose plugin and Node.js 20.19 or newer are required.

package/dist/index.js

@@ -0,0 +1,378 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  buildProjectFiles: () => buildProjectFiles,
+  main: () => main,
+  parseArgs: () => parseArgs,
+  scaffoldProject: () => scaffoldProject
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_child_process = require("child_process");
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_net = __toESM(require("net"));
+var import_node_path = __toESM(require("path"));
+var DEFAULT_PROJECT_NAME = "tradejs-project";
+var DEFAULT_PORT = 3e3;
+var DEFAULT_INFRASTRUCTURE_PORTS = {
+  postgres: 5432,
+  redis: 6379,
+  redisInsight: 5540
+};
+var printUsage = () => {
+  console.log(`Create a ready-to-run TradeJS project.
+
+Usage:
+  npx create-tradejs [project-directory] [options]
+
+Options:
+  --port <number>  Preferred Web UI port (default: 3000)
+  --no-install     Only generate project files
+  --no-infra       Skip Docker infrastructure and onboarding seed
+  --no-start       Do not start the Web UI
+  --no-open        Do not open a browser
+  -h, --help       Show this help`);
+};
+var readOptionValue = (argv, index) => {
+  const value = argv[index + 1];
+  if (!value || value.startsWith("-")) {
+    throw new Error(`${argv[index]} requires a value`);
+  }
+  return value;
+};
+var parseArgs = (argv) => {
+  let targetDir = "";
+  let install = true;
+  let infra = true;
+  let start = true;
+  let open = true;
+  let port = DEFAULT_PORT;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "-h" || arg === "--help") {
+      return null;
+    }
+    if (arg === "--no-install") {
+      install = false;
+      infra = false;
+      start = false;
+      continue;
+    }
+    if (arg === "--no-infra") {
+      infra = false;
+      continue;
+    }
+    if (arg === "--no-start") {
+      start = false;
+      continue;
+    }
+    if (arg === "--no-open") {
+      open = false;
+      continue;
+    }
+    if (arg === "--port") {
+      port = Number(readOptionValue(argv, index));
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--port=")) {
+      port = Number(arg.slice("--port=".length));
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+    if (targetDir) {
+      throw new Error(`Unexpected extra project directory: ${arg}`);
+    }
+    targetDir = arg;
+  }
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+    throw new Error(`Invalid port: ${port}`);
+  }
+  if (!install && (infra || start)) {
+    throw new Error("--no-install cannot start infrastructure or the Web UI");
+  }
+  return {
+    targetDir: targetDir || DEFAULT_PROJECT_NAME,
+    install,
+    infra,
+    start,
+    open,
+    port
+  };
+};
+var packageNameFromDir = (targetDir) => {
+  const normalized = import_node_path.default.basename(targetDir).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || DEFAULT_PROJECT_NAME;
+};
+var createAuthSecret = () => (0, import_node_crypto.randomBytes)(32).toString("hex");
+var buildProjectFiles = (targetDir, port, infrastructurePorts = DEFAULT_INFRASTRUCTURE_PORTS) => {
+  const packageName = packageNameFromDir(targetDir);
+  const authSecret = createAuthSecret();
+  const packageVersion = String(process.env.CREATE_TRADEJS_PACKAGE_VERSION || "").trim() || "latest";
+  const packageSpec = (name) => String(process.env[`CREATE_TRADEJS_${name}_PACKAGE`] || "").trim() || packageVersion;
+  const infraPackage = String(
+    process.env.CREATE_TRADEJS_INFRA_PACKAGE || ""
+  ).trim();
+  const dependencies = {
+    "@tradejs/app": packageSpec("APP"),
+    "@tradejs/base": packageSpec("BASE"),
+    "@tradejs/cli": packageSpec("CLI"),
+    "@tradejs/core": packageSpec("CORE"),
+    ...infraPackage ? { "@tradejs/infra": infraPackage } : {}
+  };
+  return {
+    "package.json": `${JSON.stringify(
+      {
+        name: packageName,
+        version: "0.1.0",
+        private: true,
+        scripts: {
+          dev: "tradejs-app dev",
+          backtest: "tradejs backtest",
+          doctor: "tradejs doctor --skip-ml",
+          "infra-up": "tradejs infra-up",
+          "infra-down": "tradejs infra-down"
+        },
+        dependencies,
+        engines: {
+          node: ">=20.19"
+        }
+      },
+      null,
+      2
+    )}
+`,
+    "tradejs.config.ts": `import { basePreset } from '@tradejs/base';
+import { defineConfig } from '@tradejs/core/config';
+
+export default defineConfig(basePreset);
+`,
+    ".env": `AUTH_SECRET=${authSecret}
+NEXTAUTH_SECRET=${authSecret}
+NEXTAUTH_URL=http://localhost:${port}
+APP_URL=http://localhost:${port}
+PG_PORT=${infrastructurePorts.postgres}
+REDIS_PORT=${infrastructurePorts.redis}
+REDIS_INSIGHT_PORT=${infrastructurePorts.redisInsight}
+`,
+    ".gitignore": `node_modules
+.tradejs
+.next
+data
+.env
+`,
+    "README.md": `# ${packageName}
+
+This project was created with \`create-tradejs\`.
+
+## Start
+
+\`\`\`bash
+npm run infra-up
+npm run dev
+\`\`\`
+
+Open [http://localhost:${port}/routes/dashboard](http://localhost:${port}/routes/dashboard).
+On the first launch, TradeJS asks you to create the local root password.
+`
+  };
+};
+var scaffoldProject = (targetDir, port, infrastructurePorts = DEFAULT_INFRASTRUCTURE_PORTS) => {
+  const absoluteTarget = import_node_path.default.resolve(targetDir);
+  if ((0, import_node_fs.existsSync)(absoluteTarget) && (0, import_node_fs.readdirSync)(absoluteTarget).length > 0) {
+    throw new Error(`Target directory is not empty: ${absoluteTarget}`);
+  }
+  (0, import_node_fs.mkdirSync)(absoluteTarget, { recursive: true });
+  const files = buildProjectFiles(absoluteTarget, port, infrastructurePorts);
+  for (const [relativePath, contents] of Object.entries(files)) {
+    (0, import_node_fs.writeFileSync)(import_node_path.default.join(absoluteTarget, relativePath), contents, "utf8");
+  }
+  return absoluteTarget;
+};
+var run = (command, args, cwd) => {
+  const result = (0, import_node_child_process.spawnSync)(command, args, {
+    cwd,
+    env: { ...process.env, PROJECT_CWD: cwd },
+    stdio: "inherit"
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(
+      `${command} ${args.join(" ")} failed with code ${result.status}`
+    );
+  }
+};
+var localBin = (projectDir, name) => import_node_path.default.join(
+  projectDir,
+  "node_modules",
+  ".bin",
+  process.platform === "win32" ? `${name}.cmd` : name
+);
+var isPortAvailable = (port) => new Promise((resolve) => {
+  const server = import_node_net.default.createServer();
+  server.unref();
+  server.once("error", () => resolve(false));
+  server.listen(port, () => server.close(() => resolve(true)));
+});
+var findAvailablePort = async (preferredPort) => {
+  for (let offset = 0; offset < 20; offset += 1) {
+    const port = preferredPort + offset;
+    if (await isPortAvailable(port)) {
+      return port;
+    }
+  }
+  throw new Error(`No available port found starting at ${preferredPort}`);
+};
+var openBrowser = (url) => {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  const child = (0, import_node_child_process.spawn)(command, args, { detached: true, stdio: "ignore" });
+  child.once("error", (error) => {
+    console.warn(`Could not open the browser automatically: ${error.message}`);
+  });
+  child.unref();
+};
+var waitForApp = async (url, child) => {
+  for (let attempt = 0; attempt < 120; attempt += 1) {
+    if (child.exitCode !== null) {
+      throw new Error(
+        `Web UI exited before it became ready (code ${child.exitCode})`
+      );
+    }
+    try {
+      const response = await fetch(url, { redirect: "manual" });
+      if (response.status > 0 && response.status < 500) {
+        return;
+      }
+    } catch {
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+  throw new Error(`Timed out waiting for ${url}`);
+};
+var startWebApp = async (projectDir, preferredPort, shouldOpen) => {
+  const port = await findAvailablePort(preferredPort);
+  const installUrl = `http://localhost:${port}/routes/install`;
+  const appBin = localBin(projectDir, "tradejs-app");
+  const child = (0, import_node_child_process.spawn)(appBin, ["dev", "--port", String(port)], {
+    cwd: projectDir,
+    env: {
+      ...process.env,
+      PROJECT_CWD: projectDir,
+      PORT: String(port),
+      APP_URL: `http://localhost:${port}`,
+      NEXTAUTH_URL: `http://localhost:${port}`
+    },
+    stdio: "inherit"
+  });
+  const launchError = new Promise((_, reject) => {
+    child.once("error", reject);
+  });
+  await Promise.race([waitForApp(installUrl, child), launchError]);
+  console.log(`
+TradeJS Web UI: ${installUrl}`);
+  if (shouldOpen) {
+    openBrowser(installUrl);
+  }
+  await new Promise((resolve, reject) => {
+    child.once("exit", (code, signal) => {
+      if (signal || code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`Web UI exited with code ${code}`));
+    });
+  });
+};
+var main = async () => {
+  const options = parseArgs(process.argv.slice(2));
+  if (!options) {
+    printUsage();
+    return;
+  }
+  const infrastructurePorts = options.infra ? {
+    postgres: await findAvailablePort(5432),
+    redis: await findAvailablePort(6379),
+    redisInsight: await findAvailablePort(5540)
+  } : DEFAULT_INFRASTRUCTURE_PORTS;
+  const projectDir = scaffoldProject(
+    options.targetDir,
+    options.port,
+    infrastructurePorts
+  );
+  console.log(`Created TradeJS project in ${projectDir}`);
+  if (!options.install) {
+    console.log("Project files generated. Run npm install to continue.");
+    return;
+  }
+  console.log("\nInstalling TradeJS packages...");
+  run(
+    process.platform === "win32" ? "npm.cmd" : "npm",
+    ["install"],
+    projectDir
+  );
+  if (options.infra) {
+    const tradejs = localBin(projectDir, "tradejs");
+    console.log("\nStarting Redis and Timescale...");
+    run(tradejs, ["infra-init"], projectDir);
+    run(tradejs, ["infra-up"], projectDir);
+    run(tradejs, ["doctor", "--skip-ml"], projectDir);
+    console.log("\nInfrastructure is ready. Finish setup in the Web UI.");
+  } else {
+    console.log("\nInfrastructure setup was skipped.");
+  }
+  if (options.start) {
+    await startWebApp(projectDir, options.port, options.open);
+  } else {
+    console.log(`
+Next: cd ${options.targetDir} && npm run dev`);
+  }
+};
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(`
+create-tradejs failed: ${error.message}`);
+    process.exit(1);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildProjectFiles,
+  main,
+  parseArgs,
+  scaffoldProject
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "create-tradejs",
+  "version": "1.0.10",
+  "description": "Create a ready-to-run TradeJS project with local infrastructure and the Web UI.",
+  "keywords": [
+    "tradejs",
+    "create",
+    "scaffold",
+    "backtesting",
+    "trading"
+  ],
+  "homepage": "https://tradejs.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TradeJS-Dev/TradeJS",
+    "directory": "packages/create-tradejs"
+  },
+  "bugs": {
+    "url": "https://github.com/tradejs-dev/tradejs/issues"
+  },
+  "bin": "dist/index.js",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20.19"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc -p ./tsconfig.json --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^24",
+    "tsup": "^8.5.1",
+    "typescript": "^5.1"
+  },
+  "license": "MIT",
+  "author": "aleksnick (https://github.com/aleksnick)"
+}