@truefoundry/trueforge 0.1.4 → 0.2.0-rc.1

package/dist/controller-main.js

@@ -0,0 +1,1259 @@
+// src/config.ts
+import { existsSync } from "fs";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+import envPaths from "env-paths";
+var DEFAULT_PORT = 8790;
+var DEFAULT_HOST = "localhost";
+var DEFAULT_MAX_REQUEST_BODY_BYTES = 30 * 1024 * 1024;
+var PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+var LOCAL_EXECUTOR_ID = "local";
+var ENV_PATHS_APP_NAME = "trueforge";
+var DEFAULT_POSTGRES_USER = "trueforge";
+var DEFAULT_POSTGRES_PASSWORD = "trueforge";
+var DEFAULT_POSTGRES_DB = "trueforge";
+var DEFAULT_POSTGRES_HOST = "localhost";
+var DEFAULT_POSTGRES_PORT = 5432;
+var DEFAULT_REDIS_URL = "redis://localhost:6379";
+var DEFAULT_OIDC_USER_REFERENCE_CLAIM = "sub";
+var DEFAULT_OIDC_USER_DISPLAY_NAME_CLAIM = "name";
+var DEFAULT_OIDC_USER_ROLE_CLAIM = "groups";
+var DEFAULT_OIDC_ADMIN_ROLE_VALUE = "admin";
+var DEFAULT_OIDC_SCOPES = "openid,profile,email";
+function getEnv(key, options) {
+  const value = process.env[key];
+  if (value !== void 0) {
+    return value;
+  }
+  if (options?.defaultValue !== void 0) {
+    return options.defaultValue;
+  }
+  if (options?.required) {
+    throw new Error(`Environment variable ${key} is required but was not specified.`);
+  }
+  return void 0;
+}
+function randomAlphanumeric(length) {
+  return Array.from({ length }, () => Math.floor(Math.random() * 36).toString(36)).join("");
+}
+function parsePort(raw) {
+  if (raw === void 0 || raw.trim() === "") {
+    return DEFAULT_PORT;
+  }
+  const port2 = Number(raw);
+  if (!Number.isInteger(port2) || port2 < 1 || port2 > 65535) {
+    throw new Error(`Environment variable PORT must be an integer between 1 and 65535, got "${raw}"`);
+  }
+  return port2;
+}
+function parseOidcScopes(raw) {
+  const scopes = raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+  if (scopes.length === 0) {
+    throw new Error("OIDC_SCOPES must contain at least one scope.");
+  }
+  return scopes;
+}
+function parseOidcAllowedEmails(raw) {
+  if (raw === void 0 || raw.trim() === "") {
+    return [];
+  }
+  return raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function parsePositiveInt(options) {
+  const { envKey, raw, defaultValue } = options;
+  if (raw === void 0 || raw.trim() === "") {
+    return defaultValue;
+  }
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 1) {
+    throw new Error(`Environment variable ${envKey} must be a positive integer, got "${raw}"`);
+  }
+  return value;
+}
+function parseBoolean(options) {
+  const { envKey, raw, defaultValue } = options;
+  if (raw === void 0 || raw.trim() === "") {
+    return defaultValue;
+  }
+  const value = raw.trim().toLowerCase();
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  throw new Error(`Environment variable ${envKey} must be "true" or "false", got "${raw}"`);
+}
+function parsePostgresSslMode(raw) {
+  if (!raw) {
+    return "";
+  }
+  const mode = raw.trim();
+  if (mode === "") {
+    return "";
+  }
+  switch (mode) {
+    case "disable":
+    case "prefer":
+    case "require":
+    case "verify-ca":
+    case "verify-full":
+    case "no-verify":
+      return mode;
+    default:
+      throw new Error(
+        `Environment variable POSTGRES_SSL_MODE must be one of disable, prefer, require, verify-ca, verify-full, no-verify; got "${mode}"`
+      );
+  }
+}
+function resolveDefaultFrontendDir() {
+  const packaged = path.join(PACKAGE_ROOT, "dist", "_frontend");
+  if (existsSync(path.join(packaged, "index.html"))) {
+    return packaged;
+  }
+  return path.join(PACKAGE_ROOT, "..", "frontend", "dist");
+}
+function resolveFrontendDir() {
+  const override = getEnv("FRONTEND_DIR");
+  if (override !== void 0 && override.trim() !== "") {
+    return path.resolve(override);
+  }
+  return resolveDefaultFrontendDir();
+}
+function resolveOptionalPathEnv(envKey) {
+  const override = getEnv(envKey);
+  if (override === void 0 || override.trim() === "") {
+    return void 0;
+  }
+  return path.resolve(override);
+}
+function resolveSqlitePath(appDataDir2) {
+  const override = getEnv("SQLITE_PATH");
+  if (override !== void 0 && override.trim() !== "") {
+    return path.resolve(override);
+  }
+  return path.join(appDataDir2, "db", "db.sqlite");
+}
+function resolveLocalSandboxRootParent(appDataDir2) {
+  return path.join(appDataDir2, "sandboxes");
+}
+function resolveCodeModeSocketParent() {
+  return path.join(os.tmpdir(), "tf_cms");
+}
+function resolveRedisUrl() {
+  const raw = getEnv("REDIS_URL", { defaultValue: DEFAULT_REDIS_URL }) ?? DEFAULT_REDIS_URL;
+  if (raw.trim() === "") {
+    throw new Error("Environment variable REDIS_URL must be non-empty when STANDALONE=false.");
+  }
+  return raw;
+}
+function resolvePostgresDatabaseUrl() {
+  const databaseUrl = getEnv("DATABASE_URL");
+  if (databaseUrl !== void 0 && databaseUrl.trim() !== "") {
+    return databaseUrl.trim();
+  }
+  const postgresUser = getEnv("POSTGRES_USER", { defaultValue: DEFAULT_POSTGRES_USER }) ?? DEFAULT_POSTGRES_USER;
+  const postgresPassword = getEnv("POSTGRES_PASSWORD", { defaultValue: DEFAULT_POSTGRES_PASSWORD }) ?? DEFAULT_POSTGRES_PASSWORD;
+  const postgresDb = getEnv("POSTGRES_DB", { defaultValue: DEFAULT_POSTGRES_DB }) ?? DEFAULT_POSTGRES_DB;
+  const postgresHost = getEnv("POSTGRES_HOST", { defaultValue: DEFAULT_POSTGRES_HOST }) ?? DEFAULT_POSTGRES_HOST;
+  const postgresPort = parsePositiveInt({
+    envKey: "POSTGRES_PORT",
+    raw: getEnv("POSTGRES_PORT"),
+    defaultValue: DEFAULT_POSTGRES_PORT
+  });
+  const postgresSslMode = parsePostgresSslMode(getEnv("POSTGRES_SSL_MODE"));
+  if (postgresUser.trim() === "" || postgresPassword.trim() === "" || postgresDb.trim() === "" || postgresHost.trim() === "") {
+    throw new Error(
+      "Set DATABASE_URL, or set non-empty POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_DB, and POSTGRES_HOST when STANDALONE=false."
+    );
+  }
+  return buildPostgresConnectionString({
+    user: postgresUser,
+    password: postgresPassword,
+    host: postgresHost,
+    port: postgresPort,
+    database: postgresDb,
+    sslMode: postgresSslMode
+  });
+}
+function buildPostgresConnectionString(parts) {
+  let connectionString = `postgres://${encodeURIComponent(parts.user)}:${encodeURIComponent(parts.password)}@${parts.host}:${String(parts.port)}/${encodeURIComponent(parts.database)}`;
+  if (parts.sslMode !== "") {
+    connectionString += `?sslmode=${encodeURIComponent(parts.sslMode)}`;
+  }
+  return connectionString;
+}
+function resolveOIDCConfig() {
+  const issuerUrl = getEnv("OIDC_ISSUER_URL");
+  const clientId = getEnv("OIDC_CLIENT_ID");
+  const clientSecret = getEnv("OIDC_CLIENT_SECRET");
+  if (!issuerUrl && !clientId && !clientSecret) {
+    return void 0;
+  }
+  if (!issuerUrl || !clientId || !clientSecret) {
+    throw new Error(
+      "OIDC_ISSUER_URL, OIDC_CLIENT_ID, and OIDC_CLIENT_SECRET must all be set together, or all left unset (unset = fixed local admin identity, no IdP)."
+    );
+  }
+  return {
+    OIDC_ISSUER_URL: issuerUrl,
+    OIDC_CLIENT_ID: clientId,
+    OIDC_CLIENT_SECRET: clientSecret,
+    OIDC_USER_REFERENCE_CLAIM: getEnv("OIDC_USER_REFERENCE_CLAIM", { defaultValue: DEFAULT_OIDC_USER_REFERENCE_CLAIM }) ?? DEFAULT_OIDC_USER_REFERENCE_CLAIM,
+    OIDC_USER_DISPLAY_NAME_CLAIM: getEnv("OIDC_USER_DISPLAY_NAME_CLAIM", { defaultValue: DEFAULT_OIDC_USER_DISPLAY_NAME_CLAIM }) ?? DEFAULT_OIDC_USER_DISPLAY_NAME_CLAIM,
+    OIDC_USER_ROLE_CLAIM: getEnv("OIDC_USER_ROLE_CLAIM", { defaultValue: DEFAULT_OIDC_USER_ROLE_CLAIM }) ?? DEFAULT_OIDC_USER_ROLE_CLAIM,
+    OIDC_ADMIN_ROLE_VALUE: getEnv("OIDC_ADMIN_ROLE_VALUE", { defaultValue: DEFAULT_OIDC_ADMIN_ROLE_VALUE }) ?? DEFAULT_OIDC_ADMIN_ROLE_VALUE,
+    OIDC_SCOPES: parseOidcScopes(getEnv("OIDC_SCOPES", { defaultValue: DEFAULT_OIDC_SCOPES }) ?? DEFAULT_OIDC_SCOPES),
+    OIDC_ALLOWED_EMAILS: parseOidcAllowedEmails(getEnv("OIDC_ALLOWED_EMAILS"))
+  };
+}
+var serverExecutionTimeoutSeconds = parsePositiveInt({
+  envKey: "SERVER_EXECUTION_TIMEOUT_SECONDS",
+  raw: getEnv("SERVER_EXECUTION_TIMEOUT_SECONDS"),
+  defaultValue: 600
+});
+var standalone = parseBoolean({
+  envKey: "STANDALONE",
+  raw: getEnv("STANDALONE"),
+  defaultValue: true
+});
+var appDataDirSuffix = getEnv("APP_DATA_DIR_SUFFIX", { defaultValue: "" }) ?? "";
+var appDataDir = envPaths(ENV_PATHS_APP_NAME, { suffix: appDataDirSuffix }).data;
+var port = parsePort(getEnv("PORT"));
+var host = getEnv("HOST", { defaultValue: DEFAULT_HOST }) ?? DEFAULT_HOST;
+var shared = {
+  LOG_LEVEL: getEnv("LOG_LEVEL", { defaultValue: "info" }) ?? "info",
+  ACCESS_LOGS: parseBoolean({ envKey: "ACCESS_LOGS", raw: getEnv("ACCESS_LOGS"), defaultValue: true }),
+  NODE_ENV: getEnv("NODE_ENV"),
+  PORT: port,
+  HOST: host,
+  EXECUTOR_ID: standalone ? LOCAL_EXECUTOR_ID : randomAlphanumeric(6),
+  MODEL_CATALOG_PATH: resolveOptionalPathEnv("MODEL_CATALOG_PATH"),
+  MCP_CATALOG_PATH: resolveOptionalPathEnv("MCP_CATALOG_PATH"),
+  SKILL_CATALOG_PATH: resolveOptionalPathEnv("SKILL_CATALOG_PATH"),
+  SANDBOX_CATALOG_PATH: resolveOptionalPathEnv("SANDBOX_CATALOG_PATH"),
+  FRONTEND_DIR: resolveFrontendDir(),
+  MCP_REQUEST_TIMEOUT_MS: parsePositiveInt({
+    envKey: "MCP_REQUEST_TIMEOUT_MS",
+    raw: getEnv("MCP_REQUEST_TIMEOUT_MS"),
+    defaultValue: 4 * 60 * 1e3
+  }),
+  MCP_CONNECT_TIMEOUT_MS: parsePositiveInt({
+    envKey: "MCP_CONNECT_TIMEOUT_MS",
+    raw: getEnv("MCP_CONNECT_TIMEOUT_MS"),
+    defaultValue: 30 * 1e3
+  }),
+  MCP_DCR_OAUTH_CLIENT_NAME: getEnv("MCP_DCR_OAUTH_CLIENT_NAME", { defaultValue: "truefoundry-harness" }) ?? "truefoundry-harness",
+  SANDBOX_FILE_MAX_BYTES_FOR_DOWNLOAD: parsePositiveInt({
+    envKey: "SANDBOX_FILE_MAX_BYTES_FOR_DOWNLOAD",
+    raw: getEnv("SANDBOX_FILE_MAX_BYTES_FOR_DOWNLOAD"),
+    defaultValue: 20971520
+  }),
+  MAX_REQUEST_BODY_BYTES: parsePositiveInt({
+    envKey: "MAX_REQUEST_BODY_BYTES",
+    raw: getEnv("MAX_REQUEST_BODY_BYTES"),
+    defaultValue: DEFAULT_MAX_REQUEST_BODY_BYTES
+  }),
+  GRACEFUL_TIMEOUT_SECONDS: parsePositiveInt({
+    envKey: "GRACEFUL_TIMEOUT_SECONDS",
+    raw: getEnv("GRACEFUL_TIMEOUT_SECONDS"),
+    defaultValue: 30
+  }),
+  SERVER_EXECUTION_TIMEOUT_SECONDS: serverExecutionTimeoutSeconds,
+  TURN_STREAM_TTL_SECONDS: parsePositiveInt({
+    envKey: "TURN_STREAM_TTL_SECONDS",
+    raw: getEnv("TURN_STREAM_TTL_SECONDS"),
+    defaultValue: serverExecutionTimeoutSeconds + 300
+  }),
+  TURN_STREAM_POST_COMPLETION_TTL_SECONDS: parsePositiveInt({
+    envKey: "TURN_STREAM_POST_COMPLETION_TTL_SECONDS",
+    raw: getEnv("TURN_STREAM_POST_COMPLETION_TTL_SECONDS"),
+    defaultValue: 300
+  }),
+  TURN_SUBSCRIBE_TIMEOUT_MS: parsePositiveInt({
+    envKey: "TURN_SUBSCRIBE_TIMEOUT_MS",
+    raw: getEnv("TURN_SUBSCRIBE_TIMEOUT_MS"),
+    defaultValue: 6e5
+  }),
+  REDIS_REQUEST_REPLY_TIMEOUT_MS: parsePositiveInt({
+    envKey: "REDIS_REQUEST_REPLY_TIMEOUT_MS",
+    raw: getEnv("REDIS_REQUEST_REPLY_TIMEOUT_MS"),
+    defaultValue: 6e4
+  }),
+  REDIS_REQUEST_REPLY_HEARTBEAT_INTERVAL_MS: parsePositiveInt({
+    envKey: "REDIS_REQUEST_REPLY_HEARTBEAT_INTERVAL_MS",
+    raw: getEnv("REDIS_REQUEST_REPLY_HEARTBEAT_INTERVAL_MS"),
+    defaultValue: 5e3
+  }),
+  REDIS_REQUEST_REPLY_REPLY_TTL_MS: parsePositiveInt({
+    envKey: "REDIS_REQUEST_REPLY_REPLY_TTL_MS",
+    raw: getEnv("REDIS_REQUEST_REPLY_REPLY_TTL_MS"),
+    defaultValue: 12e4
+  }),
+  REDIS_REQUEST_REPLY_POLL_INTERVAL_MS: parsePositiveInt({
+    envKey: "REDIS_REQUEST_REPLY_POLL_INTERVAL_MS",
+    raw: getEnv("REDIS_REQUEST_REPLY_POLL_INTERVAL_MS"),
+    defaultValue: 500
+  }),
+  PUBLIC_BASE_URL: getEnv("PUBLIC_BASE_URL", { defaultValue: "" }) ?? "",
+  SERVER_URL: getEnv("SERVER_URL", { defaultValue: `http://localhost:${String(port)}` }) ?? `http://localhost:${String(port)}`,
+  TRUEFORGE_MTLS_ENABLED: parseBoolean({
+    envKey: "TRUEFORGE_MTLS_ENABLED",
+    raw: getEnv("TRUEFORGE_MTLS_ENABLED"),
+    defaultValue: false
+  }),
+  TRUEFORGE_MTLS_CERTS_DIR: getEnv("TRUEFORGE_MTLS_CERTS_DIR", { defaultValue: "/etc/tls" }) ?? "/etc/tls"
+};
+var configuration = standalone ? {
+  ...shared,
+  STANDALONE: true,
+  SQLITE_PATH: resolveSqlitePath(appDataDir),
+  LOCAL_SANDBOX_ROOT_PARENT: resolveLocalSandboxRootParent(appDataDir),
+  CODE_MODE_SOCKET_PARENT: resolveCodeModeSocketParent()
+} : {
+  ...shared,
+  STANDALONE: false,
+  DATABASE_URL: resolvePostgresDatabaseUrl(),
+  DATABASE_POOL_MAX: parsePositiveInt({
+    envKey: "DATABASE_POOL_MAX",
+    raw: getEnv("DATABASE_POOL_MAX"),
+    defaultValue: 10
+  }),
+  POSTGRES_STATEMENT_TIMEOUT_MS: parsePositiveInt({
+    envKey: "POSTGRES_STATEMENT_TIMEOUT_MS",
+    raw: getEnv("POSTGRES_STATEMENT_TIMEOUT_MS"),
+    defaultValue: 6e4
+  }),
+  POSTGRES_IDLE_IN_TRANSACTION_SESSION_TIMEOUT_MS: parsePositiveInt({
+    envKey: "POSTGRES_IDLE_IN_TRANSACTION_SESSION_TIMEOUT_MS",
+    raw: getEnv("POSTGRES_IDLE_IN_TRANSACTION_SESSION_TIMEOUT_MS"),
+    defaultValue: 6e4
+  }),
+  REDIS_URL: resolveRedisUrl(),
+  OIDC: resolveOIDCConfig(),
+  TRUEFOUNDRY_SERVICEFOUNDRY_SERVER_URL: getEnv("TRUEFOUNDRY_SERVICEFOUNDRY_SERVER_URL", { required: false }),
+  TRUEFOUNDRY_SERVICEFOUNDRY_HTTP_TIMEOUT_MS: parsePositiveInt({
+    envKey: "TRUEFOUNDRY_SERVICEFOUNDRY_HTTP_TIMEOUT_MS",
+    raw: getEnv("TRUEFOUNDRY_SERVICEFOUNDRY_HTTP_TIMEOUT_MS"),
+    defaultValue: 1e4
+  }),
+  TRUEFOUNDRY_SERVICEFOUNDRY_HTTP_AGENT_TIMEOUT_MS: parsePositiveInt({
+    envKey: "TRUEFOUNDRY_SERVICEFOUNDRY_HTTP_AGENT_TIMEOUT_MS",
+    raw: getEnv("TRUEFOUNDRY_SERVICEFOUNDRY_HTTP_AGENT_TIMEOUT_MS"),
+    defaultValue: 3e3
+  }),
+  TRUEFOUNDRY_MTLS_ENABLED: parseBoolean({
+    envKey: "TRUEFOUNDRY_MTLS_ENABLED",
+    raw: getEnv("TRUEFOUNDRY_MTLS_ENABLED"),
+    defaultValue: false
+  }),
+  TRUEFOUNDRY_MTLS_CERTS_DIR: getEnv("TRUEFOUNDRY_MTLS_CERTS_DIR", { defaultValue: "/etc/tls/truefoundry" }) ?? "/etc/tls/truefoundry"
+};
+function isOidcConfigured(value) {
+  return !value.STANDALONE && value.OIDC !== void 0;
+}
+function isTrueFoundryModeEnabled(config = configuration) {
+  return !config.STANDALONE && config.TRUEFOUNDRY_SERVICEFOUNDRY_SERVER_URL !== void 0;
+}
+if (isTrueFoundryModeEnabled(configuration) && isOidcConfigured(configuration)) {
+  throw new Error(
+    "TRUEFOUNDRY_SERVICEFOUNDRY_SERVER_URL (TrueFoundry mode) and OIDC (SSO) cannot both be enabled at once."
+  );
+}
+var config_default = configuration;
+
+// src/controller.ts
+import { TrueForge } from "@truefoundry/trueforge-sdk";
+
+// src/controller/Controller.ts
+var CONTROLLER_STOPPED = "controller-stopped";
+var Controller = class {
+  #loops;
+  #logger;
+  #state = /* @__PURE__ */ new Map();
+  #abortController = new AbortController();
+  constructor(params) {
+    const names = /* @__PURE__ */ new Set();
+    for (const loop of params.loops) {
+      if (names.has(loop.name)) {
+        throw new Error(`Duplicate control loop name: ${loop.name}`);
+      }
+      names.add(loop.name);
+    }
+    this.#loops = params.loops;
+    this.#logger = params.logger;
+  }
+  /** Shared abort signal; aborted by {@link stop}. */
+  get signal() {
+    return this.#abortController.signal;
+  }
+  /**
+   * Starts every loop, each with an immediate first pass so a restart does not leave
+   * work waiting a full interval.
+   */
+  start() {
+    if (this.#abortController.signal.aborted || this.#state.size > 0) {
+      return;
+    }
+    for (const loop of this.#loops) {
+      const state = { timer: void 0, pass: void 0 };
+      this.#state.set(loop.name, state);
+      state.timer = setInterval(() => {
+        void this.#tick(loop);
+      }, loop.intervalMs);
+      void this.#tick(loop);
+    }
+    this.#logger.info("Controller started", { loops: this.#loops.map((loop) => loop.name) });
+  }
+  /**
+   * Stops every loop: clears timers, aborts the shared signal, then waits for
+   * in-flight passes to finish. Idempotent.
+   */
+  async stop() {
+    if (this.#abortController.signal.aborted) {
+      return;
+    }
+    this.#abortController.abort(CONTROLLER_STOPPED);
+    const passes = [];
+    for (const state of this.#state.values()) {
+      if (state.timer) {
+        clearInterval(state.timer);
+        state.timer = void 0;
+      }
+      if (state.pass) {
+        passes.push(state.pass);
+      }
+    }
+    await Promise.all(passes);
+    this.#logger.info("Controller stopped");
+  }
+  /**
+   * One pass of one loop: never throws, never overlaps itself.
+   *
+   * A pass that outlives its interval skips the next tick rather than running twice.
+   * Whatever it did not finish is picked up by the following pass — the same path a
+   * restart takes.
+   */
+  async #tick(loop) {
+    const state = this.#state.get(loop.name);
+    const { signal } = this.#abortController;
+    if (!state || signal.aborted || state.pass) {
+      return;
+    }
+    const pass = (async () => {
+      try {
+        await loop.tick(signal);
+      } catch (error) {
+        if (signal.aborted) {
+          return;
+        }
+        this.#logger.error("Control loop pass failed", { loop: loop.name, error });
+      }
+    })();
+    state.pass = pass;
+    try {
+      await pass;
+    } finally {
+      state.pass = void 0;
+    }
+  }
+};
+
+// src/db/scheduleStore.ts
+import { randomUUID } from "crypto";
+
+// src/schemas/schedule.ts
+import { z as z2 } from "@hono/zod-openapi";
+import { CreatedBySubjectSchema, TokenPaginationSchema } from "@truefoundry/trueforge-core/agent-session";
+
+// src/schemas/common.ts
+import { z } from "@hono/zod-openapi";
+var NameSchema = z.string().min(2).max(64).regex(
+  /^[a-z](?:[a-z0-9._-]{0,62}[a-z0-9])$/,
+  'must be 2\u201364 lowercase chars: start with a letter, end with alphanumeric, optionally separated by ".", "_" or "-"'
+).openapi("ResourceName");
+
+// src/schemas/schedule.ts
+var CRON_FIELD = String.raw`[\d*,\-/]+`;
+var InvalidCronError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "InvalidCronError";
+  }
+};
+var CronExpressionSchema = z2.string().trim().regex(
+  new RegExp(`^${CRON_FIELD}(?:\\s+${CRON_FIELD}){4}$`),
+  "must be a 5-field cron expression: minute hour day-of-month month day-of-week"
+).describe("Standard 5-field cron expression, evaluated in `timezone`.").openapi("CronExpression");
+var TimezoneSchema = z2.string().trim().min(1).refine((value) => {
+  try {
+    new Intl.DateTimeFormat(void 0, { timeZone: value });
+    return true;
+  } catch {
+    return false;
+  }
+}, 'must be a valid IANA time zone name, e.g. "America/New_York"').describe("IANA time zone the cron expression is evaluated in.").openapi("Timezone");
+var IsoTimestamp = z2.iso.datetime().openapi({ type: "string", format: "date-time" });
+var NullableIsoTimestamp = z2.iso.datetime().nullable().openapi({ type: ["string", "null"], format: "date-time" });
+var ScheduleTaskSchema = z2.string().trim().min(1).describe("First user message sent to the agent on every run.");
+var ScheduleStatusSchema = z2.enum(["active", "paused"]).openapi("ScheduleStatus");
+var ScheduleManifestObjectSchema = z2.object({
+  task: ScheduleTaskSchema,
+  cron: CronExpressionSchema,
+  timezone: TimezoneSchema.default("UTC"),
+  status: ScheduleStatusSchema.default("active")
+}).strict();
+var ScheduleManifestSchema = ScheduleManifestObjectSchema.openapi("ScheduleManifest");
+var ScheduleSchema = z2.object({
+  id: z2.string(),
+  agent_name: NameSchema,
+  name: NameSchema,
+  manifest: ScheduleManifestSchema,
+  created_by_subject: CreatedBySubjectSchema,
+  created_at: IsoTimestamp,
+  updated_at: IsoTimestamp
+}).strict().openapi("Schedule");
+var CreateScheduleRequestSchema = z2.object({
+  agent_name: NameSchema,
+  name: NameSchema,
+  manifest: ScheduleManifestSchema
+}).strict().openapi("CreateScheduleRequest");
+var UpdateScheduleRequestSchema = z2.object({
+  name: NameSchema,
+  manifest: ScheduleManifestSchema
+}).strict().openapi("UpdateScheduleRequest");
+var GetScheduleResponseSchema = z2.object({ data: ScheduleSchema }).openapi("GetScheduleResponse");
+var ListSchedulesResponseSchema = z2.object({
+  data: z2.array(ScheduleSchema),
+  pagination: TokenPaginationSchema
+}).openapi("ListSchedulesResponse");
+var DeleteScheduleResponseSchema = z2.object({}).openapi("DeleteScheduleResponse");
+var ScheduleRunStatusSchema = z2.enum(["scheduled", "triggered", "failed"]).openapi("ScheduleRunStatus");
+var ScheduleRunSchema = z2.object({
+  id: z2.string(),
+  schedule_id: z2.string(),
+  name: z2.string(),
+  scheduled_for: IsoTimestamp,
+  status: ScheduleRunStatusSchema,
+  created_by_subject: CreatedBySubjectSchema,
+  triggered_at: NullableIsoTimestamp,
+  created_at: IsoTimestamp,
+  updated_at: IsoTimestamp
+}).strict().openapi("ScheduleRun");
+var ListScheduleRunsResponseSchema = z2.object({ data: z2.array(ScheduleRunSchema) }).openapi("ListScheduleRunsResponse");
+var CreateScheduleRunRequestSchema = z2.object({
+  schedule_id: z2.string().min(1).max(64).describe("Immutable schedule identifier.")
+}).strict().describe("Trigger an immediate run for the given schedule. The task is taken from the schedule manifest.").openapi("CreateScheduleRunRequest");
+var CreateScheduleRunResponseSchema = z2.object({ data: ScheduleRunSchema }).openapi("CreateScheduleRunResponse");
+
+// src/db/scheduleStore.ts
+function cronRunName(scheduledFor) {
+  return `sched-${String(Math.floor(scheduledFor.getTime() / 1e3))}`;
+}
+function parseStoredScheduleManifest(manifest) {
+  return ScheduleManifestSchema.parse(manifest);
+}
+var ScheduleRunConflictError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ScheduleRunConflictError";
+  }
+};
+var ScheduleNameConflictError = class extends Error {
+  tenant_id;
+  agent_name;
+  schedule_name;
+  constructor({ tenant_id, agent_name, name }, options) {
+    super(`Schedule name already exists for agent ${agent_name}: ${name}`, options);
+    this.name = "ScheduleNameConflictError";
+    this.tenant_id = tenant_id;
+    this.agent_name = agent_name;
+    this.schedule_name = name;
+  }
+};
+function shouldSyncPendingRun(previous, next) {
+  return previous.status !== next.status || previous.manifest.cron !== next.manifest.cron || previous.manifest.timezone !== next.manifest.timezone;
+}
+
+// src/runtime/cron.ts
+import { CronExpressionParser } from "cron-parser";
+function nextTriggerAfter(input) {
+  const { cron, timezone, from } = input;
+  try {
+    const interval = CronExpressionParser.parse(cron, {
+      currentDate: from,
+      tz: timezone
+    });
+    return interval.next().toDate();
+  } catch (error) {
+    throw new InvalidCronError(`Cron expression "${cron}" has no next trigger time in ${timezone}`, { cause: error });
+  }
+}
+
+// src/controller/scheduleDispatch.ts
+var DISPATCH_BATCH_LIMIT = 20;
+var SCHEDULE_DISPATCH_INTERVAL_MS = 6e4;
+var SCHEDULE_DISPATCH_LOOP_NAME = "schedule-dispatch";
+function executeScheduledRun(client) {
+  return async ({ run, schedule }) => {
+    const { data: session } = await client.internal.sessions.getOrCreateByExternalId({
+      externalId: run.id,
+      agent: { name: schedule.agent_name }
+    });
+    const turns = await client.sessions.listTurns(session.id, { limit: 1 });
+    if (turns.data.length > 0) {
+      return;
+    }
+    await client.sessions.createTurn(session.id, {
+      input: [{ type: "user.message", content: schedule.manifest.task }],
+      previousTurnId: "none"
+    });
+  };
+}
+async function finishScheduledRun(params) {
+  const { store, withTransaction, run, status, now: now2 } = params;
+  await withTransaction(async (txn) => {
+    const latest = await store.getScheduleForUpdate({ tenant_id: run.tenant_id, id: run.schedule_id }, txn);
+    const updated = await store.updateRunStatus({ tenant_id: run.tenant_id, id: run.id, status }, txn);
+    if (updated === void 0) {
+      return;
+    }
+    if (latest?.status !== "active") {
+      return;
+    }
+    const advanceFrom = new Date(Math.max(Date.parse(run.scheduled_for), now2.getTime()));
+    let nextTrigger;
+    try {
+      nextTrigger = nextTriggerAfter({
+        cron: latest.manifest.cron,
+        timezone: latest.manifest.timezone,
+        from: advanceFrom
+      });
+    } catch (error) {
+      if (!(error instanceof InvalidCronError)) {
+        throw error;
+      }
+      return;
+    }
+    await store.createRun(
+      {
+        tenant_id: latest.tenant_id,
+        schedule_id: latest.id,
+        name: cronRunName(nextTrigger),
+        scheduled_for: nextTrigger,
+        status: "scheduled",
+        created_by_subject: latest.created_by_subject
+      },
+      txn
+    );
+  });
+}
+async function dispatchScheduledRuns(params) {
+  const { store, withTransaction, onTriggered, logger, signal } = params;
+  const now2 = /* @__PURE__ */ new Date();
+  const scheduled = await store.listScheduledRuns({ limit: DISPATCH_BATCH_LIMIT, until: now2 });
+  let dispatched = 0;
+  let failed = 0;
+  for (const run of scheduled) {
+    if (signal?.aborted) {
+      break;
+    }
+    try {
+      const schedule = await store.getSchedule({
+        tenant_id: run.tenant_id,
+        id: run.schedule_id
+      });
+      if (schedule === void 0) {
+        continue;
+      }
+      try {
+        await onTriggered({ run, schedule });
+      } catch (error) {
+        logger.error("Failed to hand off triggered run", {
+          schedule_id: schedule.id,
+          run_id: run.id,
+          error
+        });
+        await finishScheduledRun({
+          store,
+          run,
+          now: now2,
+          status: "failed",
+          withTransaction
+        });
+        failed += 1;
+        continue;
+      }
+      await finishScheduledRun({
+        store,
+        run,
+        now: now2,
+        status: "triggered",
+        withTransaction
+      });
+      dispatched += 1;
+    } catch (error) {
+      logger.error("Failed to process scheduled run", {
+        schedule_id: run.schedule_id,
+        run_id: run.id,
+        error
+      });
+    }
+  }
+  return { dispatched, failed };
+}
+function scheduleDispatchLoop(params) {
+  const { scheduleStore, client, withTransaction, logger } = params;
+  return {
+    name: SCHEDULE_DISPATCH_LOOP_NAME,
+    intervalMs: SCHEDULE_DISPATCH_INTERVAL_MS,
+    async tick(signal) {
+      const result = await dispatchScheduledRuns({
+        store: scheduleStore,
+        onTriggered: executeScheduledRun(client),
+        logger,
+        withTransaction,
+        signal
+      });
+      if (result.dispatched > 0 || result.failed > 0) {
+        logger.debug("Scheduled runs dispatched or failed", result);
+      }
+    }
+  };
+}
+
+// src/http/tls.ts
+import { readFileSync } from "fs";
+import { createServer as createHttpsServer } from "https";
+import { join } from "path";
+import { rootCertificates, TLSSocket } from "tls";
+import { Agent, fetch as undiciFetch } from "undici";
+var TLS_CERT_FILE = "tls.crt";
+var TLS_KEY_FILE = "tls.key";
+var TLS_CA_FILE = "ca.crt";
+function readTlsFile(input) {
+  const filePath = join(input.dir, input.fileName);
+  try {
+    return readFileSync(filePath, "utf8");
+  } catch (error) {
+    throw new Error(
+      `${input.enabledEnvKey} is true but ${filePath} could not be read. Check that the mTLS secret is mounted at the configured certs directory, or set ${input.enabledEnvKey}=false.`,
+      { cause: error }
+    );
+  }
+}
+function normalizeTlsUrl(input) {
+  if (!input.enabled) {
+    return input.url;
+  }
+  const parsed = new URL(input.url);
+  if (parsed.protocol === "http:") {
+    parsed.protocol = "https:";
+  }
+  return parsed.href;
+}
+function createTlsDispatcher(options) {
+  if (!options.enabled) {
+    return void 0;
+  }
+  const read = (fileName) => readTlsFile({ dir: options.dir, fileName, enabledEnvKey: options.enabledEnvKey });
+  return new Agent({
+    connect: {
+      // Appended to the default roots, not replacing them: passing `ca` alone would override Node's
+      // entire trust store for this dispatcher (breaks public HTTPS peers on the same agent).
+      ca: [...rootCertificates, read(TLS_CA_FILE)],
+      cert: read(TLS_CERT_FILE),
+      key: read(TLS_KEY_FILE)
+    }
+  });
+}
+function requestUrlFromFetchInput(input) {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (input instanceof URL) {
+    return input.href;
+  }
+  return input.url;
+}
+function createTlsFetch(options) {
+  const dispatcher = createTlsDispatcher({
+    ...options,
+    enabledEnvKey: "TRUEFORGE_MTLS_ENABLED"
+  });
+  if (dispatcher === void 0) {
+    return void 0;
+  }
+  return (input, init) => undiciFetch(requestUrlFromFetchInput(input), { ...init, dispatcher });
+}
+
+// src/controller.ts
+function createScheduleApiClient(params) {
+  const baseUrl = normalizeTlsUrl({ url: params.baseUrl, enabled: params.tls.enabled });
+  const fetchImpl = createTlsFetch(params.tls);
+  return new TrueForge({
+    baseUrl,
+    auth: false,
+    ...fetchImpl !== void 0 ? { fetch: fetchImpl } : {}
+  });
+}
+function createController(params) {
+  const { scheduleStore, withTransaction, logger, baseUrl } = params;
+  const tls = params.tls ?? { enabled: false, dir: "" };
+  return new Controller({
+    loops: [
+      scheduleDispatchLoop({
+        scheduleStore,
+        client: createScheduleApiClient({ baseUrl, tls }),
+        withTransaction,
+        logger
+      })
+    ],
+    logger
+  });
+}
+function runController(params) {
+  const { logger, gracefulTimeoutSeconds, onStopped } = params;
+  const controller = createController(params);
+  controller.start();
+  let shuttingDown = false;
+  const shutdown = async (signal) => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    logger.info(`Received ${signal}, stopping control loops`);
+    setTimeout(() => {
+      logger.warn(`Controller drain timed out after ${String(gracefulTimeoutSeconds)}s, exiting`);
+      process.exit(1);
+    }, gracefulTimeoutSeconds * 1e3).unref();
+    await controller.stop();
+    await onStopped?.();
+    process.exit(0);
+  };
+  process.on("SIGTERM", (signal) => {
+    void shutdown(signal);
+  });
+  process.on("SIGINT", (signal) => {
+    void shutdown(signal);
+  });
+  return controller;
+}
+
+// src/db/postgres/client.ts
+import { Kysely, PostgresDialect } from "kysely";
+import pg, { Pool } from "pg";
+
+// src/db/postgres/schema.ts
+import { sql } from "kysely";
+var TRUEFORGE_SCHEMA = "trueforge";
+
+// src/db/postgres/client.ts
+var INT8_OID = 20;
+var setTypeParserByOid = pg.types.setTypeParser.bind(
+  pg.types
+);
+function parseInt8Array(value) {
+  if (value === "{}" || value === "") {
+    return [];
+  }
+  return value.slice(1, -1).split(",").map((element) => Number(element));
+}
+function configurePgTypeParsers() {
+  pg.types.setTypeParser(INT8_OID, Number);
+  setTypeParserByOid(1016, parseInt8Array);
+}
+function createDb(options) {
+  const { connectionString, poolMax, statementTimeoutMs, idleInTransactionSessionTimeoutMs } = options;
+  configurePgTypeParsers();
+  return new Kysely({
+    dialect: new PostgresDialect({
+      pool: new Pool({
+        connectionString,
+        max: poolMax,
+        statement_timeout: statementTimeoutMs,
+        idle_in_transaction_session_timeout: idleInTransactionSessionTimeoutMs,
+        options: `-c search_path=${TRUEFORGE_SCHEMA}`
+      })
+    })
+  });
+}
+function isPgErrorCode(err, code) {
+  if (typeof err !== "object" || err === null || !("code" in err)) {
+    return false;
+  }
+  return err.code === code;
+}
+function isUniqueViolation(err) {
+  return isPgErrorCode(err, "23505");
+}
+
+// src/db/postgres/schedule-store/PostgresScheduleStore.ts
+import {
+  decodeOffsetPageToken,
+  paginateOffsetRows
+} from "@truefoundry/trueforge-core/agent-session/store/OffsetPageToken";
+
+// src/utils/id.ts
+import { ulid } from "ulid";
+function newId() {
+  return ulid().toLowerCase();
+}
+
+// src/db/createdBySubject.ts
+import { CreatedBySubjectSchema as CreatedBySubjectSchema2 } from "@truefoundry/trueforge-core/agent-session";
+function parseStoredCreatedBySubject(value) {
+  return CreatedBySubjectSchema2.parse(value);
+}
+
+// src/db/postgres/sqlExpressions.ts
+import { sql as sql2 } from "kysely";
+function json(value) {
+  return sql2`${JSON.stringify(value)}::jsonb`;
+}
+function now() {
+  return sql2`now()`;
+}
+function whereCreatedByOrAgentIds(query, filter) {
+  if (filter === void 0) {
+    return query;
+  }
+  if (filter.agent_ids.length === 0) {
+    return query.where(sql2`created_by_subject->>'subject_id'`, "=", filter.created_by_subject_id);
+  }
+  return query.where(
+    (eb) => eb.or([
+      eb(sql2`created_by_subject->>'subject_id'`, "=", filter.created_by_subject_id),
+      eb(sql2`agent_id`, "in", [...filter.agent_ids])
+    ])
+  );
+}
+
+// src/db/postgres/schedule-store/PostgresScheduleStore.ts
+function toScheduleRecord(row) {
+  return {
+    id: row.id,
+    tenant_id: row.tenant_id,
+    agent_id: row.agent_id,
+    agent_name: row.agent_name,
+    name: row.name,
+    manifest: parseStoredScheduleManifest(row.manifest),
+    status: row.status,
+    created_by_subject: parseStoredCreatedBySubject(row.created_by_subject),
+    created_at: row.created_at.toISOString(),
+    updated_at: row.updated_at.toISOString()
+  };
+}
+function toRunRecord(row) {
+  return {
+    id: row.id,
+    tenant_id: row.tenant_id,
+    schedule_id: row.schedule_id,
+    name: row.name,
+    scheduled_for: row.scheduled_for.toISOString(),
+    status: row.status,
+    created_by_subject: parseStoredCreatedBySubject(row.created_by_subject),
+    triggered_at: row.triggered_at === null ? null : row.triggered_at.toISOString(),
+    created_at: row.created_at.toISOString(),
+    updated_at: row.updated_at.toISOString()
+  };
+}
+var PostgresScheduleStore = class {
+  #db;
+  constructor(db) {
+    this.#db = db;
+  }
+  async #syncPendingRun(schedule, from, transaction) {
+    const db = transaction ?? this.#db;
+    await db.deleteFrom("schedule_run").where("tenant_id", "=", schedule.tenant_id).where("schedule_id", "=", schedule.id).where("status", "=", "scheduled").execute();
+    if (schedule.status !== "active") {
+      return void 0;
+    }
+    const nextTrigger = nextTriggerAfter({
+      cron: schedule.manifest.cron,
+      timezone: schedule.manifest.timezone,
+      from
+    });
+    return this.createRun(
+      {
+        tenant_id: schedule.tenant_id,
+        schedule_id: schedule.id,
+        name: cronRunName(nextTrigger),
+        scheduled_for: nextTrigger,
+        status: "scheduled",
+        created_by_subject: schedule.created_by_subject
+      },
+      transaction
+    );
+  }
+  async getSchedule(input, transaction) {
+    const db = transaction ?? this.#db;
+    const row = await db.selectFrom("schedule").selectAll().where("tenant_id", "=", input.tenant_id).where("id", "=", input.id).executeTakeFirst();
+    return row === void 0 ? void 0 : toScheduleRecord(row);
+  }
+  async getScheduleForUpdate(input, transaction) {
+    const row = await transaction.selectFrom("schedule").selectAll().where("tenant_id", "=", input.tenant_id).where("id", "=", input.id).forUpdate().executeTakeFirst();
+    return row === void 0 ? void 0 : toScheduleRecord(row);
+  }
+  async createScheduleAndRun(input, transaction) {
+    const db = transaction ?? this.#db;
+    let row;
+    try {
+      row = await db.insertInto("schedule").values({
+        id: newId(),
+        tenant_id: input.tenant_id,
+        agent_id: input.agent_id,
+        agent_name: input.agent_name,
+        name: input.name,
+        manifest: json(input.manifest),
+        // Column mirrors the manifest so the dispatch scan and API reads share one value.
+        status: input.manifest.status,
+        created_by_subject: json(input.created_by_subject),
+        created_at: now(),
+        updated_at: now()
+      }).returningAll().executeTakeFirstOrThrow();
+    } catch (error) {
+      if (isUniqueViolation(error)) {
+        throw new ScheduleNameConflictError(
+          { tenant_id: input.tenant_id, agent_name: input.agent_name, name: input.name },
+          { cause: error }
+        );
+      }
+      throw error;
+    }
+    const schedule = toScheduleRecord(row);
+    const pendingRun = await this.#syncPendingRun(schedule, input.runFrom, transaction);
+    return { schedule, pendingRun };
+  }
+  async updateScheduleAndRun(input, transaction) {
+    const previous = transaction !== void 0 ? await this.getScheduleForUpdate({ tenant_id: input.tenant_id, id: input.id }, transaction) : await this.getSchedule({ tenant_id: input.tenant_id, id: input.id });
+    if (previous === void 0) {
+      return void 0;
+    }
+    const db = transaction ?? this.#db;
+    let row;
+    try {
+      row = await db.updateTable("schedule").set({ name: input.name, manifest: json(input.manifest), status: input.manifest.status, updated_at: now() }).where("tenant_id", "=", input.tenant_id).where("id", "=", input.id).returningAll().executeTakeFirst();
+    } catch (error) {
+      if (isUniqueViolation(error)) {
+        throw new ScheduleNameConflictError(
+          { tenant_id: input.tenant_id, agent_name: previous.agent_name, name: input.name },
+          { cause: error }
+        );
+      }
+      throw error;
+    }
+    if (row === void 0) {
+      return void 0;
+    }
+    const schedule = toScheduleRecord(row);
+    if (!shouldSyncPendingRun(previous, schedule)) {
+      const pendingRun2 = await this.getScheduledRunFor(
+        { tenant_id: schedule.tenant_id, schedule_id: schedule.id },
+        transaction
+      );
+      return { schedule, pendingRun: pendingRun2 };
+    }
+    const pendingRun = await this.#syncPendingRun(schedule, input.runFrom, transaction);
+    return { schedule, pendingRun };
+  }
+  async deleteSchedule(input, transaction) {
+    const db = transaction ?? this.#db;
+    await db.deleteFrom("schedule").where("tenant_id", "=", input.tenant_id).where("id", "=", input.id).execute();
+  }
+  async listSchedules(input, transaction) {
+    const offset = decodeOffsetPageToken(input.page_token);
+    const db = transaction ?? this.#db;
+    let query = db.selectFrom("schedule").selectAll().where("tenant_id", "=", input.tenant_id);
+    if (input.agent_names !== void 0) {
+      query = query.where("agent_name", "in", [...input.agent_names]);
+    }
+    query = whereCreatedByOrAgentIds(query, input.created_by_or_agent_ids);
+    const rows = await query.orderBy("created_at", "desc").orderBy("id").limit(input.limit + 1).offset(offset).execute();
+    const { data, pagination } = paginateOffsetRows(rows, input.limit, offset);
+    return { data: data.map(toScheduleRecord), pagination };
+  }
+  async listRuns(input, transaction) {
+    const db = transaction ?? this.#db;
+    const rows = await db.selectFrom("schedule_run").selectAll().where("tenant_id", "=", input.tenant_id).where("schedule_id", "=", input.schedule_id).orderBy("scheduled_for", "desc").orderBy("id").execute();
+    return rows.map(toRunRecord);
+  }
+  async getRun(input, transaction) {
+    const db = transaction ?? this.#db;
+    const row = await db.selectFrom("schedule_run").selectAll().where("tenant_id", "=", input.tenant_id).where("id", "=", input.id).executeTakeFirst();
+    return row === void 0 ? void 0 : toRunRecord(row);
+  }
+  async getScheduledRunFor(input, transaction) {
+    const db = transaction ?? this.#db;
+    const row = await db.selectFrom("schedule_run").selectAll().where("tenant_id", "=", input.tenant_id).where("schedule_id", "=", input.schedule_id).where("status", "=", "scheduled").executeTakeFirst();
+    return row === void 0 ? void 0 : toRunRecord(row);
+  }
+  async createRun(input, transaction) {
+    const db = transaction ?? this.#db;
+    try {
+      const row = await db.insertInto("schedule_run").values({
+        id: newId(),
+        tenant_id: input.tenant_id,
+        schedule_id: input.schedule_id,
+        name: input.name,
+        scheduled_for: input.scheduled_for,
+        status: input.status,
+        created_by_subject: json(input.created_by_subject),
+        triggered_at: input.triggered_at ?? null,
+        created_at: now(),
+        updated_at: now()
+      }).returningAll().executeTakeFirstOrThrow();
+      return toRunRecord(row);
+    } catch (error) {
+      if (isUniqueViolation(error)) {
+        throw new ScheduleRunConflictError(`Schedule run already exists: ${input.name}`, { cause: error });
+      }
+      throw error;
+    }
+  }
+  async updateRunStatus(input, transaction) {
+    const db = transaction ?? this.#db;
+    const patch = input.status === "triggered" ? { status: input.status, triggered_at: now(), updated_at: now() } : { status: input.status, updated_at: now() };
+    const row = await db.updateTable("schedule_run").set(patch).where("tenant_id", "=", input.tenant_id).where("id", "=", input.id).returningAll().executeTakeFirst();
+    return row === void 0 ? void 0 : toRunRecord(row);
+  }
+  async listScheduledRuns(input, transaction) {
+    const db = transaction ?? this.#db;
+    const rows = await db.selectFrom("schedule_run").selectAll().where("status", "=", "scheduled").where("scheduled_for", "<=", input.until).orderBy("scheduled_for").limit(input.limit).execute();
+    return rows.map(toRunRecord);
+  }
+};
+
+// src/logger.ts
+import winston from "winston";
+var STANDALONE_META_SKIP = /* @__PURE__ */ new Set(["level", "message", "timestamp", "version", "component", "stack", "splat"]);
+function shouldColorize() {
+  const noColor = process.env["NO_COLOR"];
+  if (noColor !== void 0 && noColor !== "") {
+    return false;
+  }
+  const forceColor = process.env["FORCE_COLOR"];
+  if (forceColor === "0") {
+    return false;
+  }
+  if (forceColor !== void 0 && forceColor !== "") {
+    return true;
+  }
+  return process.stderr.isTTY;
+}
+function standaloneMeta(info) {
+  const copied = { ...info };
+  const meta = {};
+  for (const key of Object.keys(copied)) {
+    if (STANDALONE_META_SKIP.has(key)) {
+      continue;
+    }
+    meta[key] = copied[key];
+  }
+  if (Object.keys(meta).length === 0) {
+    return "";
+  }
+  return ` ${JSON.stringify(meta)}`;
+}
+function standaloneFormat(color) {
+  const parts = [
+    winston.format.timestamp({ format: "HH:mm:ss" }),
+    winston.format.errors({ stack: true })
+  ];
+  if (color) {
+    parts.push(winston.format.colorize({ level: true }));
+  }
+  parts.push(
+    winston.format.printf((info) => {
+      const extra = standaloneMeta(info);
+      const stack = typeof info["stack"] === "string" ? `
+${info["stack"]}` : "";
+      return `${String(info["timestamp"])} ${info.level} ${String(info.message)}${extra}${stack}`;
+    })
+  );
+  return winston.format.combine(...parts);
+}
+function jsonFormat() {
+  return winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.errors({ stack: true }),
+    winston.format.json()
+  );
+}
+function serverLogFormat(options) {
+  if (options.standalone) {
+    return standaloneFormat(shouldColorize());
+  }
+  return jsonFormat();
+}
+function createLogger(options) {
+  return winston.createLogger({
+    level: options.level,
+    defaultMeta: { version: options.version, component: options.component },
+    format: serverLogFormat({ standalone: options.standalone }),
+    transports: [new winston.transports.Console()]
+  });
+}
+function createControllerLogger(options) {
+  return createLogger({ ...options, component: "controller" });
+}
+
+// src/packageVersion.ts
+import { readFileSync as readFileSync2 } from "fs";
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var PACKAGE_ROOT2 = path2.resolve(path2.dirname(fileURLToPath2(import.meta.url)), "..");
+function readPackageVersion() {
+  const packageJsonPath = path2.join(PACKAGE_ROOT2, "package.json");
+  const parsed = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+  if (typeof parsed !== "object" || parsed === null || !("version" in parsed)) {
+    throw new Error(`${packageJsonPath} is missing a version field`);
+  }
+  const { version } = parsed;
+  if (typeof version !== "string" || version.length === 0) {
+    throw new Error(`${packageJsonPath} version must be a non-empty string`);
+  }
+  return version;
+}
+var PACKAGE_VERSION = readPackageVersion();
+
+// src/controller-main.ts
+try {
+  const logger = createControllerLogger({
+    level: config_default.LOG_LEVEL,
+    standalone: config_default.STANDALONE,
+    version: PACKAGE_VERSION
+  });
+  if (config_default.STANDALONE) {
+    logger.warn("Standalone mode (STANDALONE=true): the server runs the controller in-process; nothing to do here.");
+    process.exit(0);
+  }
+  const db = createDb({
+    connectionString: config_default.DATABASE_URL,
+    poolMax: config_default.DATABASE_POOL_MAX,
+    statementTimeoutMs: config_default.POSTGRES_STATEMENT_TIMEOUT_MS,
+    idleInTransactionSessionTimeoutMs: config_default.POSTGRES_IDLE_IN_TRANSACTION_SESSION_TIMEOUT_MS
+  });
+  const mtls = {
+    enabled: config_default.TRUEFORGE_MTLS_ENABLED,
+    dir: config_default.TRUEFORGE_MTLS_CERTS_DIR
+  };
+  logger.info("Controller starting", {
+    serverUrl: config_default.SERVER_URL,
+    mTlsEnabled: mtls.enabled
+  });
+  runController({
+    scheduleStore: new PostgresScheduleStore(db),
+    withTransaction: (callback) => db.transaction().execute(callback),
+    logger,
+    baseUrl: config_default.SERVER_URL,
+    tls: mtls,
+    gracefulTimeoutSeconds: config_default.GRACEFUL_TIMEOUT_SECONDS,
+    onStopped: () => db.destroy()
+  });
+} catch (error) {
+  console.error("Failed to start controller:", error instanceof Error ? error.message : error);
+  process.exit(1);
+}
+//# sourceMappingURL=controller-main.js.map