@pd4castr/cli 0.0.5 → 0.0.6

package/dist/index.js

@@ -51,22 +51,30 @@ 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://pd4castr-api.pipelabs.app";
+var DEFAULT_API_URL = "https://pd4castr-api.pipelabs.app";
+var DEFAULT_INPUT_SOURCE_ID = "0bdfd52b-efaa-455e-9a3b-1a6d2b879b73";
 var TEST_INPUT_DATA_DIR = "test_input";
 var TEST_OUTPUT_DATA_DIR = "test_output";
+var TEST_WEBSERVER_PORT = 9800;
 var TEST_OUTPUT_FILENAME = `output-${Date.now()}.json`;
+var DOCKER_HOSTNAME_DEFAULT = "host.docker.internal";
+var DOCKER_HOSTNAME_WSL = "wsl.host";
+var WSL_NETWORK_INTERFACE_DEFAULT = "eth0";
 
 // src/commands/fetch/handle-action.ts
 import path5 from "path";
+import { HTTPError } from "ky";
 import ora from "ora";
-import { ZodError } from "zod";
+import { ZodError as ZodError2 } from "zod";
 
-// src/config/load-project-config.ts
+// src/config/load-project-context.ts
+import fs2 from "fs/promises";
 import path from "path";
-import { lilconfig } from "lilconfig";
+import { ZodError } from "zod";
 
 // src/schemas/project-config-schema.ts
 import { z } from "zod";
+var fileFormatSchema = z.enum(["csv", "json", "parquet"]);
 var aemoDataFetcherSchema = z.object({
   type: z.literal("AEMO_MMS"),
   checkInterval: z.number().int().min(60),
@@ -78,49 +86,70 @@ var aemoDataFetcherSchema = z.object({
 var dataFetcherSchema = z.discriminatedUnion("type", [aemoDataFetcherSchema]);
 var modelInputSchema = z.object({
   key: z.string(),
-  inputSource: z.string().optional(),
+  inputSource: z.string().optional().default(DEFAULT_INPUT_SOURCE_ID),
   trigger: z.enum(["WAIT_FOR_LATEST_FILE", "USE_MOST_RECENT_FILE"]),
-  fetcher: dataFetcherSchema.optional()
+  uploadFileFormat: fileFormatSchema.optional().default("json"),
+  targetFileFormat: fileFormatSchema.optional().default("json"),
+  fetcher: dataFetcherSchema.optional().nullable()
 });
 var modelOutputSchema = z.object({
   name: z.string(),
+  type: z.enum(["float", "integer", "string", "date", "boolean", "unknown"]),
   seriesKey: z.boolean(),
   colour: z.string().regex(/^#[0-9A-Fa-f]{6}$/).optional()
 });
+var CONFIG_WARNING_KEY = "// WARNING: DO NOT MODIFY THESE SYSTEM MANAGED VALUES";
 var projectConfigSchema = z.object({
-  $$id: z.string().nullable(),
-  $$modelGroupID: z.string().nullable(),
-  $$revision: z.number().int().min(0).default(0),
-  $$dockerImage: z.string().nullable(),
   name: z.string(),
+  forecastVariable: z.enum(["price"]),
+  timeHorizon: z.enum(["actual", "day_ahead", "week_ahead", "quarterly"]),
   metadata: z.record(z.string(), z.any()).optional(),
-  forecastVariable: z.enum(["PRICE"]),
-  timeHorizon: z.enum(["ACTUAL", "DAY_AHEAD", "WEEK_AHEAD"]),
   inputs: z.array(modelInputSchema),
-  outputs: z.array(modelOutputSchema)
+  outputs: z.array(modelOutputSchema),
+  [CONFIG_WARNING_KEY]: z.string().optional().default(""),
+  $$id: z.string().nullable().optional().default(null),
+  $$modelGroupID: z.string().nullable().optional().default(null),
+  $$revision: z.number().int().min(0).nullable().optional().default(null),
+  $$dockerImage: z.string().nullable().optional().default(null)
 });
 
-// src/config/parse-project-config.ts
-function parseProjectConfig(config) {
-  return projectConfigSchema.parse(config);
+// src/utils/is-existing-path.ts
+import fs from "fs/promises";
+async function isExistingPath(path15) {
+  try {
+    await fs.access(path15);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
-// src/config/load-project-config.ts
-async function loadProjectConfig() {
-  const result = await lilconfig("pd4castr", {
-    searchPlaces: [PROJECT_CONFIG_FILE]
-  }).search();
-  if (!result?.config) {
+// src/config/load-project-context.ts
+async function loadProjectContext() {
+  const projectRoot = process.cwd();
+  const configPath = path.join(projectRoot, PROJECT_CONFIG_FILE);
+  const configExists = await isExistingPath(configPath);
+  if (!configExists) {
     throw new Error(
       "No config found (docs: https://github.com/pipelabs/pd4castr-model-examples/blob/main/docs/005-config.md)."
     );
   }
-  const config = parseProjectConfig(result.config);
-  const projectRoot = path.dirname(result.filepath);
-  return {
-    config,
-    projectRoot
-  };
+  try {
+    const configFileContents = await fs2.readFile(configPath, "utf8");
+    const rawConfig = JSON.parse(configFileContents);
+    const config = projectConfigSchema.parse(rawConfig);
+    return {
+      config,
+      projectRoot
+    };
+  } catch (error) {
+    if (error instanceof ZodError) {
+      throw error;
+    }
+    throw new Error(
+      "Failed to parse project config (docs: https://github.com/pipelabs/pd4castr-model-examples/blob/main/docs/005-config.md)."
+    );
+  }
 }
 
 // src/utils/create-link.ts
@@ -133,54 +162,54 @@ function createLink(text, url) {
   return `${start}${text}${end}`;
 }
 
+// src/utils/format-nest-error-message.ts
+function formatNestErrorMessage(error) {
+  return `[${error.error?.toUpperCase() ?? "UNKNOWN"}] ${error.message}`;
+}
+
 // src/utils/get-auth.ts
 import invariant from "tiny-invariant";
 
-// src/commands/login/utils/is-authed.ts
-function isAuthed(config) {
-  const isTokenExpired = config.accessTokenExpiresAt && config.accessTokenExpiresAt <= Date.now();
-  return Boolean(config.accessToken) && !isTokenExpired;
-}
-
 // src/config/load-global-config.ts
-import fs2 from "fs/promises";
+import fs3 from "fs/promises";
 import os from "os";
 import path2 from "path";
 
 // src/schemas/global-config-schema.ts
 import { z as z2 } from "zod";
 var globalConfigSchema = z2.object({
-  accessToken: z2.string().optional(),
-  accessTokenExpiresAt: z2.number().optional()
+  accessToken: z2.string().nullable(),
+  accessTokenExpiresAt: z2.number().nullable()
 });
 
-// src/utils/is-existing-path.ts
-import fs from "fs/promises";
-async function isExistingPath(path12) {
-  try {
-    await fs.access(path12);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // 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 {};
+    await fs3.writeFile(configPath, JSON.stringify({}));
+    return getDefaultConfig();
   }
   try {
-    const configFileContents = await fs2.readFile(configPath, "utf8");
+    const configFileContents = await fs3.readFile(configPath, "utf8");
     const config = JSON.parse(configFileContents);
     return globalConfigSchema.parse(config);
   } catch {
-    return {};
+    return getDefaultConfig();
   }
 }
+function getDefaultConfig() {
+  return {
+    accessToken: null,
+    accessTokenExpiresAt: null
+  };
+}
+
+// src/utils/is-authed.ts
+function isAuthed(config) {
+  const isTokenExpired = config.accessTokenExpiresAt && config.accessTokenExpiresAt <= Date.now();
+  return Boolean(config.accessToken) && !isTokenExpired;
+}
 
 // src/utils/get-auth.ts
 async function getAuth() {
@@ -204,25 +233,49 @@ function logZodIssues(error) {
 }
 
 // src/commands/fetch/utils/fetch-aemo-data.ts
-import fs3 from "fs/promises";
+import fs4 from "fs/promises";
 import path3 from "path";
 
-// src/api.ts
+// src/api/api.ts
 import ky from "ky";
+
+// src/schemas/env-schema.ts
+import { z as z3 } from "zod";
+var envSchema = z3.object({
+  // wsl sets this environment variable on all distros that i've checked
+  isWSL: z3.boolean().optional().default(() => Boolean(process.env.WSL_DISTRO_NAME)),
+  apiURL: z3.string().optional().default(() => process.env.PD4CASTR_API_URL ?? DEFAULT_API_URL),
+  wslNetworkInterface: z3.string().optional().default(
+    () => process.env.PD4CASTR_WSL_NETWORK_INTERFACE ?? WSL_NETWORK_INTERFACE_DEFAULT
+  )
+});
+
+// src/utils/get-env.ts
+function getEnv() {
+  return envSchema.parse(process.env);
+}
+
+// src/api/api.ts
 var api = ky.create({
-  prefixUrl: process.env.PD4CASTR_API_URL ?? API_URL
+  prefixUrl: getEnv().apiURL
 });
 
+// src/api/query-data-fetcher.ts
+async function queryDataFetcher(querySQL, authCtx) {
+  const headers = { Authorization: `Bearer ${authCtx.accessToken}` };
+  const payload2 = { query: querySQL, type: "AEMO_MMS" };
+  const result = await api.post("data-fetcher/query", { json: payload2, headers }).json();
+  return result;
+}
+
 // src/commands/fetch/utils/fetch-aemo-data.ts
 async function fetchAEMOData(dataFetcher, authCtx, ctx) {
   const queryPath = path3.resolve(
     ctx.projectRoot,
     dataFetcher.config.fetchQuery
   );
-  const querySQL = await fs3.readFile(queryPath, "utf8");
-  const headers = { Authorization: `Bearer ${authCtx.accessToken}` };
-  const payload2 = { query: querySQL, type: "AEMO_MMS" };
-  const result = await api.post("data-fetcher/query", { json: payload2, headers }).json();
+  const querySQL = await fs4.readFile(queryPath, "utf8");
+  const result = await queryDataFetcher(querySQL, authCtx);
   return result;
 }
 
@@ -239,21 +292,21 @@ function getFetcher(type) {
 }
 
 // src/commands/fetch/utils/write-test-data.ts
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
 import path4 from "path";
 
 // src/utils/get-input-filename.ts
 function getInputFilename(modelInput) {
-  return `${modelInput.key}.json`;
+  return `${modelInput.key}.${modelInput.targetFileFormat}`;
 }
 
 // src/commands/fetch/utils/write-test-data.ts
 async function writeTestData(inputData, modelInput, inputDataDir, ctx) {
   const inputDir = path4.resolve(ctx.projectRoot, inputDataDir);
-  await fs4.mkdir(inputDir, { recursive: true });
+  await fs5.mkdir(inputDir, { recursive: true });
   const inputFilename = getInputFilename(modelInput);
   const inputPath = path4.resolve(inputDir, inputFilename);
-  await fs4.writeFile(inputPath, JSON.stringify(inputData, void 0, 2));
+  await fs5.writeFile(inputPath, JSON.stringify(inputData, void 0, 2));
 }
 
 // src/commands/fetch/handle-action.ts
@@ -262,7 +315,7 @@ async function handleAction(options) {
   const spinner = ora("Starting data fetch...").start();
   try {
     const authCtx = await getAuth();
-    const ctx = await loadProjectConfig();
+    const ctx = await loadProjectContext();
     for (const input2 of ctx.config.inputs) {
       if (!input2.fetcher) {
         spinner.warn(`\`${input2.key}\` - no data fetcher defined, skipping`);
@@ -286,11 +339,17 @@ async function handleAction(options) {
 ${link} to view fetched data
 `);
   } catch (error) {
-    if (error instanceof ZodError) {
+    if (error instanceof ZodError2) {
       spinner.fail("Config validation failed");
       logZodIssues(error);
+    } else if (error instanceof HTTPError) {
+      const errorResponse = await error.response.json();
+      spinner.fail(formatNestErrorMessage(errorResponse));
     } else if (error instanceof Error) {
       spinner.fail(error.message);
+      if (error.cause) {
+        console.error(error.cause);
+      }
     }
     process.exit(1);
   }
@@ -359,8 +418,8 @@ async function handleAction2() {
     spinner.succeed("Template fetched successfully");
   } catch (error) {
     spinner.fail("Error fetching template");
-    if (error instanceof Error) {
-      console.error(error.message);
+    if (error instanceof Error && error.cause) {
+      console.error(error.cause);
     }
     process.exit(1);
   }
@@ -382,19 +441,22 @@ function registerInitCommand(program2) {
 
 // src/commands/login/handle-action.ts
 import ora3 from "ora";
-import { ZodError as ZodError2 } from "zod";
+import { ZodError as ZodError3 } from "zod";
 
 // src/config/update-global-config.ts
-import fs5 from "fs/promises";
+import fs6 from "fs/promises";
 import os2 from "os";
 import path7 from "path";
-async function updateGlobalConfig(updatedConfig) {
+import { produce } from "immer";
+async function updateGlobalConfig(updateFn) {
+  const globalConfig = await loadGlobalConfig();
+  const updatedConfig = produce(globalConfig, updateFn);
   const configPath = path7.join(os2.homedir(), GLOBAL_CONFIG_FILE);
-  await fs5.writeFile(configPath, JSON.stringify(updatedConfig, void 0, 2));
+  await fs6.writeFile(configPath, JSON.stringify(updatedConfig, void 0, 2));
 }
 
 // src/commands/login/utils/complete-auth-flow.ts
-import { HTTPError } from "ky";
+import { HTTPError as HTTPError2 } from "ky";
 
 // src/commands/login/auth0-api.ts
 import ky2 from "ky";
@@ -417,7 +479,7 @@ async function completeAuthFlow(authCtx) {
       };
       return authPayload;
     } catch (error) {
-      if (!(error instanceof HTTPError)) {
+      if (!(error instanceof HTTPError2)) {
         throw error;
       }
       const errorResponse = await error.response.json();
@@ -472,19 +534,20 @@ async function handleAction3() {
 `);
     spinner.start("Waiting for login to complete...");
     const authPayload = await completeAuthFlow(authCtx);
-    const updatedGlobalConfig = {
-      ...globalConfig,
-      accessToken: authPayload.accessToken,
-      accessTokenExpiresAt: authPayload.expiresAt
-    };
-    await updateGlobalConfig(updatedGlobalConfig);
+    await updateGlobalConfig((config) => {
+      config.accessToken = authPayload.accessToken;
+      config.accessTokenExpiresAt = authPayload.expiresAt;
+    });
     spinner.succeed("Successfully logged in to the pd4castr API");
   } catch (error) {
-    if (error instanceof ZodError2) {
+    if (error instanceof ZodError3) {
       spinner.fail("Config validation failed");
       logZodIssues(error);
     } else if (error instanceof Error) {
       spinner.fail(error.message);
+      if (error.cause) {
+        console.error(error.cause);
+      }
     }
     process.exit(1);
   }
@@ -495,15 +558,92 @@ function registerLoginCommand(program2) {
   program2.command("login").description("Logs in to the pd4castr API.").action(handleAction3);
 }
 
-// src/commands/test/handle-action.ts
-import path11 from "path";
-import { ExecaError } from "execa";
-import express from "express";
+// src/commands/logout/handle-action.ts
 import ora4 from "ora";
-import slugify from "slugify";
-import { ZodError as ZodError3 } from "zod";
+import { ZodError as ZodError4 } from "zod";
+async function handleAction4() {
+  const spinner = ora4("Logging out of the pd4castr API...").start();
+  try {
+    const globalConfig = await loadGlobalConfig();
+    if (!isAuthed(globalConfig)) {
+      spinner.succeed("Already logged out!");
+      return;
+    }
+    await updateGlobalConfig((config) => {
+      config.accessToken = null;
+      config.accessTokenExpiresAt = null;
+    });
+    spinner.succeed("Successfully logged out of the pd4castr API");
+  } catch (error) {
+    if (error instanceof ZodError4) {
+      spinner.fail("Config validation failed");
+      logZodIssues(error);
+    } else if (error instanceof Error) {
+      spinner.fail(error.message);
+      if (error.cause) {
+        console.error(error.cause);
+      }
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/logout/index.ts
+function registerLogoutCommand(program2) {
+  program2.command("logout").description("Logs out of the pd4castr API.").action(handleAction4);
+}
 
-// src/commands/test/utils/build-docker-image.ts
+// src/commands/publish/handle-action.ts
+import express2 from "express";
+import { HTTPError as HTTPError3 } from "ky";
+import ora5 from "ora";
+import { ZodError as ZodError5 } from "zod";
+
+// src/utils/start-web-server.ts
+async function startWebServer(app, port) {
+  return new Promise((resolve) => {
+    const server = app.listen(port, () => {
+      resolve({
+        server,
+        [Symbol.dispose]: () => server.close()
+      });
+    });
+  });
+}
+
+// src/commands/publish/handle-create-model-flow.ts
+import * as inquirer2 from "@inquirer/prompts";
+import chalk2 from "chalk";
+
+// src/api/create-model.ts
+async function createModel(config, authCtx) {
+  const headers = { Authorization: `Bearer ${authCtx.accessToken}` };
+  const result = await api.post("model", { headers, json: config }).json();
+  return result;
+}
+
+// src/api/get-registry-push-credentials.ts
+async function getRegistryPushCredentials(modelID, authCtx) {
+  const headers = { Authorization: `Bearer ${authCtx.accessToken}` };
+  const searchParams = new URLSearchParams(`modelId=${modelID}`);
+  const result = await api.get("registry/push-credentials", { headers, searchParams }).json();
+  return result;
+}
+
+// src/config/update-project-config.ts
+import fs7 from "fs/promises";
+import path8 from "path";
+import { produce as produce2 } from "immer";
+async function updateProjectConfig(updateFn) {
+  const projectConfig = await loadProjectContext();
+  const updatedConfig = produce2(projectConfig.config, updateFn);
+  await fs7.writeFile(
+    path8.join(projectConfig.projectRoot, PROJECT_CONFIG_FILE),
+    JSON.stringify(updatedConfig, void 0, 2)
+  );
+}
+
+// src/docker/build-docker-image.ts
 import { execa } from "execa";
 async function buildDockerImage(dockerImage, ctx) {
   try {
@@ -516,59 +656,183 @@ async function buildDockerImage(dockerImage, ctx) {
   }
 }
 
-// src/commands/test/utils/check-input-files.ts
-import path8 from "path";
-async function checkInputFiles(inputFiles, inputDataPath, ctx) {
-  for (const inputFile of inputFiles) {
-    const filePath = path8.join(ctx.projectRoot, inputDataPath, inputFile);
-    const exists = await isExistingPath(filePath);
-    if (!exists) {
-      throw new Error(
-        `Input data not found (${inputFile}) - did you need to run \`pd4castr fetch\`?`
-      );
-    }
+// src/docker/login-to-docker-registry.ts
+import { execa as execa2 } from "execa";
+async function loginToDockerRegistry(authConfig) {
+  try {
+    await execa2(
+      "docker",
+      [
+        "login",
+        authConfig.registry,
+        "--username",
+        authConfig.username,
+        "--password-stdin"
+      ],
+      { input: authConfig.password }
+    );
+  } catch (error) {
+    throw new Error("Failed to login to docker registry", { cause: error });
+  }
+}
+
+// src/docker/push-docker-image.ts
+import { execa as execa3 } from "execa";
+async function pushDockerImage(dockerImage, pushRef) {
+  try {
+    await execa3("docker", ["tag", dockerImage, pushRef]);
+    await execa3("docker", ["push", pushRef]);
+  } catch (error) {
+    throw new Error("Failed to push docker image", { cause: error });
   }
 }
 
-// src/commands/test/utils/create-input-handler.ts
+// src/utils/get-docker-image.ts
+import slugify from "slugify";
+function getDockerImage(ctx) {
+  const sluggedName = slugify(ctx.config.name, { lower: true });
+  const dockerImage = `pd4castr/${sluggedName}-local:${Date.now()}`;
+  return dockerImage;
+}
+
+// src/utils/get-model-config-from-project-config.ts
+import fs8 from "fs/promises";
 import path9 from "path";
-function createInputHandler(inputFilesPath, modelIOChecks, ctx) {
-  return (req, res) => {
-    if (!modelIOChecks.isValidInput(req.params.filename)) {
-      return res.status(404).json({ error: "File not found" });
+async function getModelConfigFromProjectConfig(ctx) {
+  const inputs = await getInputsWithInlinedSQL(ctx);
+  const { $$id, $$modelGroupID, $$revision, $$dockerImage, ...config } = ctx.config;
+  return {
+    ...config,
+    id: $$id,
+    modelGroupId: $$modelGroupID,
+    revision: $$revision ?? 0,
+    dockerImage: $$dockerImage,
+    inputs
+  };
+}
+var FETCHERS_WITH_SQL = /* @__PURE__ */ new Set(["AEMO_MMS"]);
+async function getInputsWithInlinedSQL(ctx) {
+  const inputsWithSQL = [];
+  for (const input2 of ctx.config.inputs) {
+    if (!input2.fetcher || !FETCHERS_WITH_SQL.has(input2.fetcher.type)) {
+      inputsWithSQL.push(input2);
+      continue;
     }
-    modelIOChecks.trackInputHandled(req.params.filename);
-    const filePath = path9.join(
+    const fetchQueryPath = path9.resolve(
       ctx.projectRoot,
-      inputFilesPath,
-      req.params.filename
+      input2.fetcher.config.fetchQuery
     );
-    return res.sendFile(filePath);
-  };
+    const checkQueryPath = path9.resolve(
+      ctx.projectRoot,
+      input2.fetcher.config.checkQuery
+    );
+    const [fetchQuerySQL, checkQuerySQL] = await Promise.all([
+      fs8.readFile(fetchQueryPath, "utf8"),
+      fs8.readFile(checkQueryPath, "utf8")
+    ]);
+    const inputWithSQL = {
+      ...input2,
+      fetcher: {
+        ...input2.fetcher,
+        config: {
+          ...input2.fetcher.config,
+          fetchQuery: fetchQuerySQL,
+          checkQuery: checkQuerySQL
+        }
+      }
+    };
+    inputsWithSQL.push(inputWithSQL);
+  }
+  return inputsWithSQL;
 }
 
-// src/commands/test/utils/create-output-handler.ts
-import fs6 from "fs/promises";
-import path10 from "path";
-function createOutputHandler(modelIOChecks, ctx) {
-  return async (req, res) => {
-    modelIOChecks.trackOutputHandled();
-    const outputPath = path10.join(ctx.projectRoot, TEST_OUTPUT_DATA_DIR);
-    await fs6.mkdir(outputPath, { recursive: true });
-    const outputFilePath = path10.join(outputPath, TEST_OUTPUT_FILENAME);
-    const outputData = JSON.stringify(req.body, null, 2);
-    await fs6.writeFile(outputFilePath, outputData, "utf8");
-    return res.status(200).json({ success: true });
-  };
+// src/utils/log-empty-line.ts
+function logEmptyLine() {
+  console.log("");
 }
 
-// src/commands/test/utils/get-input-files.ts
-function getInputFiles(config) {
-  const inputFiles = config.inputs.map((input2) => getInputFilename(input2));
-  return inputFiles;
+// src/commands/publish/utils/get-model-summary-lines.ts
+import chalk from "chalk";
+function getModelSummaryLines(ctx) {
+  return [
+    `	${chalk.bold("Model name:")} ${ctx.config.name}`,
+    `	${chalk.bold("Revision:")} ${ctx.config.$$revision}`,
+    `	${chalk.bold("Forecast variable:")} ${ctx.config.forecastVariable}`,
+    `	${chalk.bold("Time horizon:")} ${ctx.config.timeHorizon}`,
+    `	${chalk.bold("Inputs:")}`,
+    ...ctx.config.inputs.map(
+      (input2) => `	\u2022 ${input2.key} - ${getInputType(input2)}`
+    ),
+    `	${chalk.bold("Outputs:")}`,
+    ...ctx.config.outputs.map((output) => `	\u2022 ${output.name} - ${output.type}`),
+    ""
+  ];
+}
+function getInputType(input2) {
+  if (input2.fetcher) {
+    return input2.fetcher.type;
+  }
+  return "static";
+}
+
+// src/docker/run-model-container.ts
+import os3 from "os";
+import { execa as execa4 } from "execa";
+
+// src/docker/utils/get-input-env.ts
+function getInputEnv(modelInput, webserverURL) {
+  const variableName = modelInput.key.toUpperCase();
+  const filename = getInputFilename(modelInput);
+  const inputFileURL = `${webserverURL}/input/${filename}`;
+  return `INPUT_${variableName}_URL=${inputFileURL}`;
 }
 
-// src/commands/test/utils/model-io-checks.ts
+// src/docker/run-model-container.ts
+async function runModelContainer(dockerImage, webserverPort, ctx) {
+  const env = getEnv();
+  const webserverHostname = env.isWSL ? DOCKER_HOSTNAME_WSL : DOCKER_HOSTNAME_DEFAULT;
+  const webserverURL = `http://${webserverHostname}:${webserverPort}`;
+  const inputEnvs = ctx.config.inputs.map(
+    (input2) => getInputEnv(input2, webserverURL)
+  );
+  const outputEnv = `OUTPUT_URL=${webserverURL}/output`;
+  const envs = [...inputEnvs, outputEnv];
+  try {
+    const args = [
+      "run",
+      "--rm",
+      ...envs.flatMap((env2) => ["--env", env2]),
+      dockerImage
+    ];
+    if (env.isWSL) {
+      const ip = getWSLMachineIP();
+      args.push("--add-host", `${DOCKER_HOSTNAME_WSL}:${ip}`);
+    }
+    await execa4("docker", args, {
+      cwd: ctx.projectRoot,
+      stdio: "pipe"
+    });
+  } catch (error) {
+    throw new Error("Failed to run model container", { cause: error });
+  }
+}
+function getWSLMachineIP() {
+  const env = getEnv();
+  const interfaces = os3.networkInterfaces();
+  const interfaceInfo = interfaces[env.wslNetworkInterface]?.[0];
+  if (!interfaceInfo) {
+    throw new Error(
+      `WSL machine IP not found for interface \`${env.wslNetworkInterface}\``
+    );
+  }
+  return interfaceInfo.address;
+}
+
+// src/model-io-checks/setup-model-io-checks.ts
+import path12 from "path";
+import express from "express";
+
+// src/model-io-checks/model-io-checks.ts
 var ModelIOChecks = class {
   inputsToDownload;
   outputUploaded;
@@ -601,85 +865,373 @@ var ModelIOChecks = class {
   }
 };
 
-// src/commands/test/utils/run-model-container.ts
-import { execa as execa2 } from "execa";
+// src/model-io-checks/utils/create-input-handler.ts
+import path10 from "path";
+function createInputHandler(inputFilesPath, modelIOChecks, ctx) {
+  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 = path10.join(
+      ctx.projectRoot,
+      inputFilesPath,
+      req.params.filename
+    );
+    return res.sendFile(filePath);
+  };
+}
 
-// src/commands/test/utils/get-input-env.ts
-function getInputEnv(modelInput, webserverURL) {
-  const variableName = modelInput.key.toUpperCase();
-  const filename = getInputFilename(modelInput);
-  const inputFileURL = `${webserverURL}/input/${filename}`;
-  return `INPUT_${variableName}_URL=${inputFileURL}`;
+// src/model-io-checks/utils/create-output-handler.ts
+import fs9 from "fs/promises";
+import path11 from "path";
+function createOutputHandler(modelIOChecks, ctx) {
+  return async (req, res) => {
+    modelIOChecks.trackOutputHandled();
+    const outputPath = path11.join(ctx.projectRoot, TEST_OUTPUT_DATA_DIR);
+    await fs9.mkdir(outputPath, { recursive: true });
+    const outputFilePath = path11.join(outputPath, TEST_OUTPUT_FILENAME);
+    const outputData = JSON.stringify(req.body, null, 2);
+    await fs9.writeFile(outputFilePath, outputData, "utf8");
+    return res.status(200).json({ success: true });
+  };
 }
 
-// src/commands/test/utils/run-model-container.ts
-async function runModelContainer(dockerImage, webserverURL, ctx) {
-  const inputEnvs = ctx.config.inputs.map(
-    (input2) => getInputEnv(input2, webserverURL)
+// src/model-io-checks/setup-model-io-checks.ts
+function setupModelIOChecks(app, inputDir, inputFiles, ctx) {
+  const modelIOChecks = new ModelIOChecks({ inputFiles });
+  const handleInput = createInputHandler(inputDir, modelIOChecks, ctx);
+  const handleOutput = createOutputHandler(modelIOChecks, ctx);
+  const inputPath = path12.join(ctx.projectRoot, inputDir);
+  app.use(express.json());
+  app.use("/data", express.static(inputPath));
+  app.get("/input/:filename", handleInput);
+  app.put("/output", handleOutput);
+  return modelIOChecks;
+}
+
+// src/utils/check-input-files.ts
+import path13 from "path";
+async function checkInputFiles(inputFiles, inputDataPath, ctx) {
+  for (const inputFile of inputFiles) {
+    const filePath = path13.join(ctx.projectRoot, inputDataPath, inputFile);
+    const exists = await isExistingPath(filePath);
+    if (!exists) {
+      throw new Error(
+        `Input data not found (${inputFile}) - did you need to run \`pd4castr fetch\`?`
+      );
+    }
+  }
+}
+
+// src/utils/get-input-files.ts
+function getInputFiles(config) {
+  const inputFiles = config.inputs.map((input2) => getInputFilename(input2));
+  return inputFiles;
+}
+
+// src/commands/publish/utils/run-model-io-tests.ts
+async function runModelIOTests(dockerImage, options, app, ctx) {
+  const inputFiles = getInputFiles(ctx.config);
+  await checkInputFiles(inputFiles, options.inputDir, ctx);
+  await buildDockerImage(dockerImage, ctx);
+  const modelIOChecks = setupModelIOChecks(
+    app,
+    options.inputDir,
+    inputFiles,
+    ctx
   );
-  const outputEnv = `OUTPUT_URL=${webserverURL}/output`;
-  const envs = [...inputEnvs, outputEnv];
-  try {
-    const args = [
-      "run",
-      "--rm",
-      ...envs.flatMap((env) => ["--env", env]),
-      dockerImage
-    ];
-    await execa2("docker", args, {
-      cwd: ctx.projectRoot,
-      stdio: "pipe"
-    });
-  } catch (error) {
-    throw new Error("Failed to run model container", { cause: error });
+  await runModelContainer(dockerImage, options.port, ctx);
+  if (!modelIOChecks.isInputsHandled() || !modelIOChecks.isOutputHandled()) {
+    throw new Error(
+      "Model I/O test failed. Please run `pd4castr test` to debug the issue."
+    );
   }
 }
 
-// src/commands/test/utils/start-web-server.ts
-async function startWebServer(app, port) {
-  return new Promise((resolve) => {
-    const server = app.listen(port, () => {
-      resolve({
-        server,
-        [Symbol.dispose]: () => server.close()
-      });
-    });
+// src/commands/publish/handle-create-model-flow.ts
+async function handleCreateModelFlow(options, app, spinner, ctx, authCtx) {
+  spinner.info(`You are publishing a ${chalk2.bold("new")} model:
+`);
+  getModelSummaryLines(ctx).map((line) => console.log(line));
+  const confirm4 = await inquirer2.confirm({
+    message: "Do you want to continue?",
+    default: false
+  });
+  logEmptyLine();
+  if (!confirm4) {
+    throw new Error("Aborted");
+  }
+  const dockerImage = getDockerImage(ctx);
+  if (!options.skipChecks) {
+    spinner.start("Performing model I/O test...");
+    await runModelIOTests(dockerImage, options, app, ctx);
+    spinner.succeed("Model I/O test passed");
+  }
+  spinner.start("Publishing model...");
+  const modelConfig = await getModelConfigFromProjectConfig(ctx);
+  const model = await createModel(modelConfig, authCtx);
+  await updateProjectConfig((config) => {
+    config.$$id = model.id;
+    config.$$modelGroupID = model.modelGroupId;
+    config.$$revision = model.revision;
+    config.$$dockerImage = model.dockerImage;
+  });
+  const pushCredentials = await getRegistryPushCredentials(model.id, authCtx);
+  await loginToDockerRegistry(pushCredentials);
+  await buildDockerImage(dockerImage, ctx);
+  await pushDockerImage(dockerImage, pushCredentials.ref);
+  spinner.stopAndPersist({
+    symbol: "\u{1F680} ",
+    prefixText: "\n",
+    suffixText: "\n",
+    text: chalk2.bold("Model published successfully")
   });
 }
 
+// src/commands/publish/handle-update-existing-model-flow.ts
+import * as inquirer5 from "@inquirer/prompts";
+import chalk5 from "chalk";
+
+// src/commands/publish/handle-model-revision-create-flow.ts
+import * as inquirer3 from "@inquirer/prompts";
+import chalk3 from "chalk";
+
+// src/commands/publish/utils/validate-local-model-state.ts
+import invariant2 from "tiny-invariant";
+
+// src/api/get-model.ts
+async function getModel(id, authCtx) {
+  const headers = { Authorization: `Bearer ${authCtx.accessToken}` };
+  const result = await api.get(`model/${id}`, { headers }).json();
+  return result;
+}
+
+// src/commands/publish/utils/validate-local-model-state.ts
+async function validateLocalModelState(ctx, authCtx) {
+  invariant2(ctx.config.$$id, "model ID is required to fetch published model");
+  const currentModel = await getModel(ctx.config.$$id, authCtx);
+  if (currentModel.revision !== ctx.config.$$revision) {
+    throw new Error(
+      `OUT OF SYNC: Local revision (${ctx.config.$$revision}) does not match the current published revision (${currentModel.revision})`
+    );
+  }
+  if (currentModel.modelGroupId !== ctx.config.$$modelGroupID) {
+    throw new Error(
+      `OUT OF SYNC: Local model group ID (${ctx.config.$$modelGroupID}) does not match the current published model group ID (${currentModel.modelGroupId})`
+    );
+  }
+}
+
+// src/commands/publish/handle-model-revision-create-flow.ts
+var WARNING_LABEL = chalk3.yellowBright.bold("WARNING!");
+var CONFIRMATION_MESSAGE = `${WARNING_LABEL} Creating a new revision will preserve existing revisions.
+Previous revisions will still be available in the pd4castr UI.
+`;
+async function handleModelRevisionCreateFlow(options, app, spinner, ctx, authCtx) {
+  console.log(CONFIRMATION_MESSAGE);
+  const confirmed = await inquirer3.confirm({
+    message: "Are you sure you want to continue?",
+    default: false
+  });
+  logEmptyLine();
+  if (!confirmed) {
+    throw new Error("Model revision update cancelled");
+  }
+  spinner.start("Validating local model state...");
+  await validateLocalModelState(ctx, authCtx);
+  spinner.succeed("Local model is synced with published model");
+  const dockerImage = getDockerImage(ctx);
+  if (!options.skipChecks) {
+    spinner.start("Performing model I/O test...");
+    await runModelIOTests(dockerImage, options, app, ctx);
+    spinner.succeed("Model I/O test passed");
+  }
+  const modelConfig = await getModelConfigFromProjectConfig(ctx);
+  const model = await createModel(modelConfig, authCtx);
+  await updateProjectConfig((config) => {
+    config.$$id = model.id;
+    config.$$modelGroupID = model.modelGroupId;
+    config.$$revision = model.revision;
+    config.$$dockerImage = model.dockerImage;
+  });
+  const pushCredentials = await getRegistryPushCredentials(model.id, authCtx);
+  await loginToDockerRegistry(pushCredentials);
+  await buildDockerImage(dockerImage, ctx);
+  await pushDockerImage(dockerImage, pushCredentials.ref);
+  spinner.stopAndPersist({
+    symbol: "\u{1F680} ",
+    prefixText: "\n",
+    suffixText: "\n",
+    text: chalk3.bold(
+      `New model revision (r${model.revision}) published successfully`
+    )
+  });
+}
+
+// src/commands/publish/handle-model-revision-update-flow.ts
+import * as inquirer4 from "@inquirer/prompts";
+import chalk4 from "chalk";
+
+// src/api/update-model.ts
+async function updateModel(config, authCtx) {
+  const headers = { Authorization: `Bearer ${authCtx.accessToken}` };
+  const result = await api.patch(`model/${config.id}`, { headers, json: config }).json();
+  return result;
+}
+
+// src/commands/publish/handle-model-revision-update-flow.ts
+var WARNING_LABEL2 = chalk4.yellowBright.bold("WARNING!");
+var CONFIRMATION_MESSAGE2 = `${WARNING_LABEL2} Updating a model revision recreates the associated inputs and outputs.
+Historical data is preserved, but it will no longer be displayed in the pd4castr UI.
+`;
+async function handleModelRevisionUpdateFlow(options, app, spinner, ctx, authCtx) {
+  console.log(CONFIRMATION_MESSAGE2);
+  const confirmed = await inquirer4.confirm({
+    message: "Are you sure you want to continue?",
+    default: false
+  });
+  logEmptyLine();
+  if (!confirmed) {
+    throw new Error("Model revision update cancelled");
+  }
+  spinner.start("Validating local model state...");
+  await validateLocalModelState(ctx, authCtx);
+  spinner.succeed("Local model is synced with published model");
+  const dockerImage = getDockerImage(ctx);
+  if (!options.skipChecks) {
+    spinner.start("Performing model I/O test...");
+    await runModelIOTests(dockerImage, options, app, ctx);
+    spinner.succeed("Model I/O test passed");
+  }
+  const modelConfig = await getModelConfigFromProjectConfig(ctx);
+  const model = await updateModel(modelConfig, authCtx);
+  await updateProjectConfig((config) => {
+    config.$$id = model.id;
+    config.$$modelGroupID = model.modelGroupId;
+    config.$$revision = model.revision;
+    config.$$dockerImage = model.dockerImage;
+  });
+  const pushCredentials = await getRegistryPushCredentials(model.id, authCtx);
+  await loginToDockerRegistry(pushCredentials);
+  await buildDockerImage(dockerImage, ctx);
+  await pushDockerImage(dockerImage, pushCredentials.ref);
+  spinner.stopAndPersist({
+    symbol: "\u{1F680} ",
+    prefixText: "\n",
+    suffixText: "\n",
+    text: chalk4.bold(`${model.name} (r${model.revision}) updated successfully`)
+  });
+}
+
+// src/commands/publish/handle-update-existing-model-flow.ts
+async function handleUpdateExistingModelFlow(options, app, spinner, ctx, authCtx) {
+  spinner.info(`You are publishing an ${chalk5.bold("existing")} model:
+`);
+  getModelSummaryLines(ctx).map((line) => console.log(line));
+  const revision = ctx.config.$$revision ?? 0;
+  const action = await inquirer5.select({
+    message: "Do you want to update the existing revision or create a new one?",
+    choices: [
+      {
+        value: "new" /* NewRevision */,
+        name: `New Revision (r${revision} \u2192 r${revision + 1})`
+      },
+      {
+        value: "update" /* UpdateExisting */,
+        name: `Update Existing Revision (r${revision})`
+      }
+    ]
+  });
+  logEmptyLine();
+  if (action === "new" /* NewRevision */) {
+    await handleModelRevisionCreateFlow(options, app, spinner, ctx, authCtx);
+  } else if (action === "update" /* UpdateExisting */) {
+    await handleModelRevisionUpdateFlow(options, app, spinner, ctx, authCtx);
+  } else {
+    throw new Error("Invalid CLI state");
+  }
+}
+
+// src/commands/publish/handle-action.ts
+async function handleAction5(options) {
+  var _stack = [];
+  try {
+    const spinner = ora5("Starting model publish...").start();
+    const app = express2();
+    app.use(express2.json({ limit: "100mb" }));
+    app.use(express2.urlencoded({ limit: "100mb", extended: true }));
+    const webServer = __using(_stack, await startWebServer(app, options.port));
+    try {
+      const ctx = await loadProjectContext();
+      const authCtx = await getAuth();
+      await (ctx.config.$$id ? handleUpdateExistingModelFlow(options, app, spinner, ctx, authCtx) : handleCreateModelFlow(options, app, spinner, ctx, authCtx));
+    } catch (error) {
+      if (error instanceof ZodError5) {
+        spinner.fail("Config validation failed");
+        logZodIssues(error);
+      } else if (error instanceof HTTPError3) {
+        const errorResponse = await error.response.json();
+        spinner.fail(formatNestErrorMessage(errorResponse));
+      } else if (error instanceof Error) {
+        spinner.fail(error.message);
+        if (error.cause) {
+          console.error(error.cause);
+        }
+      }
+      process.exit(1);
+    }
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+
+// src/commands/publish/index.ts
+function registerPublishCommand(program2) {
+  program2.command("publish").description("Publishes a pd4castr model.").option(
+    "-i, --input-dir <path>",
+    "The input test data directory",
+    TEST_INPUT_DATA_DIR
+  ).option(
+    "-p, --port <port>",
+    "The port to run the IO testing webserver on",
+    TEST_WEBSERVER_PORT.toString()
+  ).option("-s, --skip-checks", "Skip the model I/O checks", false).action(handleAction5);
+}
+
 // src/commands/test/handle-action.ts
-async function handleAction4(options) {
+import path14 from "path";
+import express3 from "express";
+import ora6 from "ora";
+import { ZodError as ZodError6 } from "zod";
+async function handleAction6(options) {
   var _stack = [];
   try {
-    const spinner = ora4("Starting model tests...").info();
-    const app = express();
+    const spinner = ora6("Starting model tests...").info();
+    const app = express3();
+    app.use(express3.json({ limit: "100mb" }));
+    app.use(express3.urlencoded({ limit: "100mb", extended: true }));
     const webServer = __using(_stack, await startWebServer(app, options.port));
     try {
-      const ctx = await loadProjectConfig();
+      const ctx = await loadProjectContext();
       const inputFiles = getInputFiles(ctx.config);
       spinner.start("Checking test input data files");
       await checkInputFiles(inputFiles, options.inputDir, ctx);
       spinner.succeed(`Found ${inputFiles.length} test input data files`);
       spinner.start("Building docker image");
-      const sluggedName = slugify(ctx.config.name, { lower: true });
-      const dockerImage = `pd4castr/${sluggedName}-local:${Date.now()}`;
+      const dockerImage = getDockerImage(ctx);
       await buildDockerImage(dockerImage, ctx);
       spinner.succeed(`Built docker image (${dockerImage})`);
-      const modelIOChecks = new ModelIOChecks({ inputFiles });
-      const handleInput = createInputHandler(
+      const modelIOChecks = setupModelIOChecks(
+        app,
         options.inputDir,
-        modelIOChecks,
+        inputFiles,
         ctx
       );
-      const handleOutput = createOutputHandler(modelIOChecks, ctx);
-      const inputPath = path11.join(ctx.projectRoot, options.inputDir);
-      app.use(express.json());
-      app.use("/data", express.static(inputPath));
-      app.get("/input/:filename", handleInput);
-      app.put("/output", handleOutput);
       spinner.start("Running model container");
-      const webserverURL = `http://host.docker.internal:${options.port}`;
-      await runModelContainer(dockerImage, webserverURL, ctx);
+      await runModelContainer(dockerImage, options.port, ctx);
       spinner.succeed("Model run complete");
       for (const inputFile of inputFiles) {
         const status = modelIOChecks.isInputHandled(inputFile) ? "\u2714" : "\u2718";
@@ -690,10 +1242,10 @@ async function handleAction4(options) {
       if (modelIOChecks.isInputsHandled() && modelIOChecks.isOutputHandled()) {
         spinner.succeed("Model I/O test passed");
       } else {
-        spinner.fail("Model I/O test failed");
+        throw new Error("Model I/O test failed");
       }
       if (modelIOChecks.isOutputHandled()) {
-        const outputPath = path11.join(
+        const outputPath = path14.join(
           ctx.projectRoot,
           TEST_OUTPUT_DATA_DIR,
           TEST_OUTPUT_FILENAME
@@ -705,14 +1257,14 @@ ${clickHereLink} to view output (${fileLink})
 `);
       }
     } catch (error) {
-      if (error instanceof ZodError3) {
+      if (error instanceof ZodError6) {
         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);
+        if (error.cause) {
+          console.error(error.cause);
+        }
       }
       process.exit(1);
     }
@@ -731,7 +1283,11 @@ function registerTestCommand(program2) {
     "-i, --input-dir <path>",
     "The input test data directory",
     TEST_INPUT_DATA_DIR
-  ).option("-p, --port <port>", "The port to run the webserver on", "9800").action(handleAction4);
+  ).option(
+    "-p, --port <port>",
+    "The port to run the IO testing webserver on",
+    TEST_WEBSERVER_PORT.toString()
+  ).action(handleAction6);
 }
 
 // src/program.ts
@@ -740,7 +1296,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@pd4castr/cli",
-  version: "0.0.5",
+  version: "0.0.6",
   description: "CLI tool for creating, testing, and publishing pd4castr models",
   main: "dist/index.js",
   type: "module",
@@ -761,7 +1317,7 @@ var package_default = {
     "lint:fix": "eslint . --fix",
     format: "prettier --write .",
     "format:check": "prettier --check .",
-    "type-check": "tsc --noEmit",
+    typecheck: "tsc --noEmit",
     prepublishOnly: "yarn build"
   },
   keywords: [
@@ -778,6 +1334,8 @@ var package_default = {
   },
   homepage: "https://github.com/pipelabs/pd4castr-cli#readme",
   devDependencies: {
+    "@faker-js/faker": "10.0.0",
+    "@mswjs/data": "0.16.2",
     "@types/express": "4.17.21",
     "@types/node": "24.1.0",
     "@types/supertest": "6.0.3",
@@ -788,12 +1346,15 @@ var package_default = {
     "eslint-plugin-simple-import-sort": "12.1.1",
     "eslint-plugin-unicorn": "60.0.0",
     "eslint-plugin-vitest": "0.5.4",
+    "hook-std": "3.0.0",
     "jest-extended": "6.0.0",
     memfs: "4.23.0",
     msw: "2.10.4",
     prettier: "3.6.2",
+    "strip-ansi": "7.1.0",
     supertest: "7.1.4",
     tsup: "8.5.0",
+    "type-fest": "4.41.0",
     typescript: "5.8.3",
     "typescript-eslint": "8.38.0",
     vitest: "3.2.4"
@@ -801,11 +1362,12 @@ var package_default = {
   dependencies: {
     "@inquirer/prompts": "7.7.1",
     auth0: "4.27.0",
+    chalk: "5.6.0",
     commander: "14.0.0",
     execa: "9.6.0",
     express: "4.21.2",
+    immer: "10.1.1",
     ky: "1.8.2",
-    lilconfig: "3.1.3",
     ora: "8.2.0",
     slugify: "1.6.6",
     tiged: "2.12.7",
@@ -824,6 +1386,8 @@ program.name("pd4castr").description("CLI tool for pd4castr").version(package_de
 // src/index.ts
 registerInitCommand(program);
 registerLoginCommand(program);
+registerLogoutCommand(program);
 registerTestCommand(program);
 registerFetchCommand(program);
+registerPublishCommand(program);
 await program.parseAsync(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pd4castr/cli",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "CLI tool for creating, testing, and publishing pd4castr models",
   "main": "dist/index.js",
   "type": "module",
@@ -21,7 +21,7 @@
     "lint:fix": "eslint . --fix",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
-    "type-check": "tsc --noEmit",
+    "typecheck": "tsc --noEmit",
     "prepublishOnly": "yarn build"
   },
   "keywords": [
@@ -38,6 +38,8 @@
   },
   "homepage": "https://github.com/pipelabs/pd4castr-cli#readme",
   "devDependencies": {
+    "@faker-js/faker": "10.0.0",
+    "@mswjs/data": "0.16.2",
     "@types/express": "4.17.21",
     "@types/node": "24.1.0",
     "@types/supertest": "6.0.3",
@@ -48,12 +50,15 @@
     "eslint-plugin-simple-import-sort": "12.1.1",
     "eslint-plugin-unicorn": "60.0.0",
     "eslint-plugin-vitest": "0.5.4",
+    "hook-std": "3.0.0",
     "jest-extended": "6.0.0",
     "memfs": "4.23.0",
     "msw": "2.10.4",
     "prettier": "3.6.2",
+    "strip-ansi": "7.1.0",
     "supertest": "7.1.4",
     "tsup": "8.5.0",
+    "type-fest": "4.41.0",
     "typescript": "5.8.3",
     "typescript-eslint": "8.38.0",
     "vitest": "3.2.4"
@@ -61,11 +66,12 @@
   "dependencies": {
     "@inquirer/prompts": "7.7.1",
     "auth0": "4.27.0",
+    "chalk": "5.6.0",
     "commander": "14.0.0",
     "execa": "9.6.0",
     "express": "4.21.2",
+    "immer": "10.1.1",
     "ky": "1.8.2",
-    "lilconfig": "3.1.3",
     "ora": "8.2.0",
     "slugify": "1.6.6",
     "tiged": "2.12.7",