aegra-hono 0.11.0

package/dist/cli.js

@@ -0,0 +1,714 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/config/settings.ts
+import { z } from "zod";
+var booleanFromEnv, positiveIntFromEnv = (fallback) => z.coerce.number().int().positive().default(fallback), environmentSchema, raw, settings;
+var init_settings = __esm(() => {
+  booleanFromEnv = z.stringbool().default(false);
+  environmentSchema = z.object({
+    PROJECT_NAME: z.string().default("Aegra"),
+    VERSION: z.string().default("0.11.0"),
+    ENV_MODE: z.string().default("PRODUCTION"),
+    LOG_VERBOSITY: z.string().default("verbose"),
+    LOG_EXCLUDE_PATHS: z.string().default(""),
+    HOST: z.string().default("0.0.0.0"),
+    PORT: z.coerce.number().int().min(1).max(65535).default(2026),
+    AEGRA_CONFIG: z.string().default("aegra.json"),
+    RUN_MIGRATIONS_ON_STARTUP: z.stringbool().default(true),
+    DATABASE_URL: z.string().optional(),
+    POSTGRES_USER: z.string().default("postgres"),
+    POSTGRES_PASSWORD: z.string().default("postgres"),
+    POSTGRES_HOST: z.string().default("localhost"),
+    POSTGRES_PORT: z.coerce.number().int().min(1).max(65535).default(5432),
+    POSTGRES_DB: z.string().default("aegra"),
+    REDIS_BROKER_ENABLED: booleanFromEnv,
+    REDIS_URL: z.string().default("redis://localhost:6379/0"),
+    WORKER_COUNT: positiveIntFromEnv(3),
+    N_JOBS_PER_WORKER: positiveIntFromEnv(10),
+    WORKER_QUEUE_KEY: z.string().default("aegra:jobs"),
+    BG_JOB_TIMEOUT_SECS: positiveIntFromEnv(3600),
+    BG_JOB_MAX_RETRIES: z.coerce.number().int().nonnegative().default(3),
+    WORKER_DRAIN_TIMEOUT: z.coerce.number().nonnegative().default(30),
+    STUCK_PENDING_THRESHOLD_SECONDS: positiveIntFromEnv(120),
+    LEASE_DURATION_SECONDS: positiveIntFromEnv(30),
+    HEARTBEAT_INTERVAL_SECONDS: positiveIntFromEnv(10),
+    REAPER_INTERVAL_SECONDS: positiveIntFromEnv(15),
+    POSTGRES_POLL_INTERVAL_SECONDS: positiveIntFromEnv(5),
+    KEEPALIVE_INTERVAL_SECS: positiveIntFromEnv(5),
+    CRON_ENABLED: z.stringbool().default(true),
+    CRON_POLL_INTERVAL_SECONDS: positiveIntFromEnv(60),
+    CRON_CLAIM_DURATION_SECONDS: positiveIntFromEnv(300),
+    CRON_MAX_PER_USER: z.coerce.number().int().nonnegative().default(100),
+    CRON_ALLOW_SECONDS_SCHEDULE: booleanFromEnv,
+    CRON_TICK_BATCH_SIZE: positiveIntFromEnv(100),
+    CRON_MAX_PAYLOAD_BYTES: positiveIntFromEnv(65536),
+    AEGRA_THREAD_TTL: z.string().optional(),
+    LANGGRAPH_THREAD_TTL: z.string().optional(),
+    MAX_SEARCH_LIMIT: positiveIntFromEnv(1000),
+    ENABLE_PROMETHEUS_METRICS: booleanFromEnv,
+    FF_V2_EVENT_STREAMING: z.stringbool().default(true),
+    OTEL_SERVICE_NAME: z.string().default("aegra-backend"),
+    OTEL_TARGETS: z.string().default(""),
+    OTEL_CONSOLE_EXPORT: booleanFromEnv,
+    OTEL_EXPORTER_OTLP_ENDPOINT: z.string().optional(),
+    OTEL_EXPORTER_OTLP_HEADERS: z.string().optional(),
+    LANGFUSE_BASE_URL: z.string().default("http://localhost:3000"),
+    LANGFUSE_PUBLIC_KEY: z.string().optional(),
+    LANGFUSE_SECRET_KEY: z.string().optional(),
+    PHOENIX_COLLECTOR_ENDPOINT: z.string().default("http://127.0.0.1:6006/v1/traces"),
+    PHOENIX_API_KEY: z.string().optional()
+  }).superRefine((value, issue) => {
+    if (value.LEASE_DURATION_SECONDS <= 2 * value.HEARTBEAT_INTERVAL_SECONDS) {
+      issue.addIssue({
+        code: "custom",
+        path: ["LEASE_DURATION_SECONDS"],
+        message: "LEASE_DURATION_SECONDS must exceed twice HEARTBEAT_INTERVAL_SECONDS"
+      });
+    }
+  });
+  raw = environmentSchema.parse(process.env);
+  settings = {
+    ...raw,
+    DATABASE_URL: raw.DATABASE_URL ?? `postgresql://${encodeURIComponent(raw.POSTGRES_USER)}:${encodeURIComponent(raw.POSTGRES_PASSWORD)}@${raw.POSTGRES_HOST}:${raw.POSTGRES_PORT}/${raw.POSTGRES_DB}`
+  };
+});
+
+// src/config/project.ts
+import { readFile } from "fs/promises";
+import { dirname, resolve } from "path";
+import { z as z2 } from "zod";
+async function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  const configPath = resolve(settings.AEGRA_CONFIG);
+  const content = await readFile(configPath, "utf8");
+  cachedConfig = configSchema.parse(JSON.parse(content));
+  return cachedConfig;
+}
+function configDirectory() {
+  return dirname(resolve(settings.AEGRA_CONFIG));
+}
+var corsSchema, configSchema, cachedConfig;
+var init_project = __esm(() => {
+  init_settings();
+  corsSchema = z2.object({
+    allow_origins: z2.array(z2.string()).default(["*"]),
+    allow_methods: z2.array(z2.string()).default(["*"]),
+    allow_headers: z2.array(z2.string()).default(["*"]),
+    allow_credentials: z2.boolean().optional(),
+    expose_headers: z2.array(z2.string()).default(["Content-Location", "Location"]),
+    max_age: z2.number().int().nonnegative().default(600)
+  });
+  configSchema = z2.object({
+    dependencies: z2.array(z2.string()).default([]),
+    graphs: z2.record(z2.string(), z2.string()).default({}),
+    auth: z2.object({ path: z2.string(), disable_studio_auth: z2.boolean().default(false) }).optional(),
+    http: z2.object({
+      app: z2.string().optional(),
+      enable_custom_route_auth: z2.boolean().default(false),
+      cors: corsSchema.optional()
+    }).optional(),
+    store: z2.object({
+      index: z2.object({ dims: z2.number().int().positive(), embed: z2.string(), fields: z2.array(z2.string()).nullable().optional() }).nullable().optional(),
+      scopes: z2.record(z2.string(), z2.array(z2.string())).default({})
+    }).optional(),
+    checkpointer: z2.object({
+      ttl: z2.object({
+        strategy: z2.enum(["delete", "keep_latest"]).default("delete"),
+        default_ttl: z2.number().positive().optional(),
+        sweep_interval_minutes: z2.number().positive().default(5),
+        sweep_limit: z2.number().int().positive().default(100)
+      }).nullable().optional()
+    }).optional()
+  });
+});
+
+// src/core/schema.ts
+var exports_schema = {};
+__export(exports_schema, {
+  threads: () => threads,
+  threadTtl: () => threadTtl,
+  threadEvents: () => threadEvents,
+  storeItems: () => storeItems,
+  runs: () => runs,
+  migrations: () => migrations,
+  crons: () => crons,
+  assistants: () => assistants,
+  assistantVersions: () => assistantVersions
+});
+import { sql } from "drizzle-orm";
+import { bigint, bigserial, boolean, doublePrecision, index, integer, jsonb, pgTable, primaryKey, text, timestamp, unique, uniqueIndex } from "drizzle-orm/pg-core";
+var timestamps, migrations, assistants, assistantVersions, threads, runs, threadEvents, crons, storeItems, threadTtl;
+var init_schema = __esm(() => {
+  timestamps = {
+    created_at: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updated_at: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+  };
+  migrations = pgTable("aegra_migrations", {
+    version: integer("version").primaryKey(),
+    applied_at: timestamp("applied_at", { withTimezone: true }).notNull().defaultNow()
+  });
+  assistants = pgTable("assistant", {
+    assistant_id: text("assistant_id").primaryKey().default(sql`gen_random_uuid()::text`),
+    name: text("name").notNull(),
+    description: text("description"),
+    graph_id: text("graph_id").notNull(),
+    config: jsonb("config").$type().notNull().default({}),
+    context: jsonb("context").$type().notNull().default({}),
+    user_id: text("user_id").notNull(),
+    version: integer("version").notNull().default(1),
+    metadata: jsonb("metadata").$type().notNull().default({}),
+    ...timestamps
+  }, (table) => [
+    index("idx_assistant_user").on(table.user_id),
+    unique("assistant_user_id_unique").on(table.user_id, table.assistant_id),
+    uniqueIndex("idx_assistant_user_graph_config").on(table.user_id, table.graph_id, sql`md5(${table.config}::text)`),
+    index("idx_assistant_metadata_gin").using("gin", sql`${table.metadata} jsonb_path_ops`)
+  ]);
+  assistantVersions = pgTable("assistant_versions", {
+    assistant_id: text("assistant_id").notNull().references(() => assistants.assistant_id, { onDelete: "cascade" }),
+    version: integer("version").notNull(),
+    graph_id: text("graph_id").notNull(),
+    config: jsonb("config").$type(),
+    context: jsonb("context").$type(),
+    metadata: jsonb("metadata").$type().notNull().default({}),
+    name: text("name"),
+    description: text("description"),
+    created_at: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+  }, (table) => [primaryKey({ columns: [table.assistant_id, table.version] })]);
+  threads = pgTable("thread", {
+    thread_id: text("thread_id").primaryKey(),
+    status: text("status").notNull().default("idle"),
+    metadata_json: jsonb("metadata_json").$type().notNull().default({}),
+    user_id: text("user_id").notNull(),
+    ...timestamps
+  }, (table) => [
+    index("idx_thread_user").on(table.user_id),
+    index("idx_thread_metadata_gin").using("gin", sql`${table.metadata_json} jsonb_path_ops`)
+  ]);
+  runs = pgTable("runs", {
+    run_id: text("run_id").primaryKey().default(sql`gen_random_uuid()::text`),
+    thread_id: text("thread_id").notNull().references(() => threads.thread_id, { onDelete: "cascade" }),
+    assistant_id: text("assistant_id").references(() => assistants.assistant_id, { onDelete: "cascade" }),
+    status: text("status").notNull().default("pending"),
+    input: jsonb("input").$type(),
+    config: jsonb("config").$type(),
+    context: jsonb("context").$type(),
+    output: jsonb("output").$type(),
+    error_message: text("error_message"),
+    user_id: text("user_id").notNull(),
+    execution_params: jsonb("execution_params").$type(),
+    claimed_by: text("claimed_by"),
+    lease_expires_at: timestamp("lease_expires_at", { withTimezone: true }),
+    ...timestamps
+  }, (table) => [
+    index("idx_runs_thread_id").on(table.thread_id),
+    index("idx_runs_status").on(table.status),
+    index("idx_runs_user").on(table.user_id),
+    index("idx_runs_assistant_id").on(table.assistant_id),
+    index("idx_runs_created_at").on(table.created_at),
+    index("idx_runs_lease_reaper").on(table.status, table.lease_expires_at).where(sql`${table.status} = 'running'`)
+  ]);
+  threadEvents = pgTable("thread_events", {
+    seq: bigserial("seq", { mode: "number" }).primaryKey(),
+    thread_id: text("thread_id").notNull().references(() => threads.thread_id, { onDelete: "cascade" }),
+    run_id: text("run_id").notNull().references(() => runs.run_id, { onDelete: "cascade" }),
+    user_id: text("user_id").notNull(),
+    event_id: text("event_id").notNull().unique(),
+    method: text("method").notNull(),
+    namespace: text("namespace").array().notNull().default(sql`'{}'::text[]`),
+    event_data: jsonb("event_data").$type().notNull(),
+    event_timestamp: bigint("event_timestamp", { mode: "number" }).notNull(),
+    created_at: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+  }, (table) => [index("idx_thread_events_replay").on(table.user_id, table.thread_id, table.seq)]);
+  crons = pgTable("crons", {
+    cron_id: text("cron_id").primaryKey().default(sql`gen_random_uuid()::text`),
+    assistant_id: text("assistant_id").notNull().references(() => assistants.assistant_id, { onDelete: "cascade" }),
+    thread_id: text("thread_id").references(() => threads.thread_id, { onDelete: "cascade" }),
+    user_id: text("user_id").notNull(),
+    schedule: text("schedule").notNull(),
+    payload: jsonb("payload").$type().notNull().default({}),
+    metadata: jsonb("metadata").$type().notNull().default({}),
+    on_run_completed: text("on_run_completed"),
+    enabled: boolean("enabled").notNull().default(true),
+    end_time: timestamp("end_time", { withTimezone: true }),
+    next_run_date: timestamp("next_run_date", { withTimezone: true }),
+    claimed_until: timestamp("claimed_until", { withTimezone: true }),
+    ...timestamps
+  }, (table) => [
+    index("idx_cron_user").on(table.user_id),
+    index("idx_cron_assistant_id").on(table.assistant_id),
+    index("idx_cron_thread_id").on(table.thread_id),
+    index("idx_cron_next_run").on(table.enabled, table.next_run_date)
+  ]);
+  storeItems = pgTable("store_items", {
+    user_id: text("user_id").notNull(),
+    namespace: text("namespace").array().notNull(),
+    key: text("key").notNull(),
+    value: jsonb("value").$type().notNull(),
+    ...timestamps
+  }, (table) => [primaryKey({ columns: [table.namespace, table.key] })]);
+  threadTtl = pgTable("thread_ttl", {
+    thread_id: text("thread_id").primaryKey().references(() => threads.thread_id, { onDelete: "cascade" }),
+    strategy: text("strategy").notNull().default("delete"),
+    ttl_minutes: doublePrecision("ttl_minutes").notNull(),
+    created_at: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    expires_at: timestamp("expires_at", { withTimezone: true }).notNull()
+  }, (table) => [index("idx_thread_ttl_expires_at").on(table.expires_at)]);
+});
+
+// src/core/database.ts
+var exports_database = {};
+__export(exports_database, {
+  pingDatabase: () => pingDatabase,
+  migrate: () => migrate,
+  db: () => db,
+  closeDatabase: () => closeDatabase,
+  client: () => client
+});
+import postgres from "postgres";
+import { drizzle } from "drizzle-orm/postgres-js";
+async function migrate() {
+  for (const statement of migrations2)
+    await client.unsafe(statement);
+  if ((await loadConfig()).store?.index) {
+    await client.unsafe("CREATE EXTENSION IF NOT EXISTS vector");
+    await client.unsafe(`CREATE TABLE IF NOT EXISTS store_embeddings (
+      user_id text NOT NULL,
+      namespace text[] NOT NULL,
+      key text NOT NULL,
+      embedding vector NOT NULL,
+      PRIMARY KEY(namespace, key),
+      FOREIGN KEY(namespace, key) REFERENCES store_items(namespace, key) ON DELETE CASCADE
+    )`);
+  }
+}
+async function pingDatabase() {
+  try {
+    await client`SELECT 1`;
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function closeDatabase() {
+  await client.end({ timeout: 5 });
+}
+var client, db, migrations2;
+var init_database = __esm(() => {
+  init_project();
+  init_settings();
+  init_schema();
+  client = postgres(settings.DATABASE_URL, {
+    max: 20,
+    idle_timeout: 30,
+    connect_timeout: 10,
+    transform: { undefined: null },
+    onnotice: (notice) => {
+      if (settings.LOG_VERBOSITY !== "verbose")
+        return;
+      console.log(JSON.stringify({ event: "postgres_notice", severity: notice.severity, code: notice.code, message: notice.message }));
+    }
+  });
+  db = drizzle({ client, schema: exports_schema });
+  migrations2 = [
+    `CREATE TABLE IF NOT EXISTS aegra_migrations (
+    version integer PRIMARY KEY,
+    applied_at timestamptz NOT NULL DEFAULT now()
+  )`,
+    `CREATE TABLE IF NOT EXISTS assistant (
+    assistant_id text PRIMARY KEY DEFAULT gen_random_uuid()::text,
+    name text NOT NULL,
+    description text,
+    graph_id text NOT NULL,
+    config jsonb NOT NULL DEFAULT '{}'::jsonb,
+    context jsonb NOT NULL DEFAULT '{}'::jsonb,
+    user_id text NOT NULL,
+    version integer NOT NULL DEFAULT 1,
+    metadata jsonb NOT NULL DEFAULT '{}'::jsonb,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    updated_at timestamptz NOT NULL DEFAULT now(),
+    UNIQUE(user_id, assistant_id)
+  )`,
+    `CREATE UNIQUE INDEX IF NOT EXISTS idx_assistant_user_graph_config
+    ON assistant(user_id, graph_id, md5(config::text))`,
+    `CREATE INDEX IF NOT EXISTS idx_assistant_user ON assistant(user_id)`,
+    `CREATE INDEX IF NOT EXISTS idx_assistant_metadata_gin ON assistant USING gin (metadata jsonb_path_ops)`,
+    `CREATE TABLE IF NOT EXISTS assistant_versions (
+    assistant_id text NOT NULL REFERENCES assistant(assistant_id) ON DELETE CASCADE,
+    version integer NOT NULL,
+    graph_id text NOT NULL,
+    config jsonb,
+    context jsonb,
+    metadata jsonb NOT NULL DEFAULT '{}'::jsonb,
+    name text,
+    description text,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    PRIMARY KEY(assistant_id, version)
+  )`,
+    `CREATE TABLE IF NOT EXISTS thread (
+    thread_id text PRIMARY KEY,
+    status text NOT NULL DEFAULT 'idle',
+    metadata_json jsonb NOT NULL DEFAULT '{}'::jsonb,
+    user_id text NOT NULL,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    updated_at timestamptz NOT NULL DEFAULT now()
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_thread_user ON thread(user_id)`,
+    `CREATE INDEX IF NOT EXISTS idx_thread_metadata_gin ON thread USING gin (metadata_json jsonb_path_ops)`,
+    `CREATE TABLE IF NOT EXISTS runs (
+    run_id text PRIMARY KEY DEFAULT gen_random_uuid()::text,
+    thread_id text NOT NULL REFERENCES thread(thread_id) ON DELETE CASCADE,
+    assistant_id text REFERENCES assistant(assistant_id) ON DELETE CASCADE,
+    status text NOT NULL DEFAULT 'pending',
+    input jsonb,
+    config jsonb,
+    context jsonb,
+    output jsonb,
+    error_message text,
+    user_id text NOT NULL,
+    execution_params jsonb,
+    claimed_by text,
+    lease_expires_at timestamptz,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    updated_at timestamptz NOT NULL DEFAULT now()
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_runs_thread_id ON runs(thread_id)`,
+    `CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status)`,
+    `CREATE INDEX IF NOT EXISTS idx_runs_user ON runs(user_id)`,
+    `CREATE INDEX IF NOT EXISTS idx_runs_assistant_id ON runs(assistant_id)`,
+    `CREATE INDEX IF NOT EXISTS idx_runs_created_at ON runs(created_at)`,
+    `CREATE INDEX IF NOT EXISTS idx_runs_lease_reaper ON runs(status, lease_expires_at) WHERE status = 'running'`,
+    `CREATE TABLE IF NOT EXISTS thread_events (
+    seq bigserial PRIMARY KEY,
+    thread_id text NOT NULL REFERENCES thread(thread_id) ON DELETE CASCADE,
+    run_id text NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    user_id text NOT NULL,
+    event_id text NOT NULL UNIQUE,
+    method text NOT NULL,
+    namespace text[] NOT NULL DEFAULT '{}',
+    event_data jsonb NOT NULL,
+    event_timestamp bigint NOT NULL,
+    created_at timestamptz NOT NULL DEFAULT now()
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_thread_events_replay ON thread_events(user_id, thread_id, seq)`,
+    `CREATE TABLE IF NOT EXISTS crons (
+    cron_id text PRIMARY KEY DEFAULT gen_random_uuid()::text,
+    assistant_id text NOT NULL REFERENCES assistant(assistant_id) ON DELETE CASCADE,
+    thread_id text REFERENCES thread(thread_id) ON DELETE CASCADE,
+    user_id text NOT NULL,
+    schedule text NOT NULL,
+    payload jsonb NOT NULL DEFAULT '{}'::jsonb,
+    metadata jsonb NOT NULL DEFAULT '{}'::jsonb,
+    on_run_completed text,
+    enabled boolean NOT NULL DEFAULT true,
+    end_time timestamptz,
+    next_run_date timestamptz,
+    claimed_until timestamptz,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    updated_at timestamptz NOT NULL DEFAULT now()
+  )`,
+    `CREATE TABLE IF NOT EXISTS store_items (
+    user_id text NOT NULL,
+    namespace text[] NOT NULL,
+    key text NOT NULL,
+    value jsonb NOT NULL,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    updated_at timestamptz NOT NULL DEFAULT now(),
+    PRIMARY KEY(namespace, key)
+  )`,
+    `DO $$
+  DECLARE legacy_key boolean;
+  BEGIN
+    SELECT EXISTS (
+      SELECT 1 FROM pg_constraint c
+      JOIN pg_class t ON t.oid = c.conrelid
+      WHERE t.relname = 'store_items' AND c.contype = 'p'
+        AND pg_get_constraintdef(c.oid) = 'PRIMARY KEY (user_id, namespace, key)'
+    ) INTO legacy_key;
+    IF legacy_key THEN
+      IF to_regclass('store_embeddings') IS NOT NULL THEN
+        ALTER TABLE store_embeddings DROP CONSTRAINT IF EXISTS store_embeddings_user_id_namespace_key_fkey;
+        ALTER TABLE store_embeddings DROP CONSTRAINT IF EXISTS store_embeddings_pkey;
+      END IF;
+      ALTER TABLE store_items DROP CONSTRAINT store_items_pkey;
+      ALTER TABLE store_items ADD CONSTRAINT store_items_pkey PRIMARY KEY (namespace, key);
+      IF to_regclass('store_embeddings') IS NOT NULL THEN
+        ALTER TABLE store_embeddings ADD CONSTRAINT store_embeddings_pkey PRIMARY KEY (namespace, key);
+        ALTER TABLE store_embeddings ADD CONSTRAINT store_embeddings_item_fkey
+          FOREIGN KEY (namespace, key) REFERENCES store_items(namespace, key) ON DELETE CASCADE;
+      END IF;
+    END IF;
+  END $$`,
+    `CREATE INDEX IF NOT EXISTS idx_cron_user ON crons(user_id)`,
+    `CREATE INDEX IF NOT EXISTS idx_cron_assistant_id ON crons(assistant_id)`,
+    `CREATE INDEX IF NOT EXISTS idx_cron_thread_id ON crons(thread_id)`,
+    `CREATE INDEX IF NOT EXISTS idx_cron_next_run ON crons(enabled, next_run_date)`,
+    `CREATE TABLE IF NOT EXISTS thread_ttl (
+    thread_id text PRIMARY KEY REFERENCES thread(thread_id) ON DELETE CASCADE,
+    strategy text NOT NULL DEFAULT 'delete',
+    ttl_minutes double precision NOT NULL,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    expires_at timestamptz NOT NULL
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_thread_ttl_expires_at ON thread_ttl(expires_at)`
+  ];
+});
+
+// src/cli.ts
+import { mkdir } from "fs/promises";
+import { basename, dirname as dirname2, resolve as resolve2 } from "path";
+function usage(exitCode = 1) {
+  console.log(`Usage: aegra <command> [options]
+
+Commands:
+  init [path]       Create a TypeScript Aegra project
+  dev               Start with Bun hot reload
+  serve             Start the production server
+  up|down [args]    Run Docker Compose
+  db upgrade        Apply database migrations
+  version           Print the version
+
+Server options: --host, --port, --config|-c, --env-file|-e
+Init options: --name|-n, --template|-t <basic|hono|auth|full>, --force`);
+  process.exit(exitCode);
+}
+function parseOptions(args) {
+  const positional = [];
+  const options = {};
+  for (let index2 = 0;index2 < args.length; index2++) {
+    const value = args[index2];
+    if (!value.startsWith("-")) {
+      positional.push(value);
+      continue;
+    }
+    const [rawName, inline] = value.split("=", 2);
+    const name = { "-c": "config", "-e": "env-file", "-n": "name", "-t": "template" }[rawName] ?? rawName.replace(/^--/, "");
+    if (["force", "help", "no-db-check"].includes(name)) {
+      options[name] = true;
+      continue;
+    }
+    const next = inline ?? args[++index2];
+    if (!next)
+      throw new Error(`Missing value for ${rawName}`);
+    options[name] = next;
+  }
+  return { positional, options };
+}
+async function loadEnv(path) {
+  const file = Bun.file(path);
+  if (!await file.exists())
+    return;
+  for (const line of (await file.text()).split(/\r?\n/)) {
+    const match = line.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$/);
+    if (!match || process.env[match[1]] !== undefined)
+      continue;
+    process.env[match[1]] = match[2].replace(/^(['"])(.*)\1$/, "$2");
+  }
+}
+function run(command, env) {
+  const result = Bun.spawnSync(command, { stdin: "inherit", stdout: "inherit", stderr: "inherit", ...env ? { env } : {} });
+  if (result.exitCode !== 0)
+    process.exit(result.exitCode);
+}
+async function serverEnvironment(options) {
+  await loadEnv(String(options["env-file"] ?? resolve2(".env")));
+  if (options.host)
+    process.env.HOST = String(options.host);
+  if (options.port)
+    process.env.PORT = String(options.port);
+  if (options.config)
+    process.env.AEGRA_CONFIG = resolve2(String(options.config));
+  else if (!process.env.AEGRA_CONFIG && await Bun.file(resolve2("langgraph.json")).exists() && !await Bun.file(resolve2("aegra.json")).exists())
+    process.env.AEGRA_CONFIG = "langgraph.json";
+  return process.env;
+}
+function slugify(value) {
+  return value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "aegra-agent";
+}
+async function writeProjectFile(root, path, content, force) {
+  const target = resolve2(root, path);
+  if (!force && await Bun.file(target).exists())
+    return "skipped";
+  await mkdir(dirname2(target), { recursive: true });
+  await Bun.write(target, content);
+  return "created";
+}
+async function initProject(args) {
+  const { positional, options } = parseOptions(args);
+  if (options.help)
+    usage(0);
+  const root = resolve2(positional[0] ?? ".");
+  const name = String(options.name ?? basename(root));
+  const slug = slugify(name);
+  const requestedTemplate = String(options.template ?? "basic");
+  const template = requestedTemplate === "1" ? "basic" : requestedTemplate;
+  if (!["basic", "hono", "auth", "full"].includes(template)) {
+    throw new Error("Template must be one of: basic, hono, auth, full");
+  }
+  const version = (await Bun.file(resolve2(import.meta.dir, "../package.json")).json()).version;
+  const escapedName = JSON.stringify(`Hello from ${name}`);
+  const graph = `import { AIMessage } from "@langchain/core/messages";
+import { MessagesAnnotation, StateGraph, START, END } from "@langchain/langgraph";
+import { defineGraph } from "aegra-hono/graph";
+
+export const graph = defineGraph(new StateGraph(MessagesAnnotation)
+  .addNode("reply", async () => ({ messages: [new AIMessage(${escapedName})] }))
+  .addEdge(START, "reply").addEdge("reply", END).compile());
+`;
+  const withHono = template === "hono" || template === "full";
+  const withAuth = template === "auth" || template === "full";
+  const config = {
+    name,
+    graphs: { [slug]: "./src/graph.ts:graph" },
+    ...withAuth ? { auth: { path: "./src/auth.ts:auth" } } : {},
+    ...withHono ? { http: { app: "./src/app.ts:app", ...withAuth ? { enable_custom_route_auth: true } : {} } } : {}
+  };
+  const compose = `services:
+  postgres:
+    image: pgvector/pgvector:pg18
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: aegra
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres -d aegra"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+${template === "full" ? `  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis-data:/data
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+` : ""}volumes:
+  postgres-data:
+${template === "full" ? `  redis-data:
+` : ""}`;
+  const files = {
+    "aegra.json": `${JSON.stringify(config, null, 2)}
+`,
+    "package.json": `${JSON.stringify({ name: slug, private: true, type: "module", scripts: { dev: "aegra dev", start: "aegra serve", check: "tsc --noEmit", db: "aegra db upgrade", services: "docker compose up -d" }, dependencies: { aegra: version, "@langchain/core": "1.2.10", "@langchain/langgraph": "1.4.14", ...withHono ? { hono: "4.13.7" } : {} }, devDependencies: { "@types/bun": "1.3.10", typescript: "5.9.3" }, engines: { bun: ">=1.3.10" } }, null, 2)}
+`,
+    "tsconfig.json": `${JSON.stringify({ compilerOptions: { target: "ES2022", module: "Preserve", moduleResolution: "bundler", strict: true, noEmit: true, types: ["bun"], skipLibCheck: true }, include: ["src"] }, null, 2)}
+`,
+    "src/graph.ts": graph,
+    ".env.example": `DATABASE_URL=postgresql://postgres:postgres@localhost:5432/aegra
+REDIS_BROKER_ENABLED=${template === "full" ? "true" : "false"}
+REDIS_URL=redis://localhost:6379/0
+${withAuth ? `AEGRA_AUTH_TOKEN=replace-me
+` : ""}`,
+    ".gitignore": `node_modules
+.env
+`,
+    "docker-compose.yml": compose,
+    "README.md": `# ${name}
+
+\`\`\`bash
+bun install
+cp .env.example .env
+docker compose up -d
+bun run db
+bun run dev
+\`\`\`
+`
+  };
+  if (withHono)
+    files["src/app.ts"] = `import { Hono } from "hono";
+import { defineApp } from "aegra-hono/hono";
+
+export const app = defineApp(new Hono().get("/hello", (context) => context.json({ message: ${escapedName} })));
+`;
+  if (withAuth)
+    files["src/auth.ts"] = `import { Auth } from "aegra-hono/auth";
+
+export const auth = new Auth();
+auth.authenticate((request) => {
+  const token = process.env.AEGRA_AUTH_TOKEN;
+  if (!token || request.headers.get("authorization") !== \`Bearer \${token}\`) throw new Error("Invalid bearer token");
+  return { identity: request.headers.get("x-user-id")?.trim() || "authenticated-user", isAuthenticated: true, permissions: [] };
+});
+`;
+  let created = 0;
+  let skipped = 0;
+  for (const [path, content] of Object.entries(files)) {
+    if (await writeProjectFile(root, path, content, Boolean(options.force)) === "created")
+      created++;
+    else
+      skipped++;
+  }
+  console.log(`Created ${created} files in ${root}${skipped ? ` (${skipped} skipped; use --force to overwrite)` : ""}`);
+}
+async function main(argv = process.argv.slice(2)) {
+  const [command, ...args] = argv;
+  if (!command || command === "help" || command === "--help")
+    usage(command ? 0 : 1);
+  if (command === "init")
+    return initProject(args);
+  if (command === "version" || command === "--version") {
+    const pkg = await Bun.file(resolve2(import.meta.dir, "../package.json")).json();
+    console.log(pkg.version);
+    return;
+  }
+  if (command === "dev" || command === "serve") {
+    const { options } = parseOptions(args);
+    if (options.help)
+      usage(0);
+    const env = await serverEnvironment(options);
+    const builtEntrypoint = resolve2(import.meta.dir, "index.js");
+    const entrypoint = await Bun.file(builtEntrypoint).exists() ? builtEntrypoint : resolve2(import.meta.dir, "index.ts");
+    if (command === "dev")
+      run(["bun", "--hot", entrypoint], env);
+    else
+      await import(entrypoint);
+    return;
+  }
+  if (command === "up" || command === "down")
+    return run(["docker", "compose", command, ...args]);
+  if (command === "db" && args[0] === "upgrade") {
+    const { options } = parseOptions(args.slice(1));
+    await serverEnvironment(options);
+    const { migrate: migrate2, closeDatabase: closeDatabase2 } = await Promise.resolve().then(() => (init_database(), exports_database));
+    await migrate2();
+    await closeDatabase2();
+    console.log("Database is up to date");
+    return;
+  }
+  usage();
+}
+if (import.meta.main)
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  });
+export {
+  main
+};
+
+//# debugId=C015E558C48B8F4564756E2164756E21