@kortyx/cli 0.1.4 → 0.2.0

package/dist/index.js

@@ -0,0 +1,900 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_promises2 = require("fs/promises");
+var import_node_module = __toESM(require("module"));
+var import_node_os2 = require("os");
+var import_node_path2 = require("path");
+var import_agent = require("@kortyx/agent");
+var import_telemetry_contracts = require("@kortyx/telemetry-contracts");
+var import_commander2 = require("commander");
+var import_api = require("tsx/cjs/api");
+
+// src/studio/command.ts
+var import_commander = require("commander");
+
+// src/studio/state.ts
+var import_promises = require("fs/promises");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var import_zod = require("zod");
+
+// src/studio/compose.ts
+var STUDIO_COMPOSE_FILE = `name: \${KORTYX_COMPOSE_PROJECT_NAME:-kortyx-studio}
+
+x-api-env: &api-env
+  DATABASE_URL: postgres://kortyx:\${POSTGRES_PASSWORD}@postgres:5432/kortyx
+  KORTYX_API_KEY_PEPPER: \${KORTYX_API_KEY_PEPPER}
+
+x-bootstrap-keys: &bootstrap-keys
+  KORTYX_TELEMETRY_API_KEY: \${KORTYX_TELEMETRY_API_KEY}
+  KORTYX_STUDIO_API_KEY: \${KORTYX_STUDIO_API_KEY}
+
+services:
+  postgres:
+    image: postgres:17-alpine
+    environment:
+      POSTGRES_USER: kortyx
+      POSTGRES_PASSWORD: \${POSTGRES_PASSWORD}
+      POSTGRES_DB: kortyx
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U kortyx -d kortyx"]
+      interval: 2s
+      timeout: 5s
+      retries: 30
+
+  db-init:
+    image: \${KORTYX_API_IMAGE:-ghcr.io/kortyx-io/kortyx-api}:\${KORTYX_STUDIO_IMAGE_TAG:-latest}
+    pull_policy: \${KORTYX_STUDIO_PULL_POLICY:-always}
+    environment:
+      <<: [*api-env, *bootstrap-keys]
+    command: >
+      sh -lc "pnpm --filter @kortyx/telemetry-db db:migrate &&
+      pnpm --filter @kortyx/telemetry-db db:bootstrap"
+    depends_on:
+      postgres:
+        condition: service_healthy
+    restart: "no"
+
+  api:
+    image: \${KORTYX_API_IMAGE:-ghcr.io/kortyx-io/kortyx-api}:\${KORTYX_STUDIO_IMAGE_TAG:-latest}
+    pull_policy: \${KORTYX_STUDIO_PULL_POLICY:-always}
+    environment:
+      <<: *api-env
+      NODE_ENV: production
+      API_HOST: 0.0.0.0
+      API_PORT: 6400
+    ports:
+      - "127.0.0.1:\${API_PORT:-6400}:6400"
+    depends_on:
+      db-init:
+        condition: service_completed_successfully
+    healthcheck:
+      test:
+        [
+          "CMD-SHELL",
+          "node -e \\"fetch('http://localhost:6400/health').then((r)=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))\\"",
+        ]
+      interval: 5s
+      timeout: 5s
+      retries: 30
+
+  studio:
+    image: \${KORTYX_STUDIO_IMAGE:-ghcr.io/kortyx-io/kortyx-studio}:\${KORTYX_STUDIO_IMAGE_TAG:-latest}
+    pull_policy: \${KORTYX_STUDIO_PULL_POLICY:-always}
+    environment:
+      NODE_ENV: production
+      PORT: 6300
+      KORTYX_API_URL: http://api:6400
+      KORTYX_STUDIO_API_KEY: \${KORTYX_STUDIO_API_KEY}
+      KORTYX_STUDIO_AUTH_MODE: basic
+      KORTYX_STUDIO_BASIC_AUTH_USERNAME: \${KORTYX_STUDIO_BASIC_AUTH_USERNAME}
+      KORTYX_STUDIO_BASIC_AUTH_PASSWORD: \${KORTYX_STUDIO_BASIC_AUTH_PASSWORD}
+    ports:
+      - "127.0.0.1:\${STUDIO_PORT:-6300}:6300"
+    depends_on:
+      api:
+        condition: service_healthy
+    healthcheck:
+      test:
+        [
+          "CMD-SHELL",
+          "node -e \\"fetch('http://localhost:6300').then((r)=>process.exit(r.status<500?0:1)).catch(()=>process.exit(1))\\"",
+        ]
+      interval: 5s
+      timeout: 5s
+      retries: 30
+
+volumes:
+  postgres-data:
+`;
+
+// src/studio/state.ts
+var CONFIG_VERSION = 1;
+var DEFAULT_API_PORT = 6400;
+var DEFAULT_STUDIO_PORT = 6300;
+var DEFAULT_IMAGE_TAG = "latest";
+var DEFAULT_USERNAME = "admin";
+var DEFAULT_PROJECT_NAME = "kortyx-studio";
+var PortSchema = import_zod.z.number().int().min(1).max(65535);
+var StudioConfigSchema = import_zod.z.object({
+  version: import_zod.z.literal(CONFIG_VERSION),
+  apiPort: PortSchema,
+  studioPort: PortSchema,
+  imageTag: import_zod.z.string().regex(
+    /^[A-Za-z0-9][A-Za-z0-9._-]*$/,
+    "Image tag contains unsupported characters."
+  ),
+  username: import_zod.z.string().regex(/^[A-Za-z0-9._@-]+$/, "Username contains unsupported characters."),
+  projectName: import_zod.z.string().regex(
+    /^[a-z0-9][a-z0-9_-]*$/,
+    "Docker Compose project name contains unsupported characters."
+  ),
+  createdAt: import_zod.z.iso.datetime()
+}).refine((config) => config.apiPort !== config.studioPort, {
+  message: "Studio and API ports must be different.",
+  path: ["apiPort"]
+});
+var ApiKeySchema = import_zod.z.string().regex(/^ktyx_(?:test|live)_[^_]+_.+$/, "Invalid Kortyx API key.");
+var StudioEnvironmentSchema = import_zod.z.object({
+  KORTYX_COMPOSE_PROJECT_NAME: import_zod.z.string().min(1),
+  KORTYX_STUDIO_IMAGE_TAG: import_zod.z.string().min(1),
+  API_PORT: import_zod.z.string().regex(/^\d+$/),
+  STUDIO_PORT: import_zod.z.string().regex(/^\d+$/),
+  POSTGRES_PASSWORD: import_zod.z.string().min(16),
+  KORTYX_API_KEY_PEPPER: import_zod.z.string().min(16),
+  KORTYX_TELEMETRY_API_KEY: ApiKeySchema,
+  KORTYX_STUDIO_API_KEY: ApiKeySchema,
+  KORTYX_STUDIO_BASIC_AUTH_USERNAME: import_zod.z.string().min(1),
+  KORTYX_STUDIO_BASIC_AUTH_PASSWORD: import_zod.z.string().min(12)
+}).passthrough();
+var defaultStudioHome = () => (0, import_node_path.resolve)(
+  process.env.KORTYX_STUDIO_HOME ?? (0, import_node_path.join)((0, import_node_os.homedir)(), ".kortyx", "studio")
+);
+var studioConfigPath = (home) => (0, import_node_path.join)(home, "config.json");
+var studioEnvPath = (home) => (0, import_node_path.join)(home, ".env");
+var studioComposePath = (home) => (0, import_node_path.join)(home, "compose.yml");
+var isMissingFile = (error) => error instanceof Error && "code" in error && error.code === "ENOENT";
+var invalidStateError = (label, path, error) => new Error(
+  `Unsupported or invalid Studio ${label} at ${path}.
+${import_zod.z.prettifyError(error)}`
+);
+var readStudioConfig = async (home) => {
+  try {
+    const parsed = JSON.parse(
+      await (0, import_promises.readFile)(studioConfigPath(home), "utf8")
+    );
+    const result = StudioConfigSchema.safeParse(parsed);
+    if (!result.success) {
+      throw invalidStateError("config", studioConfigPath(home), result.error);
+    }
+    return result.data;
+  } catch (error) {
+    if (isMissingFile(error)) return void 0;
+    throw error;
+  }
+};
+var resolveConfig = (existing, options, runtime) => {
+  const result = StudioConfigSchema.safeParse({
+    version: CONFIG_VERSION,
+    apiPort: options.apiPort ?? existing?.apiPort ?? DEFAULT_API_PORT,
+    studioPort: options.studioPort ?? existing?.studioPort ?? DEFAULT_STUDIO_PORT,
+    imageTag: options.imageTag ?? existing?.imageTag ?? DEFAULT_IMAGE_TAG,
+    username: options.username ?? existing?.username ?? DEFAULT_USERNAME,
+    projectName: options.projectName ?? existing?.projectName ?? DEFAULT_PROJECT_NAME,
+    createdAt: existing?.createdAt ?? runtime.now()
+  });
+  if (!result.success) {
+    throw new Error(
+      `Invalid Studio configuration.
+${import_zod.z.prettifyError(result.error)}`
+    );
+  }
+  return result.data;
+};
+var createApiKey = (purpose, runtime) => `ktyx_live_${purpose}${runtime.random(6).toLowerCase()}_${runtime.random(32)}`;
+var createEnvironment = (config, runtime) => StudioEnvironmentSchema.parse({
+  KORTYX_COMPOSE_PROJECT_NAME: config.projectName,
+  KORTYX_STUDIO_IMAGE_TAG: config.imageTag,
+  API_PORT: String(config.apiPort),
+  STUDIO_PORT: String(config.studioPort),
+  POSTGRES_PASSWORD: runtime.random(32),
+  KORTYX_API_KEY_PEPPER: runtime.random(48),
+  KORTYX_TELEMETRY_API_KEY: createApiKey("telemetry", runtime),
+  KORTYX_STUDIO_API_KEY: createApiKey("studio", runtime),
+  KORTYX_STUDIO_BASIC_AUTH_USERNAME: config.username,
+  KORTYX_STUDIO_BASIC_AUTH_PASSWORD: runtime.random(24)
+});
+var parseEnvironmentFile = (raw, path) => {
+  const values = {};
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line || line.startsWith("#")) continue;
+    const separator = line.indexOf("=");
+    if (separator <= 0) {
+      throw new Error(`Invalid environment entry in ${path}: ${line}`);
+    }
+    values[line.slice(0, separator)] = line.slice(separator + 1);
+  }
+  const result = StudioEnvironmentSchema.safeParse(values);
+  if (!result.success) {
+    throw invalidStateError("environment", path, result.error);
+  }
+  return result.data;
+};
+var serializeEnvironment = (environment) => `${Object.entries(environment).map(([key, value]) => `${key}=${value}`).join("\n")}
+`;
+var readStudioEnvironment = async (home) => {
+  const path = studioEnvPath(home);
+  return parseEnvironmentFile(await (0, import_promises.readFile)(path, "utf8"), path);
+};
+var ensureStudioState = async (options, runtime) => {
+  await (0, import_promises.mkdir)(options.home, { recursive: true, mode: 448 });
+  await (0, import_promises.chmod)(options.home, 448);
+  const existing = await readStudioConfig(options.home);
+  const config = resolveConfig(existing, options, runtime);
+  await (0, import_promises.writeFile)(
+    studioConfigPath(options.home),
+    `${JSON.stringify(config, null, 2)}
+`,
+    { mode: 384 }
+  );
+  await (0, import_promises.chmod)(studioConfigPath(options.home), 384);
+  await (0, import_promises.writeFile)(studioComposePath(options.home), STUDIO_COMPOSE_FILE, {
+    mode: 384
+  });
+  await (0, import_promises.chmod)(studioComposePath(options.home), 384);
+  let environment;
+  try {
+    environment = await readStudioEnvironment(options.home);
+  } catch (error) {
+    if (!isMissingFile(error)) throw error;
+    environment = createEnvironment(config, runtime);
+  }
+  const updatedEnvironment = StudioEnvironmentSchema.parse({
+    ...environment,
+    KORTYX_COMPOSE_PROJECT_NAME: config.projectName,
+    KORTYX_STUDIO_IMAGE_TAG: config.imageTag,
+    API_PORT: String(config.apiPort),
+    STUDIO_PORT: String(config.studioPort),
+    KORTYX_STUDIO_BASIC_AUTH_USERNAME: config.username
+  });
+  await (0, import_promises.writeFile)(
+    studioEnvPath(options.home),
+    serializeEnvironment(updatedEnvironment),
+    { mode: 384 }
+  );
+  await (0, import_promises.chmod)(studioEnvPath(options.home), 384);
+  return config;
+};
+var requireStudioConfig = async (home) => {
+  const config = await readStudioConfig(home);
+  if (!config) {
+    throw new Error(
+      `Kortyx Studio is not initialized at ${home}. Run "kortyx studio start" first.`
+    );
+  }
+  return config;
+};
+
+// src/studio/local-stack.ts
+var composeArgs = (home, args) => [
+  "compose",
+  "--env-file",
+  studioEnvPath(home),
+  "-f",
+  studioComposePath(home),
+  ...args
+];
+var runCompose = async (home, args, runtime, inherit = true) => await runtime.run("docker", composeArgs(home, args), {
+  cwd: home,
+  inherit
+});
+var preflightDocker = async (runtime) => {
+  await runtime.run("docker", ["version", "--format", "{{.Server.Version}}"], {
+    inherit: false
+  });
+  await runtime.run("docker", ["compose", "version", "--short"], {
+    inherit: false
+  });
+};
+var hasRunningServices = async (home, runtime) => {
+  const result = await runCompose(
+    home,
+    ["ps", "--status", "running", "--services"],
+    runtime,
+    false
+  );
+  return result.stdout.trim().length > 0;
+};
+var assertPortsAvailable = async (config, runtime) => {
+  for (const [label, port] of [
+    ["Studio", config.studioPort],
+    ["API", config.apiPort]
+  ]) {
+    if (!await runtime.portAvailable(port)) {
+      throw new Error(
+        `${label} port ${port} is already in use. Choose another with --${label.toLowerCase()}-port ${port + 1}.`
+      );
+    }
+  }
+};
+var printStudioConnection = async (home, config, runtime) => {
+  const environment = await readStudioEnvironment(home);
+  runtime.log();
+  runtime.log("Kortyx Studio connection");
+  runtime.log(`  Studio:  http://localhost:${config.studioPort}`);
+  runtime.log(`  API:     http://localhost:${config.apiPort}`);
+  runtime.log(`  Username: ${environment.KORTYX_STUDIO_BASIC_AUTH_USERNAME}`);
+  runtime.log(`  Password: ${environment.KORTYX_STUDIO_BASIC_AUTH_PASSWORD}`);
+  runtime.log();
+  runtime.log("Add these server-side variables to your Kortyx SDK project:");
+  runtime.log(`  KORTYX_TELEMETRY_API_URL=http://localhost:${config.apiPort}`);
+  runtime.log(
+    `  KORTYX_TELEMETRY_API_KEY=${environment.KORTYX_TELEMETRY_API_KEY}`
+  );
+  runtime.log("  KORTYX_TELEMETRY_ENVIRONMENT=development");
+  runtime.log("  KORTYX_TELEMETRY_SERVICE_NAME=my-agent");
+  runtime.log();
+  runtime.log(`Local state: ${home}`);
+};
+var startStudio = async (options, runtime) => {
+  await preflightDocker(runtime);
+  const config = await ensureStudioState(options, runtime);
+  if (!await hasRunningServices(options.home, runtime)) {
+    await assertPortsAvailable(config, runtime);
+  }
+  runtime.log(
+    "Starting Kortyx Studio. The first image pull can take a few minutes."
+  );
+  await runCompose(
+    options.home,
+    ["up", "-d", "--wait", "--wait-timeout", "180"],
+    runtime
+  );
+  runtime.log("Kortyx Studio is ready.");
+  await printStudioConnection(options.home, config, runtime);
+};
+var stopStudio = async (home, runtime) => {
+  await preflightDocker(runtime);
+  await requireStudioConfig(home);
+  await runCompose(home, ["stop"], runtime);
+  runtime.log(
+    "Kortyx Studio stopped. Local data and credentials were preserved."
+  );
+};
+var restartStudio = async (home, runtime) => {
+  await preflightDocker(runtime);
+  const config = await requireStudioConfig(home);
+  await runCompose(
+    home,
+    ["up", "-d", "--force-recreate", "--wait", "--wait-timeout", "180"],
+    runtime
+  );
+  runtime.log("Kortyx Studio restarted.");
+  await printStudioConnection(home, config, runtime);
+};
+var showStudioStatus = async (home, runtime) => {
+  await preflightDocker(runtime);
+  const config = await requireStudioConfig(home);
+  await runCompose(home, ["ps"], runtime);
+  runtime.log();
+  runtime.log(`Studio: http://localhost:${config.studioPort}`);
+  runtime.log(`API:    http://localhost:${config.apiPort}`);
+  runtime.log(`State:  ${home}`);
+};
+var showStudioLogs = async (home, follow, runtime) => {
+  await preflightDocker(runtime);
+  await requireStudioConfig(home);
+  await runCompose(
+    home,
+    ["logs", ...follow ? ["--follow"] : [], "--tail", "200"],
+    runtime
+  );
+};
+var resetStudio = async (home, confirm, runtime) => {
+  if (!confirm) {
+    throw new Error(
+      'Reset permanently deletes the local Studio database. Re-run with "kortyx studio reset --confirm".'
+    );
+  }
+  await preflightDocker(runtime);
+  await requireStudioConfig(home);
+  await runCompose(home, ["down", "--volumes", "--remove-orphans"], runtime);
+  runtime.log(
+    'Kortyx Studio data was deleted. Credentials were preserved; run "kortyx studio start" to create a fresh database.'
+  );
+};
+
+// src/studio/runtime.ts
+var import_node_crypto = require("crypto");
+var import_node_net = require("net");
+var stringOutput = (value) => typeof value === "string" ? value : "";
+var isCommandNotFound = (error) => error instanceof Error && ("code" in error && error.code === "ENOENT" || error.message.includes("ENOENT"));
+var run = async (command, args, options) => {
+  try {
+    const { execa } = await import("execa");
+    const result = await execa(command, args, {
+      ...options.cwd ? { cwd: options.cwd } : {},
+      stdin: "inherit",
+      stdout: options.inherit ? "inherit" : "pipe",
+      stderr: options.inherit ? "inherit" : "pipe"
+    });
+    return {
+      stdout: stringOutput(result.stdout),
+      stderr: stringOutput(result.stderr)
+    };
+  } catch (error) {
+    if (isCommandNotFound(error)) {
+      throw new Error(
+        `Could not run ${command}. Install and start Docker Desktop, then try again.`,
+        { cause: error }
+      );
+    }
+    throw error;
+  }
+};
+var portAvailable = async (port) => await new Promise((resolvePromise) => {
+  const server = (0, import_node_net.createServer)();
+  server.unref();
+  server.once("error", () => resolvePromise(false));
+  server.listen({ host: "127.0.0.1", port }, () => {
+    server.close(() => resolvePromise(true));
+  });
+});
+var defaultStudioRuntime = {
+  run,
+  portAvailable,
+  now: () => (/* @__PURE__ */ new Date()).toISOString(),
+  random: (bytes) => (0, import_node_crypto.randomBytes)(bytes).toString("base64url"),
+  log: (message = "") => console.log(message)
+};
+
+// src/studio/command.ts
+var portParser = (value) => {
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new import_commander.InvalidArgumentError(
+      "Port must be an integer between 1 and 65535."
+    );
+  }
+  return port;
+};
+var withHome = (command) => command.addOption(
+  new import_commander.Option("--home <path>", "Local Studio state directory.").default(
+    defaultStudioHome()
+  )
+);
+var configureOutput = (command, runtime) => command.configureOutput({
+  writeOut: (output) => runtime.log(output.trimEnd()),
+  writeErr: (output) => runtime.log(output.trimEnd())
+});
+var createStudioCommand = (runtime = defaultStudioRuntime) => {
+  const studio = configureOutput(
+    new import_commander.Command("studio").description("Run and manage Kortyx Studio.").showHelpAfterError().addHelpText(
+      "after",
+      "\nLocal state and generated credentials are stored in ~/.kortyx/studio by default."
+    ),
+    runtime
+  );
+  withHome(
+    studio.command("start").description(
+      "Create or update the local stack and wait until it is healthy."
+    ).option("--studio-port <port>", "Studio host port.", portParser).option("--api-port <port>", "Telemetry API host port.", portParser).option("--image-tag <tag>", "Published Studio image tag.").option("--username <name>", "Local Studio username.").option("--project-name <name>", "Docker Compose project name.")
+  ).action(async (options) => {
+    await startStudio(options, runtime);
+  });
+  withHome(
+    studio.command("stop").description("Stop containers while preserving local data.")
+  ).action(async ({ home }) => {
+    await stopStudio(home, runtime);
+  });
+  withHome(
+    studio.command("restart").description("Recreate the stack and wait until it is healthy.")
+  ).action(async ({ home }) => {
+    await restartStudio(home, runtime);
+  });
+  withHome(
+    studio.command("status").description("Show container health and local endpoints.")
+  ).action(async ({ home }) => {
+    await showStudioStatus(home, runtime);
+  });
+  withHome(
+    studio.command("logs").description("Show API, Studio, bootstrap, and database logs.").option("--no-follow", "Print recent logs without following.")
+  ).action(async ({ home, follow }) => {
+    await showStudioLogs(home, follow, runtime);
+  });
+  withHome(
+    studio.command("credentials").description("Print Studio sign-in and SDK telemetry configuration.")
+  ).action(async ({ home }) => {
+    await printStudioConnection(home, await requireStudioConfig(home), runtime);
+  });
+  withHome(
+    studio.command("reset").description("Delete the local Studio database volume.").option("--confirm", "Confirm permanent deletion.", false)
+  ).action(async ({ home, confirm }) => {
+    await resetStudio(home, confirm, runtime);
+  });
+  return studio;
+};
+
+// src/index.ts
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var isWorkflowDefinition = (value) => isRecord(value) && typeof value.id === "string" && isRecord(value.nodes) && Array.isArray(value.edges);
+var isAgent = (value) => isRecord(value) && typeof value.projectTopology === "function";
+var readPackageName = async (cwd) => {
+  let current = cwd;
+  for (; ; ) {
+    try {
+      const raw = await (0, import_promises2.readFile)((0, import_node_path2.join)(current, "package.json"), "utf8");
+      const parsed = JSON.parse(raw);
+      if (isRecord(parsed) && typeof parsed.name === "string") {
+        return parsed.name;
+      }
+    } catch {
+    }
+    const parent = (0, import_node_path2.dirname)(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
+};
+var loadEnvFiles = async (cwd) => {
+  for (const filename of [".env", ".env.local"]) {
+    const path = (0, import_node_path2.join)(cwd, filename);
+    let raw;
+    try {
+      raw = await (0, import_promises2.readFile)(path, "utf8");
+    } catch {
+      continue;
+    }
+    for (const line of raw.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const separator = trimmed.indexOf("=");
+      if (separator <= 0) continue;
+      const key = trimmed.slice(0, separator).trim();
+      if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
+      if (process.env[key] !== void 0) continue;
+      process.env[key] = unquoteEnvValue(trimmed.slice(separator + 1).trim());
+    }
+  }
+};
+var unquoteEnvValue = (value) => {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+};
+var resolveOptions = async (options) => {
+  if (!options.entry) {
+    throw new Error("Missing required option: --entry <path>.");
+  }
+  const entry = (0, import_node_path2.isAbsolute)(options.entry) ? options.entry : (0, import_node_path2.resolve)(options.cwd, options.entry);
+  const environment = options.environment ?? process.env.KORTYX_TELEMETRY_ENVIRONMENT ?? process.env.NODE_ENV ?? "development";
+  const serviceName = options.serviceName ?? process.env.KORTYX_TELEMETRY_SERVICE_NAME ?? await readPackageName(options.cwd) ?? "kortyx-app";
+  return {
+    ...options,
+    entry,
+    environment,
+    serviceName,
+    apiUrl: options.apiUrl ?? process.env.KORTYX_TELEMETRY_API_URL ?? process.env.KORTYX_API_URL,
+    apiKey: options.apiKey ?? process.env.KORTYX_TELEMETRY_API_KEY,
+    deploymentRef: options.deploymentRef ?? process.env.KORTYX_TELEMETRY_DEPLOYMENT_REF ?? process.env.GITHUB_SHA ?? process.env.VERCEL_GIT_COMMIT_SHA
+  };
+};
+var createFrameworkMarkerStubs = async () => {
+  const root = await (0, import_promises2.mkdtemp)((0, import_node_path2.join)((0, import_node_os2.tmpdir)(), "kortyx-cli-stubs-"));
+  for (const moduleName of ["server-only", "client-only"]) {
+    const directory = (0, import_node_path2.join)(root, moduleName);
+    await (0, import_promises2.mkdir)(directory, { recursive: true });
+    await (0, import_promises2.writeFile)((0, import_node_path2.join)(directory, "index.js"), "", "utf8");
+    await (0, import_promises2.writeFile)(
+      (0, import_node_path2.join)(directory, "package.json"),
+      JSON.stringify({ name: moduleName, version: "0.0.0", main: "index.js" }),
+      "utf8"
+    );
+  }
+  const previousNodePath = process.env.NODE_PATH;
+  process.env.NODE_PATH = previousNodePath ? `${root}${import_node_path2.delimiter}${previousNodePath}` : root;
+  const moduleWithPrivateInit = import_node_module.default;
+  moduleWithPrivateInit._initPaths?.();
+  return {
+    cleanup: async () => {
+      if (previousNodePath === void 0) delete process.env.NODE_PATH;
+      else process.env.NODE_PATH = previousNodePath;
+      moduleWithPrivateInit._initPaths?.();
+      await (0, import_promises2.rm)(root, { recursive: true, force: true });
+    }
+  };
+};
+var importEntry = async (entry) => {
+  const stubs = await createFrameworkMarkerStubs();
+  let unregisterPaths;
+  try {
+    const tsconfig = await findNearestFile((0, import_node_path2.dirname)(entry), "tsconfig.json");
+    unregisterPaths = tsconfig ? await registerTsconfigPaths(tsconfig) : void 0;
+    const module2 = (0, import_api.require)(entry, (0, import_node_path2.join)((0, import_node_path2.dirname)(entry), "kortyx-cli.cjs"));
+    if (!isRecord(module2)) {
+      throw new Error(`Entry module did not export an object: ${entry}`);
+    }
+    return module2;
+  } finally {
+    unregisterPaths?.();
+    await stubs.cleanup();
+  }
+};
+var findNearestFile = async (startDirectory, filename) => {
+  let current = startDirectory;
+  for (; ; ) {
+    const candidate = (0, import_node_path2.join)(current, filename);
+    try {
+      await (0, import_promises2.access)(candidate);
+      return candidate;
+    } catch {
+      const parent = (0, import_node_path2.dirname)(current);
+      if (parent === current) return void 0;
+      current = parent;
+    }
+  }
+};
+var registerTsconfigPaths = async (tsconfigPath) => {
+  const raw = JSON.parse(await (0, import_promises2.readFile)(tsconfigPath, "utf8"));
+  if (!isRecord(raw)) return () => void 0;
+  const compilerOptions = isRecord(raw.compilerOptions) ? raw.compilerOptions : void 0;
+  const paths = isRecord(compilerOptions?.paths) ? compilerOptions.paths : void 0;
+  if (!paths) return () => void 0;
+  const tsconfigDirectory = (0, import_node_path2.dirname)(tsconfigPath);
+  const baseUrl = typeof compilerOptions?.baseUrl === "string" ? (0, import_node_path2.resolve)(tsconfigDirectory, compilerOptions.baseUrl) : tsconfigDirectory;
+  const mappings = Object.entries(paths).flatMap(([pattern, rawTargets]) => {
+    if (!Array.isArray(rawTargets)) return [];
+    return rawTargets.filter((target) => typeof target === "string").map((target) => ({ pattern, target }));
+  }).map(({ pattern, target }) => {
+    const [patternPrefix, patternSuffix = ""] = pattern.split("*");
+    const [targetPrefix, targetSuffix = ""] = target.split("*");
+    return {
+      pattern,
+      target,
+      patternPrefix,
+      patternSuffix,
+      targetPrefix,
+      targetSuffix,
+      wildcard: pattern.includes("*")
+    };
+  });
+  if (mappings.length === 0) return () => void 0;
+  const moduleWithResolver = import_node_module.default;
+  const originalResolve = moduleWithResolver._resolveFilename;
+  moduleWithResolver._resolveFilename = function resolveWithTsconfigPaths(request, parent, isMain, options) {
+    for (const mapping of mappings) {
+      const matched = mapping.wildcard ? request.startsWith(mapping.patternPrefix ?? "") && request.endsWith(mapping.patternSuffix) : request === mapping.pattern;
+      if (!matched) continue;
+      const wildcardValue = mapping.wildcard ? request.slice(
+        mapping.patternPrefix?.length ?? 0,
+        request.length - mapping.patternSuffix.length
+      ) : "";
+      const mapped = mapping.wildcard ? `${mapping.targetPrefix}${wildcardValue}${mapping.targetSuffix}` : mapping.target;
+      for (const candidate of candidateModulePaths((0, import_node_path2.resolve)(baseUrl, mapped))) {
+        try {
+          return originalResolve.call(this, candidate, parent, isMain, options);
+        } catch {
+        }
+      }
+    }
+    return originalResolve.call(this, request, parent, isMain, options);
+  };
+  return () => {
+    moduleWithResolver._resolveFilename = originalResolve;
+  };
+};
+var candidateModulePaths = (basePath) => [
+  basePath,
+  `${basePath}.ts`,
+  `${basePath}.tsx`,
+  `${basePath}.mts`,
+  `${basePath}.cts`,
+  `${basePath}.js`,
+  `${basePath}.jsx`,
+  (0, import_node_path2.join)(basePath, "index.ts"),
+  (0, import_node_path2.join)(basePath, "index.tsx"),
+  (0, import_node_path2.join)(basePath, "index.js"),
+  (0, import_node_path2.join)(basePath, "index.jsx")
+];
+var valueFromModule = (module2, exportName) => {
+  if (exportName) {
+    if (!(exportName in module2)) {
+      throw new Error(`Entry module does not export "${exportName}".`);
+    }
+    return module2[exportName];
+  }
+  if (isAgent(module2.agent)) return module2.agent;
+  if (Array.isArray(module2.workflows)) return module2.workflows;
+  if (isAgent(module2.default)) return module2.default;
+  if (Array.isArray(module2.default)) return module2.default;
+  const workflowExports = Object.values(module2).filter(isWorkflowDefinition);
+  if (workflowExports.length > 0) return workflowExports;
+  throw new Error(
+    "Entry must export an agent with projectTopology(), a workflows array, or named workflow definitions. Use --export when needed."
+  );
+};
+var projectSnapshots = async (value, options) => {
+  if (isAgent(value)) {
+    const snapshots = await value.projectTopology?.(options);
+    return snapshots ?? [];
+  }
+  const workflows = Array.isArray(value) ? value.filter(isWorkflowDefinition) : isWorkflowDefinition(value) ? [value] : [];
+  if (workflows.length === 0) {
+    throw new Error("No workflow definitions found in the selected export.");
+  }
+  const knownWorkflowIds = workflows.map((workflow) => workflow.id);
+  return workflows.map(
+    (workflow) => (0, import_agent.projectWorkflowTopology)({
+      workflow,
+      environment: options.environment,
+      service: options.service,
+      knownWorkflowIds
+    })
+  );
+};
+var endpointFor = (apiUrl, path) => `${apiUrl.replace(/\/$/, "")}${path}`;
+var pushSnapshot = async (apiUrl, apiKey, snapshot) => {
+  const response = await fetch(
+    endpointFor(apiUrl, "/v1/telemetry/workflow-revisions:ensure"),
+    {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${apiKey}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(snapshot)
+    }
+  );
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(
+      `Kortyx API rejected topology ${snapshot.workflow.id} (${response.status}): ${text}`
+    );
+  }
+  return import_telemetry_contracts.EnsureWorkflowTopologyResponseSchema.parse(await response.json());
+};
+var printResults = (results, options) => {
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          workflows: results.map(({ snapshot, response }) => ({
+            workflowId: snapshot.workflow.id,
+            declaredVersion: snapshot.workflow.declaredVersion,
+            topologyHash: snapshot.workflow.topologyHash,
+            transitionCount: snapshot.workflow.transitions?.length ?? 0,
+            workflowRevisionId: response?.workflowRevisionId,
+            created: response?.created
+          }))
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  const verb = options.dryRun ? "Projected" : "Pushed";
+  console.log(`${verb} ${results.length} workflow topology snapshot(s).`);
+  for (const { snapshot, response } of results) {
+    const revision = response ? ` revision=${response.workflowRevisionId} created=${response.created}` : "";
+    console.log(
+      `- ${snapshot.workflow.id}@${snapshot.workflow.declaredVersion} hash=${snapshot.workflow.topologyHash.slice(
+        0,
+        12
+      )} transitions=${snapshot.workflow.transitions?.length ?? 0}${revision}`
+    );
+  }
+};
+var runTopologyPush = async (rawOptions) => {
+  const options = await resolveOptions(rawOptions);
+  if (!options.dryRun && !options.apiUrl) {
+    throw new Error(
+      "Missing Kortyx API URL. Pass --api-url or set KORTYX_TELEMETRY_API_URL."
+    );
+  }
+  if (!options.dryRun && !options.apiKey) {
+    throw new Error(
+      "Missing telemetry API key. Pass --api-key or set KORTYX_TELEMETRY_API_KEY."
+    );
+  }
+  const module2 = await importEntry(options.entry);
+  const selected = valueFromModule(module2, options.exportName);
+  const service = {
+    name: options.serviceName,
+    ...options.deploymentRef ? { deploymentRef: options.deploymentRef } : {}
+  };
+  const snapshots = await projectSnapshots(selected, {
+    environment: options.environment,
+    service
+  });
+  const parsedSnapshots = snapshots.map(
+    (snapshot) => import_telemetry_contracts.EnsureWorkflowTopologyRequestSchema.parse(snapshot)
+  );
+  const results = [];
+  for (const snapshot of parsedSnapshots) {
+    let response;
+    if (!options.dryRun) {
+      if (!options.apiUrl || !options.apiKey) {
+        throw new Error("Missing Kortyx API URL or telemetry API key.");
+      }
+      response = await pushSnapshot(options.apiUrl, options.apiKey, snapshot);
+    }
+    results.push({ snapshot, ...response ? { response } : {} });
+  }
+  printResults(results, options);
+};
+var createCliProgram = () => {
+  const program = new import_commander2.Command().name("kortyx").description("Build, observe, and operate Kortyx projects.").showHelpAfterError().addHelpText(
+    "after",
+    '\nRun "kortyx <command> --help" for detailed command options.'
+  );
+  program.addCommand(createStudioCommand());
+  const topology = program.command("topology").description("Publish deterministic workflow topology to Studio.");
+  topology.command("push").description("Project and publish workflow topology.").requiredOption(
+    "--entry <path>",
+    "Module exporting an agent or workflows array."
+  ).option("--export <name>", "Named export to load from the entry module.").option(
+    "--api-url <url>",
+    "Kortyx API URL. Defaults to KORTYX_TELEMETRY_API_URL."
+  ).option(
+    "--api-key <key>",
+    "Telemetry API key. Defaults to KORTYX_TELEMETRY_API_KEY."
+  ).option("--environment <name>", "Telemetry environment.").option("--service-name <name>", "Telemetry service name.").option("--deployment-ref <ref>", "Deployment reference.").option("--dry-run", "Print topology without publishing.", false).option("--json", "Print machine-readable JSON.", false).action(async (options) => {
+    const cliOptions = {
+      entry: options.entry,
+      exportName: options.export,
+      apiUrl: options.apiUrl,
+      apiKey: options.apiKey,
+      environment: options.environment,
+      serviceName: options.serviceName,
+      deploymentRef: options.deploymentRef,
+      dryRun: options.dryRun ?? false,
+      json: options.json ?? false,
+      cwd: process.cwd()
+    };
+    await loadEnvFiles(cliOptions.cwd);
+    await runTopologyPush(cliOptions);
+  });
+  return program;
+};
+var main = async () => {
+  const program = createCliProgram().exitOverride();
+  if (process.argv.length === 2) {
+    program.outputHelp();
+    return;
+  }
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    if (error instanceof import_commander2.CommanderError && error.exitCode === 0) return;
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+};
+void main();
+//# sourceMappingURL=index.js.map