@pd4castr/cli 0.0.1

package/README.md

@@ -0,0 +1,47 @@
+# pd4castr CLI
+
+CLI tool for creating, testing, and publishing pd4castr models.
+
+Install via:
+
+```bash
+npm install -g @pd4castr/cli
+```
+
+## Contributing
+
+### Quick Start
+
+```bash
+# set this repository up for linking during develpment
+yarn link
+
+# run the project in watch mode
+yarn dev
+
+# from a model project, link the module
+yarn link @pd4castr/cli
+
+# from that project, execute a command
+yarn pd4castr <command>
+```
+
+### Scripts
+
+- `yarn build` - Build the project
+- `yarn dev` - Watch mode for development
+- `yarn cli <command>` - Run CLI commands against local build
+- `yarn test` - Run tests once
+- `yarn test:watch` - Run tests in watch mode
+- `yarn lint` - Check for linting issues
+- `yarn format` - Format code with Prettier
+- `yarn type-check` - TypeScript type checking
+
+### Testing
+
+As this project requires a lot of disk I/O and network reqeuests, we opt for 2 mocking solutions that keep us as close to the metal as possible:
+
+- network requests are mocked uses [msw](https://mswjs.io/) - request handlers live in the [mocks/handlers](./src/mocks/handlers/) folder
+- disk I/O (`fs`) is mocked using [`memfs`](https://github.com/streamich/memfs) which is handled by Vitest in our [`__mocks__/`](./src/__mocks__) folder
+
+Both of these mocks are initialised globally via our [setup script](./vitest.setup.ts).

package/dist/index.js

@@ -0,0 +1,699 @@
+#!/usr/bin/env node
+
+// src/program.ts
+import { Command } from "commander";
+
+// package.json
+var package_default = {
+  name: "@pd4castr/cli",
+  version: "0.0.1",
+  description: "CLI tool for creating, testing, and publishing pd4castr models",
+  main: "dist/index.js",
+  type: "module",
+  bin: {
+    pd4castr: "dist/index.js"
+  },
+  files: [
+    "dist/**/*"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    cli: "node dist/index.js",
+    test: "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    lint: "eslint .",
+    "lint:fix": "eslint . --fix",
+    format: "prettier --write .",
+    "format:check": "prettier --check .",
+    "type-check": "tsc --noEmit",
+    prepublishOnly: "yarn build"
+  },
+  keywords: [
+    "cli",
+    "pd4castr"
+  ],
+  license: "UNLICENSED",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/pipelabs/pd4castr-cli.git"
+  },
+  bugs: {
+    url: "https://github.com/pipelabs/pd4castr-cli/issues"
+  },
+  homepage: "https://github.com/pipelabs/pd4castr-cli#readme",
+  devDependencies: {
+    "@types/express": "4.17.21",
+    "@types/node": "24.1.0",
+    "@types/supertest": "6.0.3",
+    "@typescript-eslint/eslint-plugin": "8.38.0",
+    "@typescript-eslint/parser": "8.38.0",
+    eslint: "9.32.0",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-unicorn": "60.0.0",
+    "eslint-plugin-vitest": "0.5.4",
+    "jest-extended": "6.0.0",
+    memfs: "4.23.0",
+    msw: "2.10.4",
+    prettier: "3.6.2",
+    supertest: "7.1.4",
+    tsup: "8.5.0",
+    typescript: "5.8.3",
+    "typescript-eslint": "8.38.0",
+    vitest: "3.2.4"
+  },
+  dependencies: {
+    "@inquirer/prompts": "7.7.1",
+    auth0: "4.27.0",
+    commander: "14.0.0",
+    execa: "9.6.0",
+    express: "4.21.2",
+    ky: "1.8.2",
+    lilconfig: "3.1.3",
+    ora: "8.2.0",
+    tiged: "2.12.7",
+    "tiny-invariant": "1.3.3",
+    zod: "4.0.14"
+  },
+  engines: {
+    node: ">=20.0.0"
+  }
+};
+
+// src/program.ts
+var program = new Command();
+program.name("pd4castr").description("CLI tool for pd4castr").version(package_default.version);
+
+// src/commands/init/handle-action.ts
+import path from "path";
+import * as inquirer from "@inquirer/prompts";
+import tiged from "tiged";
+import ora from "ora";
+
+// src/commands/init/constants.ts
+var templates = {
+  "python-barebones": {
+    name: "python-barebones",
+    repo: "pipelabs/pd4castr-model-examples",
+    path: "examples/python-barebones"
+  },
+  "python-demo": {
+    name: "python-demo",
+    repo: "pipelabs/pd4castr-model-examples",
+    path: "examples/python-demo"
+  }
+};
+
+// src/commands/init/utils/get-template-path.ts
+function getTemplatePath(template) {
+  return `https://github.com/${template.repo}/${template.path}`;
+}
+
+// src/utils/is-existing-path.ts
+import fs from "fs/promises";
+async function isExistingPath(path8) {
+  try {
+    await fs.access(path8);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/init/utils/validate-name.ts
+async function validateName(value) {
+  const exists = await isExistingPath(`./${value}`);
+  if (exists) {
+    return "A directory or file with this name already exists. Please choose a different name.";
+  }
+  return true;
+}
+
+// src/commands/init/handle-action.ts
+async function handleAction() {
+  const projectName = await inquirer.input({
+    message: "Name your new model project",
+    default: "my-model",
+    validate: validateName
+  });
+  const template = await inquirer.select({
+    message: "Select a template",
+    choices: Object.values(templates).map((template2) => ({
+      name: template2.name,
+      value: template2.name
+    }))
+  });
+  const spinner = ora("Fetching template...").start();
+  try {
+    await fetchTemplate(template, projectName);
+    spinner.succeed("Template fetched successfully");
+  } catch {
+    spinner.fail("Error fetching template");
+    process.exit(1);
+  }
+}
+async function fetchTemplate(template, projectName) {
+  const templatePath = getTemplatePath(templates[template]);
+  const fetcher = tiged(templatePath, {
+    disableCache: true,
+    force: true
+  });
+  const destination = path.join(process.cwd(), projectName);
+  await fetcher.clone(destination);
+}
+
+// src/commands/init/index.ts
+function registerInitCommand(program2) {
+  program2.command("init").description("Initialize a new model using a template.").action(handleAction);
+}
+
+// src/commands/login/handle-action.ts
+import ora2 from "ora";
+import { ZodError } from "zod";
+
+// src/config/load-global-config.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import os from "os";
+
+// src/constants.ts
+var AUTH0_DOMAIN = "pdview.au.auth0.com";
+var AUTH0_CLIENT_ID = "Q5tQNF57cQlVXnVsqnU0hhgy92rVb03W";
+var AUTH0_AUDIENCE = "https://api.pd4castr.com.au";
+var GLOBAL_CONFIG_FILE = ".pd4castr";
+var PROJECT_CONFIG_FILE = ".pd4castrrc.json";
+var API_URL = "https://api.pd4castr.com.au";
+var TEST_INPUT_DATA_DIR = "test_data";
+
+// src/schemas/global-config-schema.ts
+import { z } from "zod";
+var globalConfigSchema = z.object({
+  accessToken: z.string().optional(),
+  accessTokenExpiresAt: z.number().optional()
+});
+
+// src/config/load-global-config.ts
+async function loadGlobalConfig() {
+  const configPath = path2.join(os.homedir(), GLOBAL_CONFIG_FILE);
+  const configExists = await isExistingPath(configPath);
+  if (!configExists) {
+    await fs2.writeFile(configPath, JSON.stringify({}));
+    return {};
+  }
+  try {
+    const configFileContents = await fs2.readFile(configPath, "utf8");
+    const config = JSON.parse(configFileContents);
+    return globalConfigSchema.parse(config);
+  } catch {
+    return {};
+  }
+}
+
+// src/config/update-global-config.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+import os2 from "os";
+async function updateGlobalConfig(updatedConfig) {
+  const configPath = path3.join(os2.homedir(), GLOBAL_CONFIG_FILE);
+  await fs3.writeFile(configPath, JSON.stringify(updatedConfig, void 0, 2));
+}
+
+// src/utils/log-zod-issues.ts
+function logZodIssues(error) {
+  for (const issue of error.issues) {
+    console.log(`  \u2718 ${issue.path.join(".")} - ${issue.message}`);
+  }
+}
+
+// src/commands/login/utils/is-authed.ts
+function isAuthed(config) {
+  const isTokenExpired = config.accessTokenExpiresAt && config.accessTokenExpiresAt <= Date.now();
+  return Boolean(config.accessToken) && !isTokenExpired;
+}
+
+// src/commands/login/auth0-api.ts
+import ky from "ky";
+var auth0API = ky.create({ prefixUrl: `https://${AUTH0_DOMAIN}` });
+
+// src/commands/login/utils/start-auth-flow.ts
+var payload = {
+  client_id: AUTH0_CLIENT_ID,
+  audience: AUTH0_AUDIENCE,
+  scope: "openid profile"
+};
+async function startAuthFlow() {
+  const codeResponse = await auth0API.post("oauth/device/code", { json: payload }).json();
+  const authContext = {
+    deviceCode: codeResponse.device_code,
+    verificationURL: codeResponse.verification_uri_complete,
+    userCode: codeResponse.user_code,
+    checkInterval: codeResponse.interval
+  };
+  return authContext;
+}
+
+// src/commands/login/utils/complete-auth-flow.ts
+import { HTTPError } from "ky";
+var FAILED_AUTH_ERRORS = /* @__PURE__ */ new Set(["expired_token", "access_denied"]);
+async function completeAuthFlow(authCtx) {
+  const payload2 = {
+    client_id: AUTH0_CLIENT_ID,
+    grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+    device_code: authCtx.deviceCode
+  };
+  async function fetchAuthResponse() {
+    try {
+      const response = await auth0API.post("oauth/token", { json: payload2 }).json();
+      const authPayload = {
+        accessToken: response.access_token,
+        expiresAt: Date.now() + response.expires_in * 1e3
+      };
+      return authPayload;
+    } catch (error) {
+      if (!(error instanceof HTTPError)) {
+        throw error;
+      }
+      const errorResponse = await error.response.json();
+      const isFailedAuthError = FAILED_AUTH_ERRORS.has(errorResponse.error);
+      if (isFailedAuthError) {
+        throw new Error(
+          `Login failed, please try again (${errorResponse.error_description}).`
+        );
+      }
+      const delay = authCtx.checkInterval * 1e3;
+      return new Promise(
+        (resolve) => setTimeout(() => resolve(fetchAuthResponse()), delay)
+      );
+    }
+  }
+  return fetchAuthResponse();
+}
+
+// src/commands/login/handle-action.ts
+async function handleAction2() {
+  const spinner = ora2("Logging in to the pd4castr API...").start();
+  try {
+    const globalConfig = await loadGlobalConfig();
+    if (isAuthed(globalConfig)) {
+      spinner.succeed("Already logged in!");
+      return;
+    }
+    const authCtx = await startAuthFlow();
+    spinner.info(
+      `Please open the login link in your browser:
+	${authCtx.verificationURL}`
+    );
+    spinner.info(`Your login code is:
+	${authCtx.userCode}
+`);
+    spinner.start("Waiting for login to complete...");
+    const authPayload = await completeAuthFlow(authCtx);
+    const updatedGlobalConfig = {
+      ...globalConfig,
+      accessToken: authPayload.accessToken,
+      accessTokenExpiresAt: authPayload.expiresAt
+    };
+    await updateGlobalConfig(updatedGlobalConfig);
+    spinner.succeed("Successfully logged in to the pd4castr API");
+  } catch (error) {
+    if (error instanceof ZodError) {
+      spinner.fail("Config validation failed");
+      logZodIssues(error);
+    } else if (error instanceof Error) {
+      spinner.fail(error.message);
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/login/index.ts
+function registerLoginCommand(program2) {
+  program2.command("login").description("Logs in to the pd4castr API.").action(handleAction2);
+}
+
+// src/commands/test/handle-action.ts
+import ora3 from "ora";
+import express from "express";
+import path5 from "path";
+import { ExecaError } from "execa";
+import { ZodError as ZodError2 } from "zod";
+
+// src/config/load-project-config.ts
+import { lilconfig } from "lilconfig";
+
+// src/schemas/project-config-schema.ts
+import { z as z2 } from "zod";
+var aemoDataFetcherSchema = z2.object({
+  key: z2.string(),
+  type: z2.literal("AEMO_MMS"),
+  checkInterval: z2.int().positive(),
+  config: z2.object({
+    checkQuery: z2.string(),
+    fetchQuery: z2.string()
+  })
+});
+var dataFetcherSchema = z2.discriminatedUnion("type", [aemoDataFetcherSchema]);
+var modelInputSchema = z2.object({
+  key: z2.string(),
+  inputSource: z2.string(),
+  dataFetcher: z2.string(),
+  trigger: z2.string()
+});
+var projectConfigSchema = z2.object({
+  dataFetchers: z2.array(dataFetcherSchema).default([]),
+  modelInputs: z2.array(modelInputSchema).default([])
+});
+
+// src/config/parse-project-config.ts
+function parseProjectConfig(config) {
+  return projectConfigSchema.parse(config);
+}
+
+// src/config/load-project-config.ts
+async function loadProjectConfig() {
+  const result = await lilconfig("pd4castr", {
+    searchPlaces: [PROJECT_CONFIG_FILE]
+  }).search();
+  if (!result?.config) {
+    throw new Error(
+      "No config found (docs: https://github.com/pipelabs/pd4castr-model-examples/blob/main/docs/005-config.md)."
+    );
+  }
+  return parseProjectConfig(result.config);
+}
+
+// src/utils/get-cwd.ts
+function getCWD() {
+  if (!process.env.INIT_CWD) {
+    throw new Error("INIT_CWD environment variable is not set");
+  }
+  return process.env.INIT_CWD;
+}
+
+// src/commands/test/utils/build-docker-image.ts
+import { execa } from "execa";
+async function buildDockerImage(dockerImage) {
+  try {
+    await execa("docker", ["build", "-t", dockerImage, "."], {
+      cwd: getCWD(),
+      stdio: "pipe"
+    });
+  } catch (error) {
+    throw new Error("Failed to build docker image", { cause: error });
+  }
+}
+
+// src/commands/test/utils/create-input-handler.ts
+import path4 from "path";
+function createInputHandler(inputFilesPath, modelIOChecks) {
+  return (req, res) => {
+    if (!modelIOChecks.isValidInput(req.params.filename)) {
+      return res.status(404).json({ error: "File not found" });
+    }
+    modelIOChecks.trackInputHandled(req.params.filename);
+    const filePath = path4.join(getCWD(), inputFilesPath, req.params.filename);
+    return res.sendFile(filePath);
+  };
+}
+
+// src/commands/test/utils/create-output-handler.ts
+function createOutputHandler(modelIOChecks) {
+  return (_, res) => {
+    modelIOChecks.trackOutputHandled();
+    return res.status(200).json({ message: "Output received" });
+  };
+}
+
+// src/utils/get-test-data-filename.ts
+function getTestDataFilename(modelInput) {
+  return `${modelInput.inputSource}-${modelInput.key}.json`;
+}
+
+// src/commands/test/utils/get-test-data-filenames.ts
+function getTestDataFilenames(config) {
+  const testDataFilenames = config.modelInputs.map(
+    (modelInput) => getTestDataFilename(modelInput)
+  );
+  return testDataFilenames;
+}
+
+// src/commands/test/utils/model-io-checks.ts
+var ModelIOChecks = class {
+  inputsToDownload;
+  outputUploaded;
+  constructor(data) {
+    this.inputsToDownload = {};
+    this.outputUploaded = false;
+    for (const file of data.inputFiles) {
+      this.inputsToDownload[file] = false;
+    }
+  }
+  trackInputHandled(filename) {
+    if (this.inputsToDownload[filename] !== void 0) {
+      this.inputsToDownload[filename] = true;
+    }
+  }
+  trackOutputHandled() {
+    this.outputUploaded = true;
+  }
+  isOutputHandled() {
+    return this.outputUploaded;
+  }
+  isInputHandled(filename) {
+    return this.inputsToDownload[filename];
+  }
+  isInputsHandled() {
+    return Object.values(this.inputsToDownload).every(Boolean);
+  }
+  isValidInput(filename) {
+    return this.inputsToDownload[filename] !== void 0;
+  }
+};
+
+// src/commands/test/utils/run-model-container.ts
+import { execa as execa2 } from "execa";
+
+// src/commands/test/utils/get-input-env.ts
+function getInputEnv(modelInput, webserverURL) {
+  const variableName = modelInput.key.toUpperCase();
+  const filename = getTestDataFilename(modelInput);
+  const inputFileURL = `${webserverURL}/input/${filename}`;
+  return `INPUT_${variableName}_URL=${inputFileURL}`;
+}
+
+// src/commands/test/utils/run-model-container.ts
+async function runModelContainer(dockerImage, config, webserverURL) {
+  const inputEnvs = config.modelInputs.map(
+    (modelInput) => getInputEnv(modelInput, webserverURL)
+  );
+  const outputEnv = `OUTPUT_URL=${webserverURL}/output`;
+  const envs = [...inputEnvs, outputEnv];
+  try {
+    const args = [
+      "run",
+      "--rm",
+      "--network=host",
+      ...envs.flatMap((env) => ["--env", env]),
+      dockerImage
+    ];
+    await execa2("docker", args, { cwd: getCWD(), stdio: "pipe" });
+  } catch (error) {
+    throw new Error("Failed to run model container", { cause: error });
+  }
+}
+
+// src/commands/test/utils/start-web-server.ts
+async function startWebServer(app, port) {
+  return new Promise((resolve) => {
+    const server = app.listen(port, () => {
+      resolve(server);
+    });
+  });
+}
+
+// src/commands/test/handle-action.ts
+async function handleAction3(options) {
+  const spinner = ora3("Starting model tests...").start();
+  const app = express();
+  const server = await startWebServer(app, options.port);
+  try {
+    const projectConfig = await loadProjectConfig();
+    spinner.start("Building docker image");
+    await buildDockerImage(options.dockerImage);
+    spinner.succeed(`Built docker image (${options.dockerImage})`);
+    const inputFiles = getTestDataFilenames(projectConfig);
+    const modelIOChecks = new ModelIOChecks({ inputFiles });
+    spinner.succeed(`Found ${inputFiles.length} input data files`);
+    const handleInput = createInputHandler(options.inputData, modelIOChecks);
+    const handleOutput = createOutputHandler(modelIOChecks);
+    app.use("/data", express.static(path5.join(getCWD(), options.inputData)));
+    app.get("/input/:filename", handleInput);
+    app.put("/output", handleOutput);
+    spinner.start("Running model container");
+    const webserverURL = `http://localhost:${options.port}`;
+    await runModelContainer(options.dockerImage, projectConfig, webserverURL);
+    spinner.succeed("Model run complete");
+    for (const file of inputFiles) {
+      const status = modelIOChecks.isInputHandled(file) ? "\u2714" : "\u2718";
+      console.log(`    ${status} Input Fetched - ${file}`);
+    }
+    const outputStatus = modelIOChecks.isOutputHandled() ? "\u2714" : "\u2718";
+    console.log(`    ${outputStatus} Output Uploaded`);
+    if (modelIOChecks.isInputsHandled() && modelIOChecks.isOutputHandled()) {
+      spinner.succeed("Model I/O test passed");
+    } else {
+      spinner.fail("Model I/O test failed");
+    }
+  } catch (error) {
+    if (error instanceof ZodError2) {
+      spinner.fail("Config validation failed");
+      logZodIssues(error);
+    } else if (error instanceof Error) {
+      spinner.fail(error.message);
+    }
+    if (error instanceof Error && error.cause instanceof ExecaError) {
+      console.error(error.cause.stderr);
+    }
+    process.exit(1);
+  } finally {
+    server.close();
+  }
+}
+
+// src/commands/test/index.ts
+function registerTestCommand(program2) {
+  program2.command("test").description(
+    "Test a model by verifying input and output is handled correctly."
+  ).option(
+    "-i, --input-data <path>",
+    "The path to the input data directory",
+    TEST_INPUT_DATA_DIR
+  ).option(
+    "-d, --docker-image <image>",
+    "The Docker image to execute for testing",
+    // TODO: determine a default value here intelligently when we
+    // implement our image tagging strategy
+    `pd4castr/my-model:${Date.now()}`
+  ).option("-p, --port <port>", "The port to run the webserver on", "9800").action(handleAction3);
+}
+
+// src/commands/fetch/handle-action.ts
+import ora4 from "ora";
+import { ZodError as ZodError3 } from "zod";
+
+// src/utils/get-auth.ts
+import invariant from "tiny-invariant";
+async function getAuth() {
+  const config = await loadGlobalConfig();
+  if (!isAuthed(config)) {
+    throw new Error("Not authenticated. Please run `pd4castr login` to login.");
+  }
+  invariant(config.accessToken, "Access token is required");
+  invariant(config.accessTokenExpiresAt, "Access token expiry is required");
+  return {
+    accessToken: config.accessToken,
+    expiresAt: config.accessTokenExpiresAt
+  };
+}
+
+// src/commands/fetch/utils/fetch-aemo-data.ts
+import path6 from "path";
+import fs4 from "fs/promises";
+
+// src/api.ts
+import ky2 from "ky";
+var api = ky2.create({
+  prefixUrl: process.env.PD4CASTR_API_URL ?? API_URL
+});
+
+// src/commands/fetch/utils/fetch-aemo-data.ts
+async function fetchAEMOData(dataFetcher, authCtx) {
+  const queryPath = path6.resolve(getCWD(), dataFetcher.config.fetchQuery);
+  const querySQL = await fs4.readFile(queryPath, "utf8");
+  const headers = { Authorization: `Bearer ${authCtx.accessToken}` };
+  const payload2 = { query: querySQL, type: "AEMO_MMS" };
+  const result = await api.post("data-fetcher/run-query", { json: payload2, headers }).json();
+  return result;
+}
+
+// src/commands/fetch/utils/get-fetcher.ts
+var DATA_FETCHER_FNS = {
+  AEMO_MMS: fetchAEMOData
+};
+function getFetcher(type) {
+  const fetcher = DATA_FETCHER_FNS[type];
+  if (!fetcher) {
+    throw new Error(`Unsupported data fetcher type: ${type}`);
+  }
+  return fetcher;
+}
+
+// src/commands/fetch/utils/write-test-data.ts
+import path7 from "path";
+import fs5 from "fs/promises";
+async function writeTestData(output, modelInput) {
+  const outputDir = path7.resolve(getCWD(), TEST_INPUT_DATA_DIR);
+  await fs5.mkdir(outputDir, { recursive: true });
+  const testDataFilename = getTestDataFilename(modelInput);
+  const outputPath = path7.resolve(outputDir, testDataFilename);
+  await fs5.writeFile(outputPath, JSON.stringify(output, void 0, 2));
+}
+
+// src/commands/fetch/handle-action.ts
+var FETCHABLE_DATA_FETCHER_TYPES = /* @__PURE__ */ new Set(["AEMO_MMS"]);
+async function handleAction4() {
+  const spinner = ora4("Starting data fetch...").start();
+  try {
+    const authCtx = await getAuth();
+    const projectConfig = await loadProjectConfig();
+    for (const modelInput of projectConfig.modelInputs) {
+      const dataFetcher = projectConfig.dataFetchers.find(
+        (dataFetcher2) => dataFetcher2.key === modelInput.dataFetcher
+      );
+      if (!dataFetcher) {
+        spinner.warn(
+          `\`${modelInput.key}\` - input has no data fetcher, skipping`
+        );
+        continue;
+      }
+      if (!FETCHABLE_DATA_FETCHER_TYPES.has(dataFetcher.type)) {
+        spinner.warn(
+          `\`${dataFetcher.key}\` (${dataFetcher.type}) - unsupported, skipping`
+        );
+        continue;
+      }
+      spinner.start(
+        `\`${dataFetcher.key}\` (${dataFetcher.type}) - fetching...`
+      );
+      const fetchData = getFetcher(dataFetcher.type);
+      const output = await fetchData(dataFetcher, authCtx);
+      await writeTestData(output, modelInput);
+      spinner.succeed(`\`${dataFetcher.key}\` (${dataFetcher.type}) - fetched`);
+    }
+  } catch (error) {
+    if (error instanceof ZodError3) {
+      spinner.fail("Config validation failed");
+      logZodIssues(error);
+    } else if (error instanceof Error) {
+      spinner.fail(error.message);
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/fetch/index.ts
+function registerFetchCommand(program2) {
+  program2.command("fetch").description("Fetches test data from configured data fetchers.").option(
+    "-i, --input-data <path>",
+    "The path to the input data directory",
+    TEST_INPUT_DATA_DIR
+  ).action(handleAction4);
+}
+
+// src/index.ts
+registerInitCommand(program);
+registerLoginCommand(program);
+registerTestCommand(program);
+registerFetchCommand(program);
+await program.parseAsync(process.argv);

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@pd4castr/cli",
+  "version": "0.0.1",
+  "description": "CLI tool for creating, testing, and publishing pd4castr models",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "pd4castr": "dist/index.js"
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "cli": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "yarn build"
+  },
+  "keywords": [
+    "cli",
+    "pd4castr"
+  ],
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pipelabs/pd4castr-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pipelabs/pd4castr-cli/issues"
+  },
+  "homepage": "https://github.com/pipelabs/pd4castr-cli#readme",
+  "devDependencies": {
+    "@types/express": "4.17.21",
+    "@types/node": "24.1.0",
+    "@types/supertest": "6.0.3",
+    "@typescript-eslint/eslint-plugin": "8.38.0",
+    "@typescript-eslint/parser": "8.38.0",
+    "eslint": "9.32.0",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-unicorn": "60.0.0",
+    "eslint-plugin-vitest": "0.5.4",
+    "jest-extended": "6.0.0",
+    "memfs": "4.23.0",
+    "msw": "2.10.4",
+    "prettier": "3.6.2",
+    "supertest": "7.1.4",
+    "tsup": "8.5.0",
+    "typescript": "5.8.3",
+    "typescript-eslint": "8.38.0",
+    "vitest": "3.2.4"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "7.7.1",
+    "auth0": "4.27.0",
+    "commander": "14.0.0",
+    "execa": "9.6.0",
+    "express": "4.21.2",
+    "ky": "1.8.2",
+    "lilconfig": "3.1.3",
+    "ora": "8.2.0",
+    "tiged": "2.12.7",
+    "tiny-invariant": "1.3.3",
+    "zod": "4.0.14"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}