@pd4castr/cli 0.0.4 → 0.0.6

package/dist/index.js

@@ -45,97 +45,330 @@ var __callDispose = (stack, error, hasError) => {
   return next();
 };
 
-// src/program.ts
-import { Command } from "commander";
+// 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 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";
 
-// package.json
-var package_default = {
-  name: "@pd4castr/cli",
-  version: "0.0.4",
-  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",
-    slugify: "1.6.6",
-    tiged: "2.12.7",
-    "tiny-invariant": "1.3.3",
-    zod: "4.0.14"
-  },
-  engines: {
-    node: ">=20.0.0"
+// src/commands/fetch/handle-action.ts
+import path5 from "path";
+import { HTTPError } from "ky";
+import ora from "ora";
+import { ZodError as ZodError2 } from "zod";
+
+// src/config/load-project-context.ts
+import fs2 from "fs/promises";
+import path from "path";
+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),
+  config: z.object({
+    checkQuery: z.string(),
+    fetchQuery: z.string()
+  })
+});
+var dataFetcherSchema = z.discriminatedUnion("type", [aemoDataFetcherSchema]);
+var modelInputSchema = z.object({
+  key: z.string(),
+  inputSource: z.string().optional().default(DEFAULT_INPUT_SOURCE_ID),
+  trigger: z.enum(["WAIT_FOR_LATEST_FILE", "USE_MOST_RECENT_FILE"]),
+  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({
+  name: z.string(),
+  forecastVariable: z.enum(["price"]),
+  timeHorizon: z.enum(["actual", "day_ahead", "week_ahead", "quarterly"]),
+  metadata: z.record(z.string(), z.any()).optional(),
+  inputs: z.array(modelInputSchema),
+  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/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-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)."
+    );
+  }
+  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
+var ESC = "\x1B";
+var OSC = `${ESC}]`;
+var SEP = ";";
+function createLink(text, url) {
+  const start = `${OSC}8${SEP}${SEP}${url}${ESC}\\`;
+  const end = `${OSC}8${SEP}${SEP}${ESC}\\`;
+  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/config/load-global-config.ts
+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().nullable(),
+  accessTokenExpiresAt: z2.number().nullable()
+});
+
+// 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 fs3.writeFile(configPath, JSON.stringify({}));
+    return getDefaultConfig();
+  }
+  try {
+    const configFileContents = await fs3.readFile(configPath, "utf8");
+    const config = JSON.parse(configFileContents);
+    return globalConfigSchema.parse(config);
+  } catch {
+    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() {
+  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/utils/log-zod-issues.ts
+function logZodIssues(error) {
+  for (const issue of error.issues) {
+    console.log(`  \u2718 ${issue.path.join(".")} - ${issue.message}`);
+  }
+}
+
+// src/commands/fetch/utils/fetch-aemo-data.ts
+import fs4 from "fs/promises";
+import path3 from "path";
+
+// 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: 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 fs4.readFile(queryPath, "utf8");
+  const result = await queryDataFetcher(querySQL, authCtx);
+  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/program.ts
-var program = new Command();
-program.name("pd4castr").description("CLI tool for pd4castr").version(package_default.version);
+// src/commands/fetch/utils/write-test-data.ts
+import fs5 from "fs/promises";
+import path4 from "path";
+
+// src/utils/get-input-filename.ts
+function getInputFilename(modelInput) {
+  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 fs5.mkdir(inputDir, { recursive: true });
+  const inputFilename = getInputFilename(modelInput);
+  const inputPath = path4.resolve(inputDir, inputFilename);
+  await fs5.writeFile(inputPath, JSON.stringify(inputData, void 0, 2));
+}
+
+// src/commands/fetch/handle-action.ts
+var FETCHABLE_DATA_FETCHER_TYPES = /* @__PURE__ */ new Set(["AEMO_MMS"]);
+async function handleAction(options) {
+  const spinner = ora("Starting data fetch...").start();
+  try {
+    const authCtx = await getAuth();
+    const ctx = await loadProjectContext();
+    for (const input2 of ctx.config.inputs) {
+      if (!input2.fetcher) {
+        spinner.warn(`\`${input2.key}\` - no data fetcher defined, skipping`);
+        continue;
+      }
+      if (!FETCHABLE_DATA_FETCHER_TYPES.has(input2.fetcher.type)) {
+        spinner.warn(
+          `\`${input2.key}\` (${input2.fetcher.type}) - unsupported, skipping`
+        );
+        continue;
+      }
+      spinner.start(`\`${input2.key}\` (${input2.fetcher.type}) - fetching...`);
+      const fetchData = getFetcher(input2.fetcher.type);
+      const output = await fetchData(input2.fetcher, authCtx, ctx);
+      await writeTestData(output, input2, options.inputDir, ctx);
+      spinner.succeed(`\`${input2.key}\` (${input2.fetcher.type}) - fetched`);
+    }
+    const inputPath = path5.resolve(ctx.projectRoot, options.inputDir);
+    const link = createLink("Click here", `file://${inputPath}`);
+    console.log(`
+${link} to view fetched data
+`);
+  } catch (error) {
+    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);
+  }
+}
+
+// src/commands/fetch/index.ts
+function registerFetchCommand(program2) {
+  program2.command("fetch").description("Fetches test data from configured data fetchers.").option(
+    "-i, --input-dir <path>",
+    "The input test data directory",
+    TEST_INPUT_DATA_DIR
+  ).action(handleAction);
+}
 
 // src/commands/init/handle-action.ts
-import path from "path";
+import path6 from "path";
 import * as inquirer from "@inquirer/prompts";
+import ora2 from "ora";
 import tiged from "tiged";
-import ora from "ora";
 
 // src/commands/init/constants.ts
 var templates = {
@@ -156,17 +389,6 @@ 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(path12) {
-  try {
-    await fs.access(path12);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // src/commands/init/utils/validate-name.ts
 async function validateName(value) {
   const exists = await isExistingPath(`./${value}`);
@@ -177,7 +399,7 @@ async function validateName(value) {
 }
 
 // src/commands/init/handle-action.ts
-async function handleAction() {
+async function handleAction2() {
   const projectName = await inquirer.input({
     message: "Name your new model project",
     default: "my-model",
@@ -190,14 +412,14 @@ async function handleAction() {
       value: template2.name
     }))
   });
-  const spinner = ora("Fetching template...").start();
+  const spinner = ora2("Fetching template...").start();
   try {
     await fetchTemplate(template, projectName);
     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);
   }
@@ -208,104 +430,39 @@ async function fetchTemplate(template, projectName) {
     disableCache: true,
     force: true
   });
-  const destination = path.join(process.cwd(), projectName);
+  const destination = path6.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);
+  program2.command("init").description("Initialize a new model using a template.").action(handleAction2);
 }
 
 // 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://pd4castr-api.pipelabs.app";
-var TEST_INPUT_DATA_DIR = "test_input";
-var TEST_OUTPUT_DATA_DIR = "test_output";
-var TEST_OUTPUT_FILENAME = `output-${Date.now()}.json`;
-
-// 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 {};
-  }
-}
+import ora3 from "ora";
+import { ZodError as ZodError3 } from "zod";
 
 // src/config/update-global-config.ts
-import fs3 from "fs/promises";
-import path3 from "path";
+import fs6 from "fs/promises";
 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}`);
-  }
+import path7 from "path";
+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 fs6.writeFile(configPath, JSON.stringify(updatedConfig, void 0, 2));
 }
 
-// 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/utils/complete-auth-flow.ts
+import { HTTPError as HTTPError2 } from "ky";
 
 // 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 email"
-};
-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;
-}
+import ky2 from "ky";
+var auth0API = ky2.create({ prefixUrl: `https://${AUTH0_DOMAIN}` });
 
 // 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 = {
@@ -322,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();
@@ -341,9 +498,26 @@ async function completeAuthFlow(authCtx) {
   return fetchAuthResponse();
 }
 
+// src/commands/login/utils/start-auth-flow.ts
+var payload = {
+  client_id: AUTH0_CLIENT_ID,
+  audience: AUTH0_AUDIENCE,
+  scope: "openid email"
+};
+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/handle-action.ts
-async function handleAction2() {
-  const spinner = ora2("Logging in to the pd4castr API...").start();
+async function handleAction3() {
+  const spinner = ora3("Logging in to the pd4castr API...").start();
   try {
     const globalConfig = await loadGlobalConfig();
     if (isAuthed(globalConfig)) {
@@ -360,19 +534,20 @@ async function handleAction2() {
 `);
     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 ZodError) {
+    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);
   }
@@ -380,90 +555,95 @@ async function handleAction2() {
 
 // src/commands/login/index.ts
 function registerLoginCommand(program2) {
-  program2.command("login").description("Logs in to the pd4castr API.").action(handleAction2);
+  program2.command("login").description("Logs in to the pd4castr API.").action(handleAction3);
 }
 
-// src/commands/test/handle-action.ts
-import ora3 from "ora";
-import express from "express";
-import path8 from "path";
-import slugify from "slugify";
-import { ExecaError } from "execa";
-import { ZodError as ZodError2 } from "zod";
+// src/commands/logout/handle-action.ts
+import ora4 from "ora";
+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/config/load-project-config.ts
-import path4 from "path";
-import { lilconfig } from "lilconfig";
+// src/commands/logout/index.ts
+function registerLogoutCommand(program2) {
+  program2.command("logout").description("Logs out of the pd4castr API.").action(handleAction4);
+}
 
-// src/schemas/project-config-schema.ts
-import { z as z2 } from "zod";
-var aemoDataFetcherSchema = z2.object({
-  type: z2.literal("AEMO_MMS"),
-  checkInterval: z2.number().int().min(60),
-  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().optional(),
-  trigger: z2.enum(["WAIT_FOR_LATEST_FILE", "USE_MOST_RECENT_FILE"]),
-  fetcher: dataFetcherSchema.optional()
-});
-var modelOutputSchema = z2.object({
-  name: z2.string(),
-  seriesKey: z2.boolean(),
-  colour: z2.string().regex(/^#[0-9A-Fa-f]{6}$/).optional()
-});
-var projectConfigSchema = z2.object({
-  $$id: z2.string().nullable(),
-  $$modelGroupID: z2.string().nullable(),
-  $$revision: z2.number().int().min(0).default(0),
-  $$dockerImage: z2.string().nullable(),
-  name: z2.string(),
-  metadata: z2.record(z2.string(), z2.any()).optional(),
-  forecastVariable: z2.enum(["PRICE"]),
-  timeHorizon: z2.enum(["ACTUAL", "DAY_AHEAD", "WEEK_AHEAD"]),
-  inputs: z2.array(modelInputSchema),
-  outputs: z2.array(modelOutputSchema)
-});
+// 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/config/parse-project-config.ts
-function parseProjectConfig(config) {
-  return projectConfigSchema.parse(config);
+// 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/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)."
-    );
-  }
-  const config = parseProjectConfig(result.config);
-  const projectRoot = path4.dirname(result.filepath);
-  return {
-    config,
-    projectRoot
-  };
+// 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/utils/create-link.ts
-var ESC = "\x1B";
-var OSC = `${ESC}]`;
-var SEP = ";";
-function createLink(text, url) {
-  const start = `${OSC}8${SEP}${SEP}${url}${ESC}\\`;
-  const end = `${OSC}8${SEP}${SEP}${ESC}\\`;
-  return `${start}${text}${end}`;
+// 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/commands/test/utils/build-docker-image.ts
+// src/docker/build-docker-image.ts
 import { execa } from "execa";
 async function buildDockerImage(dockerImage, ctx) {
   try {
@@ -476,15 +656,224 @@ async function buildDockerImage(dockerImage, ctx) {
   }
 }
 
-// src/commands/test/utils/create-input-handler.ts
-import path5 from "path";
+// 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/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";
+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;
+    }
+    const fetchQueryPath = path9.resolve(
+      ctx.projectRoot,
+      input2.fetcher.config.fetchQuery
+    );
+    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/utils/log-empty-line.ts
+function logEmptyLine() {
+  console.log("");
+}
+
+// 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/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;
+  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/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 = path5.join(
+    const filePath = path10.join(
       ctx.projectRoot,
       inputFilesPath,
       req.params.filename
@@ -493,26 +882,39 @@ function createInputHandler(inputFilesPath, modelIOChecks, ctx) {
   };
 }
 
-// src/commands/test/utils/create-output-handler.ts
-import path6 from "path";
-import fs4 from "fs/promises";
+// 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 = path6.join(ctx.projectRoot, TEST_OUTPUT_DATA_DIR);
-    await fs4.mkdir(outputPath, { recursive: true });
-    const outputFilePath = path6.join(outputPath, TEST_OUTPUT_FILENAME);
+    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 fs4.writeFile(outputFilePath, outputData, "utf8");
+    await fs9.writeFile(outputFilePath, outputData, "utf8");
     return res.status(200).json({ success: true });
   };
 }
 
-// src/commands/test/utils/check-input-files.ts
-import path7 from "path";
+// 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 = path7.join(ctx.projectRoot, inputDataPath, inputFile);
+    const filePath = path13.join(ctx.projectRoot, inputDataPath, inputFile);
     const exists = await isExistingPath(filePath);
     if (!exists) {
       throw new Error(
@@ -522,130 +924,314 @@ async function checkInputFiles(inputFiles, inputDataPath, ctx) {
   }
 }
 
-// src/utils/get-input-filename.ts
-function getInputFilename(modelInput) {
-  return `${modelInput.key}.json`;
-}
-
-// src/commands/test/utils/get-input-files.ts
+// src/utils/get-input-files.ts
 function getInputFiles(config) {
   const inputFiles = config.inputs.map((input2) => getInputFilename(input2));
   return inputFiles;
 }
 
-// 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;
-    }
+// 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
+  );
+  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."
+    );
   }
-  trackInputHandled(filename) {
-    if (this.inputsToDownload[filename] !== void 0) {
-      this.inputsToDownload[filename] = true;
-    }
+}
+
+// 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");
   }
-  trackOutputHandled() {
-    this.outputUploaded = true;
+  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");
   }
-  isOutputHandled() {
-    return this.outputUploaded;
+  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})`
+    );
   }
-  isInputHandled(filename) {
-    return this.inputsToDownload[filename];
+  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})`
+    );
   }
-  isInputsHandled() {
-    return Object.values(this.inputsToDownload).every(Boolean);
+}
+
+// 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");
   }
-  isValidInput(filename) {
-    return this.inputsToDownload[filename] !== void 0;
+  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/test/utils/run-model-container.ts
-import { execa as execa2 } from "execa";
+// src/commands/publish/handle-model-revision-update-flow.ts
+import * as inquirer4 from "@inquirer/prompts";
+import chalk4 from "chalk";
 
-// 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/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/test/utils/run-model-container.ts
-async function runModelContainer(dockerImage, webserverURL, ctx) {
-  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",
-      "--network=host",
-      ...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 });
+// 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/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-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 handleAction3(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 = ora3("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 = path8.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://localhost:${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";
@@ -656,10 +1242,10 @@ async function handleAction3(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 = path8.join(
+        const outputPath = path14.join(
           ctx.projectRoot,
           TEST_OUTPUT_DATA_DIR,
           TEST_OUTPUT_FILENAME
@@ -671,14 +1257,14 @@ ${clickHereLink} to view output (${fileLink})
 `);
       }
     } catch (error) {
-      if (error instanceof ZodError2) {
+      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);
     }
@@ -697,127 +1283,111 @@ 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(handleAction3);
+  ).option(
+    "-p, --port <port>",
+    "The port to run the IO testing webserver on",
+    TEST_WEBSERVER_PORT.toString()
+  ).action(handleAction6);
 }
 
-// src/commands/fetch/handle-action.ts
-import ora4 from "ora";
-import path11 from "path";
-import { ZodError as ZodError3 } from "zod";
+// src/program.ts
+import { Command } from "commander";
 
-// 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.");
+// package.json
+var package_default = {
+  name: "@pd4castr/cli",
+  version: "0.0.6",
+  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 .",
+    typecheck: "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: {
+    "@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",
+    "@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-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"
+  },
+  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",
+    ora: "8.2.0",
+    slugify: "1.6.6",
+    tiged: "2.12.7",
+    "tiny-invariant": "1.3.3",
+    zod: "4.0.14"
+  },
+  engines: {
+    node: ">=20.0.0"
   }
-  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 path9 from "path";
-import fs5 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, ctx) {
-  const queryPath = path9.resolve(
-    ctx.projectRoot,
-    dataFetcher.config.fetchQuery
-  );
-  const querySQL = await fs5.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();
-  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 path10 from "path";
-import fs6 from "fs/promises";
-async function writeTestData(inputData, modelInput, inputDataDir, ctx) {
-  const inputDir = path10.resolve(ctx.projectRoot, inputDataDir);
-  await fs6.mkdir(inputDir, { recursive: true });
-  const inputFilename = getInputFilename(modelInput);
-  const inputPath = path10.resolve(inputDir, inputFilename);
-  await fs6.writeFile(inputPath, JSON.stringify(inputData, void 0, 2));
-}
-
-// src/commands/fetch/handle-action.ts
-var FETCHABLE_DATA_FETCHER_TYPES = /* @__PURE__ */ new Set(["AEMO_MMS"]);
-async function handleAction4(options) {
-  const spinner = ora4("Starting data fetch...").start();
-  try {
-    const authCtx = await getAuth();
-    const ctx = await loadProjectConfig();
-    for (const input2 of ctx.config.inputs) {
-      if (!input2.fetcher) {
-        spinner.warn(`\`${input2.key}\` - no data fetcher defined, skipping`);
-        continue;
-      }
-      if (!FETCHABLE_DATA_FETCHER_TYPES.has(input2.fetcher.type)) {
-        spinner.warn(
-          `\`${input2.key}\` (${input2.fetcher.type}) - unsupported, skipping`
-        );
-        continue;
-      }
-      spinner.start(`\`${input2.key}\` (${input2.fetcher.type}) - fetching...`);
-      const fetchData = getFetcher(input2.fetcher.type);
-      const output = await fetchData(input2.fetcher, authCtx, ctx);
-      await writeTestData(output, input2, options.inputDir, ctx);
-      spinner.succeed(`\`${input2.key}\` (${input2.fetcher.type}) - fetched`);
-    }
-    const inputPath = path11.resolve(ctx.projectRoot, options.inputDir);
-    const link = createLink("Click here", `file://${inputPath}`);
-    console.log(`
-${link} to view fetched data
-`);
-  } 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-dir <path>",
-    "The input test data directory",
-    TEST_INPUT_DATA_DIR
-  ).action(handleAction4);
-}
+// src/program.ts
+var program = new Command();
+program.name("pd4castr").description("CLI tool for pd4castr").version(package_default.version);
 
 // src/index.ts
 registerInitCommand(program);
 registerLoginCommand(program);
+registerLogoutCommand(program);
 registerTestCommand(program);
 registerFetchCommand(program);
+registerPublishCommand(program);
 await program.parseAsync(process.argv);