bunbase 0.0.9

package/dist/cli/index.js

@@ -0,0 +1,1530 @@
+#!/usr/bin/env bun
+import {
+  BadRequestError,
+  ForbiddenError,
+  UnauthorizedError,
+  __commonJS,
+  __toESM,
+  loadConfig
+} from "../shared/chunk-k195ahh5.js";
+
+// node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS((exports, module) => {
+  var p = process || {};
+  var argv = p.argv || [];
+  var env = p.env || {};
+  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+  var formatter = (open, close, replace = open) => (input) => {
+    let string = "" + input, index = string.indexOf(close, open.length);
+    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+  };
+  var replaceClose = (string, close, replace, index) => {
+    let result = "", cursor = 0;
+    do {
+      result += string.substring(cursor, index) + replace;
+      cursor = index + close.length;
+      index = string.indexOf(close, cursor);
+    } while (~index);
+    return result + string.substring(cursor);
+  };
+  var createColors = (enabled = isColorSupported) => {
+    let f = enabled ? formatter : () => String;
+    return {
+      isColorSupported: enabled,
+      reset: f("\x1B[0m", "\x1B[0m"),
+      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+      italic: f("\x1B[3m", "\x1B[23m"),
+      underline: f("\x1B[4m", "\x1B[24m"),
+      inverse: f("\x1B[7m", "\x1B[27m"),
+      hidden: f("\x1B[8m", "\x1B[28m"),
+      strikethrough: f("\x1B[9m", "\x1B[29m"),
+      black: f("\x1B[30m", "\x1B[39m"),
+      red: f("\x1B[31m", "\x1B[39m"),
+      green: f("\x1B[32m", "\x1B[39m"),
+      yellow: f("\x1B[33m", "\x1B[39m"),
+      blue: f("\x1B[34m", "\x1B[39m"),
+      magenta: f("\x1B[35m", "\x1B[39m"),
+      cyan: f("\x1B[36m", "\x1B[39m"),
+      white: f("\x1B[37m", "\x1B[39m"),
+      gray: f("\x1B[90m", "\x1B[39m"),
+      bgBlack: f("\x1B[40m", "\x1B[49m"),
+      bgRed: f("\x1B[41m", "\x1B[49m"),
+      bgGreen: f("\x1B[42m", "\x1B[49m"),
+      bgYellow: f("\x1B[43m", "\x1B[49m"),
+      bgBlue: f("\x1B[44m", "\x1B[49m"),
+      bgMagenta: f("\x1B[45m", "\x1B[49m"),
+      bgCyan: f("\x1B[46m", "\x1B[49m"),
+      bgWhite: f("\x1B[47m", "\x1B[49m"),
+      blackBright: f("\x1B[90m", "\x1B[39m"),
+      redBright: f("\x1B[91m", "\x1B[39m"),
+      greenBright: f("\x1B[92m", "\x1B[39m"),
+      yellowBright: f("\x1B[93m", "\x1B[39m"),
+      blueBright: f("\x1B[94m", "\x1B[39m"),
+      magentaBright: f("\x1B[95m", "\x1B[39m"),
+      cyanBright: f("\x1B[96m", "\x1B[39m"),
+      whiteBright: f("\x1B[97m", "\x1B[39m"),
+      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+      bgRedBright: f("\x1B[101m", "\x1B[49m"),
+      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+    };
+  };
+  module.exports = createColors();
+  module.exports.createColors = createColors;
+});
+
+// src/cli/index.ts
+import { Command as Command5 } from "commander";
+
+// src/cli/commands/build.ts
+import { Command } from "commander";
+var buildCommand = new Command("build").description("Build the project for production").action(async () => {
+  console.log("Building project...");
+  const proc = Bun.spawn([
+    "bun",
+    "build",
+    "./src/index.ts",
+    "--outdir",
+    "./dist",
+    "--target",
+    "bun"
+  ], {
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  await proc.exited;
+  console.log("Build complete.");
+});
+
+// src/cli/commands/create-action.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Command as Command2 } from "commander";
+import inquirer from "inquirer";
+var createActionCommand = new Command2("create:action").description("Create a new action").action(async () => {
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Action name (e.g. user/create):",
+      validate: (input) => input.length > 0
+    },
+    {
+      type: "checkbox",
+      name: "triggers",
+      message: "Select triggers:",
+      choices: ["api", "cron", "event", "agent"]
+    }
+  ]);
+  const name = answers.name;
+  const parts = name.split("/");
+  const fileName = parts.pop() || "index";
+  const dir = parts.join("/");
+  const baseDir = "./src/actions";
+  const targetDir = join(baseDir, dir);
+  const targetFile = join(targetDir, `${fileName}.ts`);
+  await mkdir(targetDir, { recursive: true });
+  const content = `import { action } from 'basalt'
+import { Type } from '@sinclair/typebox'
+
+export default action({
+    name: '${name}',
+    description: 'Auto-generated action',
+    input: Type.Object({
+        // Define input schema
+        name: Type.String(),
+    }),
+    output: Type.Object({
+        result: Type.String(),
+    }),
+    triggers: [
+${answers.triggers.map((t) => {
+    if (t === "api")
+      return `        { kind: 'api', method: 'POST', path: '/${name}' },`;
+    if (t === "cron")
+      return `        { kind: 'cron', schedule: '0 * * * *' },`;
+    if (t === "event")
+      return `        { kind: 'event', event: '${name.replace("/", ".")}' },`;
+    if (t === "agent")
+      return `        { kind: 'agent', tool: '${name.replace("/", "_")}', description: 'Execute ${name}' },`;
+    return "";
+  }).join(`
+`)}
+    ],
+    handler: async (input, ctx) => {
+        ctx.log.info('Executing ${name}', { input })
+        return {
+            result: \`Hello \${input.name}\`
+        }
+    }
+})
+`;
+  await writeFile(targetFile, content);
+  console.log(`✓ Created action at ${targetFile}`);
+});
+
+// src/cli/commands/dev.ts
+import { Command as Command3 } from "commander";
+
+// src/runtime/dev.ts
+import { watch } from "node:fs";
+
+// src/codegen/types.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+async function generateActionTypes(actions, outputDir = ".gravity") {
+  const typeMap = {};
+  for (const action of actions) {
+    const inputType = schemaToTypeString(action.config.input);
+    typeMap[action.config.name] = inputType;
+  }
+  const dts = `
+// Auto-generated by Gravity - DO NOT EDIT
+// Generated at ${new Date().toISOString()}
+
+declare module 'gravity-run/types' {
+  export interface ActionRegistry {
+${Object.entries(typeMap).map(([name, type]) => `    '${name}': ${type}`).join(`
+`)}
+  }
+}
+
+export {}
+`.trim();
+  await mkdir2(outputDir, { recursive: true });
+  await writeFile2(join2(outputDir, "types.d.ts"), dts, "utf-8");
+}
+function schemaToTypeString(schema) {
+  if (!schema)
+    return "any";
+  const kind = schema.type;
+  if (kind === "object") {
+    const props = schema.properties || {};
+    const entries = Object.entries(props).map(([key, val]) => {
+      return `${key}: ${schemaToTypeString(val)}`;
+    });
+    return `{ ${entries.join("; ")} }`;
+  }
+  if (kind === "string")
+    return "string";
+  if (kind === "number")
+    return "number";
+  if (kind === "boolean")
+    return "boolean";
+  if (kind === "array") {
+    const items = schema.items;
+    return `Array<${schemaToTypeString(items)}>`;
+  }
+  return "any";
+}
+
+// src/logger/action-logger.ts
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+
+// src/logger/symbols.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+import isUnicodeSupported from "is-unicode-supported";
+var unicode = isUnicodeSupported();
+var u = (c, fallback) => unicode ? c : fallback;
+var S_BAR_START = u("┌", "T");
+var S_BAR = u("│", "|");
+var S_BAR_END = u("└", "-");
+var S_STEP_SUBMIT = u("◇", "o");
+var S_RADIO_ACTIVE = u("●", ">");
+var S_SUCCESS = u("✔", "√");
+var S_ERROR = u("✖", "x");
+var S_WARN = u("▲", "!");
+var S_INFO = u("●", "•");
+var bar = () => import_picocolors.default.gray(S_BAR);
+var barStart = (text) => `${import_picocolors.default.gray(S_BAR_START)}  ${text}`;
+var barEnd = (text) => `${import_picocolors.default.gray(S_BAR_END)}  ${text}`;
+var stepInfo = (label, detail) => `${import_picocolors.default.green(S_STEP_SUBMIT)}  ${label}${detail ? `: ${detail}` : ""}`;
+var stepActive = (label, detail) => `${import_picocolors.default.cyan(S_RADIO_ACTIVE)}  ${label}${detail ? `: ${detail}` : ""}`;
+var stepSuccess = (label, detail) => `${import_picocolors.default.green(S_SUCCESS)}  ${label}${detail ? `: ${detail}` : ""}`;
+var stepError = (label, detail) => `${import_picocolors.default.red(S_ERROR)}  ${label}${detail ? `: ${detail}` : ""}`;
+var stepWarn = (label, detail) => `${import_picocolors.default.yellow(S_WARN)}  ${label}${detail ? `: ${detail}` : ""}`;
+
+// src/logger/action-logger.ts
+class LoggerSession {
+  output;
+  startTime;
+  constructor(title, output = process.stdout) {
+    this.output = output;
+    this.startTime = Date.now();
+    this.write(barStart(title));
+  }
+  write(line) {
+    this.output.write(`${line}
+`);
+  }
+  info(label, detail) {
+    this.write(stepInfo(label, detail));
+    return this;
+  }
+  step(label, detail) {
+    this.write(stepActive(label, detail));
+    return this;
+  }
+  success(label, detail) {
+    this.write(stepSuccess(label, detail));
+    return this;
+  }
+  warn(label, detail) {
+    this.write(stepWarn(label, detail));
+    return this;
+  }
+  error(label, detail) {
+    this.write(stepError(label, detail));
+    return this;
+  }
+  bar() {
+    this.write(bar());
+    return this;
+  }
+  end(message) {
+    const elapsed = Date.now() - this.startTime;
+    const msg = message ?? "Done";
+    this.write(bar());
+    this.write(barEnd(import_picocolors2.default.green(`${msg}`) + import_picocolors2.default.gray(` (${elapsed}ms)`)));
+    this.write("");
+  }
+  fail(message) {
+    const elapsed = Date.now() - this.startTime;
+    const msg = message ?? "Failed";
+    this.write(bar());
+    this.write(barEnd(import_picocolors2.default.red(`${msg}`) + import_picocolors2.default.gray(` (${elapsed}ms)`)));
+    this.write("");
+  }
+}
+// src/logger/pretty-print.ts
+var import_picocolors3 = __toESM(require_picocolors(), 1);
+var stepTag = (step) => step ? import_picocolors3.default.bold(import_picocolors3.default.cyan(step)) : "";
+var timestampTag = (timestamp) => import_picocolors3.default.gray(timestamp);
+var traceIdTag = (traceId) => traceId ? import_picocolors3.default.gray(traceId) : "";
+var levelTags = {
+  error: import_picocolors3.default.red("[ERROR]"),
+  info: import_picocolors3.default.blue("[INFO]"),
+  warn: import_picocolors3.default.yellow("[WARN]"),
+  debug: import_picocolors3.default.gray("[DEBUG]")
+};
+var numericTag = (value) => import_picocolors3.default.green(value);
+var stringTag = (value) => import_picocolors3.default.cyan(value);
+var booleanTag = (value) => import_picocolors3.default.blue(value);
+var arrayBrackets = ["[", "]"].map((s) => import_picocolors3.default.gray(s));
+var objectBrackets = ["{", "}"].map((s) => import_picocolors3.default.gray(s));
+var prettyPrintObject = (obj, depth = 0, parentIsLast = false, prefix = "") => {
+  const tab = prefix + (depth === 0 ? "" : parentIsLast ? "│ " : "│ ");
+  if (depth > 2)
+    return `${tab} └ ${import_picocolors3.default.gray("[...]")}`;
+  const entries = Object.entries(obj);
+  return entries.map(([key, value], index) => {
+    const isLast = index === entries.length - 1;
+    const isObject = typeof value === "object" && value !== null;
+    const branch = isLast ? "└" : "├";
+    if (isObject) {
+      const subObject = prettyPrintObject(value, depth + 1, isLast, tab);
+      const [start, end] = Array.isArray(value) ? arrayBrackets : objectBrackets;
+      return `${tab}${branch} ${key}: ${start}
+${subObject}
+${tab}${isLast ? " " : "│"} ${end}`;
+    }
+    let printedValue = value;
+    if (typeof value === "number")
+      printedValue = numericTag(String(value));
+    else if (typeof value === "boolean")
+      printedValue = booleanTag(String(value));
+    else if (typeof value === "string")
+      printedValue = stringTag(value);
+    return `${tab}${branch} ${key}: ${printedValue}`;
+  }).join(`
+`);
+};
+var prettyPrint = (json, excludeDetails = false) => {
+  const { time, traceId, msg, flows, level, step, ...details } = json;
+  const levelTag = levelTags[level?.toLowerCase?.()] ?? levelTags.info;
+  const timestamp = timestampTag(`[${new Date(time).toLocaleTimeString()}]`);
+  const objectHasKeys = Object.keys(details).length > 0;
+  process.stdout.write(`${timestamp} ${traceIdTag(traceId)} ${levelTag} ${stepTag(step)} ${msg}
+`);
+  if (objectHasKeys && !excludeDetails) {
+    process.stdout.write(`${prettyPrintObject(details)}
+`);
+  }
+};
+
+// src/logger/logger.ts
+var LEVELS = {
+  DEBUG: 10,
+  INFO: 20,
+  WARNING: 30,
+  ERROR: 40,
+  CRITICAL: 50
+};
+var levelMap = {
+  debug: LEVELS.DEBUG,
+  info: LEVELS.INFO,
+  warn: LEVELS.WARNING,
+  warning: LEVELS.WARNING,
+  error: LEVELS.ERROR,
+  critical: LEVELS.CRITICAL
+};
+
+class Logger {
+  options;
+  meta;
+  coreListeners;
+  listeners = [];
+  minLevel;
+  store;
+  constructor(options = {}, meta = {}, coreListeners = [], store) {
+    this.options = options;
+    this.meta = meta;
+    this.coreListeners = coreListeners;
+    this.minLevel = options.level ? levelMap[options.level] ?? LEVELS.INFO : LEVELS.INFO;
+    this.store = store;
+  }
+  setStore(store) {
+    this.store = store;
+  }
+  child(meta) {
+    return new Logger(this.options, { ...this.meta, ...meta }, this.coreListeners, this.store);
+  }
+  session(title) {
+    return new LoggerSession(title);
+  }
+  shouldLog(messageLevel) {
+    return messageLevel >= this.minLevel;
+  }
+  _log(level, msg, args) {
+    const time = Date.now();
+    const meta = {
+      ...this.meta,
+      ...args && typeof args === "object" ? args : {}
+    };
+    const isVerbose = this.options.verbose ?? false;
+    prettyPrint({ level, time, msg, ...meta }, !isVerbose);
+    if (this.store) {
+      try {
+        this.store.logs.insert({
+          level,
+          message: msg,
+          meta: Object.keys(meta).length > 0 ? JSON.stringify(meta) : null,
+          action_name: meta.action ?? null,
+          trace_id: meta.traceId ?? null
+        });
+      } catch {}
+    }
+    this.coreListeners.forEach((listener) => {
+      listener(level, msg, meta);
+    });
+    this.listeners.forEach((listener) => {
+      listener(level, msg, meta);
+    });
+  }
+  info(message, args) {
+    if (this.shouldLog(LEVELS.INFO))
+      this._log("INFO", message, args);
+  }
+  error(message, args) {
+    if (this.shouldLog(LEVELS.ERROR))
+      this._log("ERROR", message, args);
+  }
+  debug(message, args) {
+    if (this.shouldLog(LEVELS.DEBUG))
+      this._log("DEBUG", message, args);
+  }
+  warn(message, args) {
+    if (this.shouldLog(LEVELS.WARNING))
+      this._log("WARNING", message, args);
+  }
+  addListener(listener) {
+    this.listeners.push(listener);
+  }
+}
+// src/runtime/loader.ts
+async function loadActions(dir, logger = new Logger) {
+  const glob = new Bun.Glob(`${dir}/**/*.ts`);
+  const files = glob.scanSync();
+  logger.debug("Loading actions from", { files });
+  const actions = [];
+  for (const file of files) {
+    const module = await import(Bun.pathToFileURL(file).href);
+    logger.debug("Loading action", { file });
+    for (const exported of Object.values(module)) {
+      if (isAction(exported)) {
+        actions.push(exported);
+      }
+    }
+  }
+  return actions;
+}
+function isAction(obj) {
+  return typeof obj === "function" && "config" in obj && "handler" in obj && typeof obj.config === "object" && "name" in obj.config;
+}
+
+// src/store/job-store.ts
+class JobStore {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  upsert(job) {
+    this.db.run(`INSERT INTO jobs (action_name, trigger_name, schedule, status)
+			 VALUES (?, ?, ?, 'active')
+			 ON CONFLICT(action_name, trigger_name) DO UPDATE SET
+			   schedule = excluded.schedule,
+			   status = 'active'`, [job.action_name, job.trigger_name, job.schedule]);
+  }
+  recordRun(actionName, triggerName, error) {
+    if (error) {
+      this.db.run(`UPDATE jobs
+				 SET last_run_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now'),
+				     run_count = run_count + 1,
+				     last_error = ?
+				 WHERE action_name = ? AND trigger_name = ?`, [error, actionName, triggerName]);
+    } else {
+      this.db.run(`UPDATE jobs
+				 SET last_run_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now'),
+				     run_count = run_count + 1,
+				     last_error = NULL
+				 WHERE action_name = ? AND trigger_name = ?`, [actionName, triggerName]);
+    }
+  }
+  list(status) {
+    if (status) {
+      return this.db.query("SELECT * FROM jobs WHERE status = ? ORDER BY created_at DESC").all(status);
+    }
+    return this.db.query("SELECT * FROM jobs ORDER BY created_at DESC").all();
+  }
+  get(actionName, triggerName) {
+    return this.db.query("SELECT * FROM jobs WHERE action_name = ? AND trigger_name = ?").get(actionName, triggerName) ?? null;
+  }
+  pause(actionName, triggerName) {
+    this.db.run(`UPDATE jobs SET status = 'paused' WHERE action_name = ? AND trigger_name = ?`, [actionName, triggerName]);
+  }
+  resume(actionName, triggerName) {
+    this.db.run(`UPDATE jobs SET status = 'active' WHERE action_name = ? AND trigger_name = ?`, [actionName, triggerName]);
+  }
+}
+// src/store/log-store.ts
+class LogStore {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  insert(entry) {
+    this.db.run(`INSERT INTO logs (level, message, meta, action_name, trace_id) VALUES (?, ?, ?, ?, ?)`, [
+      entry.level,
+      entry.message,
+      entry.meta ?? null,
+      entry.action_name ?? null,
+      entry.trace_id ?? null
+    ]);
+  }
+  query(filter = {}) {
+    const conditions = [];
+    const params = [];
+    if (filter.level) {
+      conditions.push("level = ?");
+      params.push(filter.level);
+    }
+    if (filter.action_name) {
+      conditions.push("action_name = ?");
+      params.push(filter.action_name);
+    }
+    if (filter.trace_id) {
+      conditions.push("trace_id = ?");
+      params.push(filter.trace_id);
+    }
+    if (filter.since) {
+      conditions.push("created_at >= ?");
+      params.push(filter.since);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = filter.limit ?? 100;
+    const offset = filter.offset ?? 0;
+    return this.db.query(`SELECT * FROM logs ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+  }
+  cleanup(retentionDays) {
+    const result = this.db.run(`DELETE FROM logs WHERE created_at < datetime('now', '-' || ? || ' days')`, [retentionDays]);
+    return result.changes;
+  }
+  count(filter = {}) {
+    const conditions = [];
+    const params = [];
+    if (filter.level) {
+      conditions.push("level = ?");
+      params.push(filter.level);
+    }
+    if (filter.action_name) {
+      conditions.push("action_name = ?");
+      params.push(filter.action_name);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const row = this.db.query(`SELECT COUNT(*) as count FROM logs ${where}`).get(...params);
+    return row?.count ?? 0;
+  }
+}
+// src/store/run-store.ts
+class RunStore {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  start(run) {
+    this.db.run(`INSERT INTO action_runs (trace_id, action_name, trigger_name, trigger_type, actor_id, actor_type, input, status)
+			 VALUES (?, ?, ?, ?, ?, ?, ?, 'pending')`, [
+      run.trace_id,
+      run.action_name,
+      run.trigger_name,
+      run.trigger_type,
+      run.actor_id ?? null,
+      run.actor_type ?? null,
+      run.input !== undefined ? JSON.stringify(run.input) : null
+    ]);
+  }
+  complete(traceId, output, durationMs) {
+    this.db.run(`UPDATE action_runs
+			 SET status = 'success', output = ?, duration_ms = ?, completed_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+			 WHERE trace_id = ?`, [
+      output !== undefined ? JSON.stringify(output) : null,
+      durationMs,
+      traceId
+    ]);
+  }
+  fail(traceId, errorMessage, durationMs) {
+    this.db.run(`UPDATE action_runs
+			 SET status = 'error', error_message = ?, duration_ms = ?, completed_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+			 WHERE trace_id = ?`, [errorMessage, durationMs, traceId]);
+  }
+  query(filter = {}) {
+    const conditions = [];
+    const params = [];
+    if (filter.action_name) {
+      conditions.push("action_name = ?");
+      params.push(filter.action_name);
+    }
+    if (filter.trigger_type) {
+      conditions.push("trigger_type = ?");
+      params.push(filter.trigger_type);
+    }
+    if (filter.status) {
+      conditions.push("status = ?");
+      params.push(filter.status);
+    }
+    if (filter.since) {
+      conditions.push("started_at >= ?");
+      params.push(filter.since);
+    }
+    if (filter.until) {
+      conditions.push("started_at <= ?");
+      params.push(filter.until);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = filter.limit ?? 50;
+    const offset = filter.offset ?? 0;
+    return this.db.query(`SELECT * FROM action_runs ${where} ORDER BY started_at DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+  }
+  getByTraceId(traceId) {
+    return this.db.query("SELECT * FROM action_runs WHERE trace_id = ?").get(traceId) ?? null;
+  }
+  stats(since) {
+    const where = since ? "WHERE started_at >= ?" : "";
+    const params = since ? [since] : [];
+    const row = this.db.query(`
+			SELECT
+				COUNT(*) as total,
+				SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as success,
+				SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END) as error,
+				COALESCE(AVG(duration_ms), 0) as avg_duration_ms
+			FROM action_runs ${where}
+		`).get(...params);
+    return {
+      total: row.total ?? 0,
+      success: row.success ?? 0,
+      error: row.error ?? 0,
+      avg_duration_ms: Math.round(row.avg_duration_ms ?? 0)
+    };
+  }
+  cleanup(retentionDays) {
+    const result = this.db.run(`DELETE FROM action_runs WHERE started_at < datetime('now', '-' || ? || ' days')`, [retentionDays]);
+    return result.changes;
+  }
+}
+// src/store/store.ts
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
+// src/store/schema.ts
+var CREATE_LOGS_TABLE = `
+CREATE TABLE IF NOT EXISTS logs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  level TEXT NOT NULL,
+  message TEXT NOT NULL,
+  meta TEXT,
+  action_name TEXT,
+  trace_id TEXT,
+  created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+`;
+var CREATE_ACTION_RUNS_TABLE = `
+CREATE TABLE IF NOT EXISTS action_runs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  trace_id TEXT NOT NULL UNIQUE,
+  action_name TEXT NOT NULL,
+  trigger_name TEXT NOT NULL,
+  trigger_type TEXT NOT NULL,
+  actor_id TEXT,
+  actor_type TEXT,
+  input TEXT,
+  output TEXT,
+  status TEXT NOT NULL DEFAULT 'pending',
+  error_message TEXT,
+  duration_ms INTEGER,
+  started_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+  completed_at TEXT
+);
+`;
+var CREATE_JOBS_TABLE = `
+CREATE TABLE IF NOT EXISTS jobs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  action_name TEXT NOT NULL,
+  trigger_name TEXT NOT NULL,
+  schedule TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'active',
+  last_run_at TEXT,
+  next_run_at TEXT,
+  run_count INTEGER NOT NULL DEFAULT 0,
+  last_error TEXT,
+  created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+  UNIQUE(action_name, trigger_name)
+);
+`;
+var CREATE_INDEXES = `
+CREATE INDEX IF NOT EXISTS idx_logs_level ON logs(level);
+CREATE INDEX IF NOT EXISTS idx_logs_action ON logs(action_name);
+CREATE INDEX IF NOT EXISTS idx_logs_trace ON logs(trace_id);
+CREATE INDEX IF NOT EXISTS idx_logs_created ON logs(created_at);
+
+CREATE INDEX IF NOT EXISTS idx_runs_action ON action_runs(action_name);
+CREATE INDEX IF NOT EXISTS idx_runs_status ON action_runs(status);
+CREATE INDEX IF NOT EXISTS idx_runs_trigger ON action_runs(trigger_type);
+CREATE INDEX IF NOT EXISTS idx_runs_started ON action_runs(started_at);
+
+CREATE INDEX IF NOT EXISTS idx_jobs_action ON jobs(action_name);
+CREATE INDEX IF NOT EXISTS idx_jobs_status ON jobs(status);
+`;
+
+// src/store/store.ts
+class GravityStore {
+  db;
+  logs;
+  runs;
+  jobs;
+  retention;
+  constructor(config = {}) {
+    const dbPath = config.path ?? ".gravity/data.db";
+    this.retention = config.retention ?? 30;
+    mkdirSync(dirname(dbPath), { recursive: true });
+    this.db = new Database(dbPath, { create: true });
+    this.db.run("PRAGMA journal_mode = WAL;");
+    this.db.run("PRAGMA synchronous = NORMAL;");
+    this.db.run("PRAGMA foreign_keys = ON;");
+    this.db.run(CREATE_LOGS_TABLE);
+    this.db.run(CREATE_ACTION_RUNS_TABLE);
+    this.db.run(CREATE_JOBS_TABLE);
+    this.db.exec(CREATE_INDEXES);
+    this.logs = new LogStore(this.db);
+    this.runs = new RunStore(this.db);
+    this.jobs = new JobStore(this.db);
+  }
+  cleanup() {
+    return {
+      logs: this.logs.cleanup(this.retention),
+      runs: this.runs.cleanup(this.retention)
+    };
+  }
+  close() {
+    this.db.close();
+  }
+}
+// src/runtime/executor.ts
+import { Value } from "typebox/value";
+
+// src/runtime/tracer.ts
+class Tracer {
+  logger;
+  store;
+  traceId;
+  session;
+  startTime;
+  actionName;
+  triggerName;
+  triggerType;
+  constructor(title, logger, store) {
+    this.logger = logger;
+    this.store = store;
+    this.traceId = Bun.randomUUIDv7();
+    this.startTime = Date.now();
+    this.session = new LoggerSession(title);
+  }
+  info(label, detail) {
+    this.session.info(label, detail);
+    return this;
+  }
+  step(label, detail) {
+    this.session.step(label, detail);
+    return this;
+  }
+  success(label, detail) {
+    this.session.success(label, detail);
+    return this;
+  }
+  warn(label, detail) {
+    this.session.warn(label, detail);
+    return this;
+  }
+  error(label, detail) {
+    this.session.error(label, detail);
+    return this;
+  }
+  bar() {
+    this.session.bar();
+    return this;
+  }
+  recordStart(opts) {
+    this.actionName = opts.actionName;
+    this.triggerName = opts.triggerName;
+    this.triggerType = opts.triggerType;
+    this.store?.runs.start({
+      trace_id: this.traceId,
+      action_name: opts.actionName,
+      trigger_name: opts.triggerName,
+      trigger_type: opts.triggerType,
+      actor_id: opts.actor.id,
+      actor_type: opts.actor.type,
+      input: opts.input
+    });
+  }
+  end(message, output) {
+    const durationMs = Date.now() - this.startTime;
+    this.session.end(message);
+    this.store?.runs.complete(this.traceId, output, durationMs);
+    this.persistLog("INFO", `${this.actionName ?? "request"} completed`, {
+      durationMs,
+      status: "success"
+    });
+  }
+  fail(message, errorMsg) {
+    const durationMs = Date.now() - this.startTime;
+    this.session.fail(message);
+    this.store?.runs.fail(this.traceId, errorMsg ?? message ?? "Unknown error", durationMs);
+    this.persistLog("ERROR", `${this.actionName ?? "request"} failed`, {
+      durationMs,
+      error: errorMsg,
+      status: "error"
+    });
+  }
+  get elapsed() {
+    return Date.now() - this.startTime;
+  }
+  persistLog(level, message, meta) {
+    try {
+      this.store?.logs.insert({
+        level,
+        message,
+        meta: meta ? JSON.stringify(meta) : null,
+        action_name: this.actionName ?? null,
+        trace_id: this.traceId
+      });
+    } catch {}
+  }
+}
+
+// src/runtime/executor.ts
+class ActionExecutor {
+  baseContext;
+  store;
+  constructor(baseContext) {
+    this.baseContext = baseContext;
+  }
+  setStore(store) {
+    this.store = store;
+  }
+  async execute(action, triggerName, sourceData, tracer) {
+    const config = action.config;
+    const baseLogger = this.baseContext.logger ?? new Logger;
+    const logger = baseLogger.child({
+      action: config.name,
+      trigger: triggerName
+    });
+    const trace = tracer ?? new Tracer(`Action: ${config.name}`, logger, this.store);
+    const trigger = config.triggers?.find((t) => t.name === triggerName);
+    if (!trigger) {
+      trace.error("Trigger", `'${triggerName}' not found`);
+      trace.fail("Bad Request", `Trigger '${triggerName}' not found`);
+      throw new BadRequestError(`Trigger '${triggerName}' not found for action '${config.name}'`);
+    }
+    const actor = await this.resolveActor(trigger, sourceData);
+    trace.info("Trigger", `${trigger.kind} (${triggerName})`).info("Identity", `${actor.id ?? "anonymous"} (${actor.type})`).bar();
+    trace.recordStart({
+      actionName: config.name,
+      triggerName,
+      triggerType: trigger.kind,
+      actor,
+      input: sourceData
+    });
+    const ctx = {
+      ...this.baseContext,
+      traceId: trace.traceId,
+      triggerName,
+      triggerType: trigger.kind,
+      actor,
+      logger
+    };
+    try {
+      let input = sourceData;
+      if (trigger.map) {
+        input = await trigger.map(sourceData);
+      }
+      if (config.input && !Value.Check(config.input, input)) {
+        const errors = [...Value.Errors(config.input, input)];
+        throw new BadRequestError(`Validation Error: ${JSON.stringify(errors)}`);
+      }
+      await this.checkRateLimit(ctx, config);
+      if (config.access) {
+        trace.step("Access", "checking...");
+        await this.checkAccess(ctx, config.access);
+        trace.success("Access", "passed");
+      }
+      if (config.guard) {
+        trace.step("Guard", "checking...");
+        await this.checkGuard(ctx, input, config);
+        trace.success("Guard", "passed");
+      }
+      const result = await action(input, ctx);
+      trace.end("Success", result);
+      return result;
+    } catch (error) {
+      trace.error("Error", error.message);
+      trace.fail("Failed", error.message);
+      throw error;
+    }
+  }
+  async resolveActor(trigger, sourceData) {
+    if (typeof trigger.actor === "function") {
+      return await trigger.actor(sourceData);
+    }
+    if (trigger.actor) {
+      return trigger.actor;
+    }
+    return { type: "public", id: "guest", roles: [] };
+  }
+  async checkRateLimit(ctx, config) {
+    if (!config.rateLimit)
+      return;
+    const rules = this.resolveRateLimitRules(config.rateLimit, ctx.triggerType);
+    if (rules.length === 0)
+      return;
+    for (const rule of rules) {}
+  }
+  resolveRateLimitRules(config, triggerType) {
+    if (!config)
+      return [];
+    let rules;
+    if ("limit" in config || Array.isArray(config)) {
+      rules = config;
+    } else {
+      const structured = config;
+      const specific = structured[triggerType];
+      const common = structured.common;
+      if (specific && common) {
+        const sRules = Array.isArray(specific) ? specific : [specific];
+        const cRules = Array.isArray(common) ? common : [common];
+        return [...cRules, ...sRules];
+      }
+      rules = specific || common;
+    }
+    if (!rules)
+      return [];
+    return Array.isArray(rules) ? rules : [rules];
+  }
+  async checkAccess(ctx, access) {
+    if (ctx.actor.type === "system")
+      return;
+    let config = { ...access.common };
+    if (ctx.triggerType === "api" && access.api) {
+      config = { ...config, ...access.api };
+    } else if (ctx.triggerType === "agent" && access.agent) {
+      config = { ...config, ...access.agent };
+    }
+    if (Object.keys(config).length === 0 && (access.authenticated !== undefined || access.roles)) {
+      config = {
+        authenticated: access.authenticated,
+        roles: access.roles
+      };
+    }
+    if (config.authenticated) {
+      if (ctx.actor.type === "public") {
+        throw new UnauthorizedError("Authentication required");
+      }
+    }
+    if (config.roles && config.roles.length > 0) {
+      if (ctx.actor.type === "public") {
+        throw new UnauthorizedError("Authentication required");
+      }
+      const userRoles = ctx.actor.roles || [];
+      const hasRole = config.roles.some((role) => userRoles.includes(role));
+      if (!hasRole) {
+        throw new ForbiddenError(`User lacks required role(s): ${config.roles.join(", ")}`);
+      }
+    }
+  }
+  async checkGuard(ctx, input, config) {
+    if (!config.guard)
+      return;
+    const guardFn = config.guard[ctx.triggerName] || config.guard[ctx.triggerType];
+    if (guardFn) {
+      const allowed = await guardFn(input, ctx);
+      if (!allowed) {
+        throw new ForbiddenError("Guard check failed");
+      }
+    }
+  }
+}
+
+// src/runtime/event-bus.ts
+class EventBus {
+  subscriptions = [];
+  executor;
+  logger;
+  store;
+  constructor(baseContext, store) {
+    this.executor = new ActionExecutor(baseContext);
+    this.logger = baseContext.logger;
+    this.store = store;
+  }
+  subscribe(pattern, action, triggerName) {
+    this.subscriptions.push({ pattern, action, triggerName });
+  }
+  async publish(event) {
+    const matching = this.subscriptions.filter((sub) => this.matchPattern(sub.pattern, event.type));
+    if (matching.length === 0) {
+      this.logger.debug("No subscribers for event", { eventType: event.type });
+      return;
+    }
+    const results = await Promise.allSettled(matching.map(async (sub) => {
+      const tracer = new Tracer(`Event: ${event.type}`, this.logger, this.store);
+      tracer.bar();
+      tracer.info("Handler", sub.action.config.name);
+      return await this.executor.execute(sub.action, sub.triggerName, event, tracer);
+    }));
+    const failed = results.filter((r) => r.status === "rejected").length;
+    const succeeded = results.filter((r) => r.status === "fulfilled").length;
+    this.logger.info("Event published", {
+      event: event.type,
+      handlers: matching.length,
+      succeeded,
+      failed
+    });
+  }
+  matchPattern(pattern, eventType) {
+    const regex = new RegExp(`^${pattern.replace(/\*/g, ".*").replace(/\?/g, ".")}$`);
+    return regex.test(eventType);
+  }
+}
+
+// src/runtime/http.ts
+class HttpServer {
+  config;
+  logger;
+  server;
+  router;
+  constructor(config, router, logger = new Logger) {
+    this.config = config;
+    this.logger = logger;
+    this.router = router;
+  }
+  async start() {
+    const port = this.config.server?.port || 3000;
+    const host = this.config.server?.host || "localhost";
+    const corsConfig = this.config.server?.cors;
+    this.server = Bun.serve({
+      port,
+      hostname: host,
+      fetch: async (req) => {
+        const url = new URL(req.url);
+        if (req.method === "OPTIONS") {
+          return new Response(null, {
+            status: 204,
+            headers: getCorsHeaders(corsConfig)
+          });
+        }
+        try {
+          const path = url.pathname;
+          const method = req.method;
+          let body;
+          if (["POST", "PUT", "PATCH"].includes(method)) {
+            const contentType = req.headers.get("content-type") || "";
+            if (contentType.includes("application/json")) {
+              body = await req.json();
+            } else if (contentType.includes("application/x-www-form-urlencoded")) {
+              const formData = await req.formData();
+              body = Object.fromEntries(formData.entries());
+            } else if (contentType.includes("multipart/form-data")) {
+              const formData = await req.formData();
+              body = Object.fromEntries(formData.entries());
+            } else {
+              body = await req.text();
+            }
+          }
+          const query = {};
+          url.searchParams.forEach((value, key) => {
+            query[key] = value;
+          });
+          const headers = {};
+          req.headers.forEach((value, key) => {
+            headers[key] = value;
+          });
+          const apiReq = {
+            method,
+            path,
+            params: {},
+            query,
+            body,
+            headers,
+            raw: req
+          };
+          const result = await this.router.handle(apiReq);
+          return new Response(JSON.stringify(result), {
+            status: 200,
+            headers: {
+              "Content-Type": "application/json",
+              ...getCorsHeaders(corsConfig)
+            }
+          });
+        } catch (error) {
+          let status = 500;
+          let message = "Internal Server Error";
+          if (error.name === "BadRequestError") {
+            status = 400;
+            message = error.message;
+          } else if (error.name === "UnauthorizedError") {
+            status = 401;
+            message = error.message;
+          } else if (error.name === "ForbiddenError") {
+            status = 403;
+            message = error.message;
+          } else if (error.message.includes("Route not found")) {
+            status = 404;
+            message = error.message;
+          }
+          return new Response(JSON.stringify({ error: message }), {
+            status,
+            headers: {
+              "Content-Type": "application/json",
+              ...getCorsHeaders(corsConfig)
+            }
+          });
+        }
+      },
+      error: (error) => {
+        this.logger.error("HTTP server error", {
+          error: error.message,
+          stack: error.stack
+        });
+        return new Response(JSON.stringify({ error: "Internal Server Error" }), {
+          status: 500,
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+      }
+    });
+    this.logger.info("HTTP server started", {
+      url: `http://${host}:${port}`
+    });
+  }
+  async stop() {
+    if (this.server) {
+      this.server.stop();
+      this.logger.info("HTTP server stopped");
+    }
+  }
+  getUrl() {
+    if (!this.server)
+      return null;
+    return `http://${this.server.hostname}:${this.server.port}`;
+  }
+}
+function getCorsHeaders(corsConfig) {
+  if (!corsConfig)
+    return {};
+  const headers = {};
+  if (corsConfig.origin) {
+    const origin = Array.isArray(corsConfig.origin) ? corsConfig.origin.join(", ") : corsConfig.origin;
+    headers["Access-Control-Allow-Origin"] = origin;
+  }
+  if (corsConfig.credentials) {
+    headers["Access-Control-Allow-Credentials"] = "true";
+  }
+  headers["Access-Control-Allow-Methods"] = "GET, POST, PUT, PATCH, DELETE, OPTIONS";
+  headers["Access-Control-Allow-Headers"] = "Content-Type, Authorization";
+  return headers;
+}
+
+// src/runtime/mcp-server.ts
+class McpServer {
+  context;
+  logger;
+  constructor(context, logger = new Logger) {
+    this.context = context;
+    this.logger = logger;
+  }
+  register(action, trigger) {
+    this.logger.info("Registering MCP tool", {
+      tool: trigger.tool,
+      action: action.config.name,
+      context: this.context
+    });
+  }
+  async start() {
+    this.logger.info("MCP Server started");
+  }
+  async stop() {
+    this.logger.info("MCP Server stopped");
+  }
+}
+
+// src/runtime/router.ts
+class Router {
+  routes = [];
+  executor;
+  logger;
+  store;
+  constructor(baseContext, store) {
+    this.executor = new ActionExecutor(baseContext);
+    this.logger = baseContext.logger;
+    this.store = store;
+  }
+  register(action, trigger) {
+    const { pattern, paramNames } = this.pathToRegex(trigger.path);
+    this.routes.push({
+      method: trigger.method,
+      pattern,
+      paramNames,
+      action,
+      trigger
+    });
+  }
+  async handle(req) {
+    const tracer = new Tracer(`${req.method} ${req.path}`, this.logger, this.store);
+    tracer.bar();
+    const route = this.match(req.method, req.path);
+    if (!route) {
+      tracer.error("Route", `not found`);
+      tracer.fail("404 Not Found", `Route not found: ${req.method} ${req.path}`);
+      throw new Error(`Route not found: ${req.method} ${req.path}`);
+    }
+    tracer.info("Action", route.action.config.name);
+    const params = {};
+    const match = req.path.match(route.pattern);
+    if (match) {
+      route.paramNames.forEach((name, i) => {
+        params[name] = match[i + 1];
+      });
+    }
+    const fullReq = { ...req, params };
+    return await this.executor.execute(route.action, route.trigger.name, fullReq, tracer);
+  }
+  match(method, path) {
+    return this.routes.find((route) => route.method === method && route.pattern.test(path));
+  }
+  pathToRegex(path) {
+    const paramNames = [];
+    const pattern = path.replace(/:([^/]+)/g, (_, paramName) => {
+      paramNames.push(paramName);
+      return "([^/]+)";
+    });
+    return {
+      pattern: new RegExp(`^${pattern}$`),
+      paramNames
+    };
+  }
+  getRoutes() {
+    return this.routes;
+  }
+}
+
+// src/runtime/scheduler.ts
+import Baker from "cronbake";
+class Scheduler {
+  baker = Baker.create();
+  executor;
+  logger;
+  store;
+  constructor(baseContext, store) {
+    this.executor = new ActionExecutor(baseContext);
+    this.logger = baseContext.logger;
+    this.store = store;
+  }
+  schedule(action, trigger) {
+    const triggerName = trigger.name || "cron";
+    this.store?.jobs.upsert({
+      action_name: action.config.name,
+      trigger_name: triggerName,
+      schedule: trigger.schedule
+    });
+    this.baker.add({
+      name: `${action.config.name}:${triggerName}`,
+      cron: trigger.schedule,
+      callback: async () => {
+        const tracer = new Tracer(`Cron: ${action.config.name}`, this.logger, this.store);
+        tracer.bar();
+        tracer.info("Schedule", trigger.schedule);
+        try {
+          await this.executor.execute(action, triggerName, {}, tracer);
+          this.store?.jobs.recordRun(action.config.name, triggerName);
+        } catch (error) {
+          this.store?.jobs.recordRun(action.config.name, triggerName, error.message);
+        }
+      }
+    });
+  }
+  start() {
+    this.baker.bakeAll();
+    this.logger.info("Scheduler started");
+  }
+  stop() {
+    this.baker.stopAll();
+    this.logger.info("Stopped all cron jobs");
+  }
+}
+
+// src/runtime/server.ts
+class GravityServer {
+  config;
+  router;
+  eventBus;
+  scheduler;
+  mcpServer;
+  httpServer;
+  logger;
+  store;
+  actions = [];
+  constructor(config) {
+    this.config = config;
+    this.logger = new Logger(config.logger ?? {});
+    if (config.store !== null) {
+      this.store = new GravityStore(config.store ?? {});
+      this.logger.setStore(this.store);
+    }
+    const baseContext = this.buildBaseContext();
+    this.router = new Router(baseContext, this.store);
+    this.eventBus = new EventBus(baseContext, this.store);
+    this.scheduler = new Scheduler(baseContext, this.store);
+    this.httpServer = new HttpServer(this.config, this.router, this.logger);
+    if (this.config.mcp?.enabled) {
+      this.mcpServer = new McpServer(baseContext, this.logger);
+    }
+  }
+  buildBaseContext() {
+    return {
+      logger: this.logger,
+      db: undefined,
+      storage: undefined,
+      enqueue: async (eventType, data) => {
+        const event = {
+          id: `evt-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+          type: eventType,
+          data,
+          timestamp: new Date
+        };
+        await this.eventBus.publish(event);
+      },
+      schedule: async (when, action, input) => {
+        await this.scheduleAction(when, action, input);
+      }
+    };
+  }
+  async scheduleAction(when, action, input) {
+    const actionName = action.config.name;
+    if (typeof when === "number") {
+      const runAt = new Date(Date.now() + when * 1000);
+      this.logger.info("Scheduling action", { actionName, runAt, input });
+    } else if (when instanceof Date) {
+      this.logger.info("Scheduling action", { actionName, runAt: when, input });
+    } else if (typeof when === "string") {
+      this.logger.info("Scheduling recurring action", {
+        actionName,
+        cron: when,
+        input
+      });
+    }
+  }
+  async initialize() {
+    this.actions = await loadActions(this.config.actionsDir || "./src/actions", this.logger);
+    for (const action of this.actions) {
+      if (!action.config.triggers)
+        continue;
+      for (const trigger of action.config.triggers) {
+        switch (trigger.kind) {
+          case "api": {
+            const apiTrigger = trigger;
+            this.router.register(action, apiTrigger);
+            this.logger.info("Registered API route", {
+              method: apiTrigger.method,
+              path: apiTrigger.path,
+              action: action.config.name
+            });
+            break;
+          }
+          case "cron": {
+            const cronTrigger = trigger;
+            this.scheduler.schedule(action, cronTrigger);
+            this.logger.info("Registered cron job", {
+              schedule: cronTrigger.schedule,
+              action: action.config.name
+            });
+            break;
+          }
+          case "event": {
+            const eventTrigger = trigger;
+            this.eventBus.subscribe(eventTrigger.event, action, eventTrigger.name);
+            this.logger.info("Registered event handler", {
+              event: eventTrigger.event,
+              action: action.config.name
+            });
+            break;
+          }
+          case "agent": {
+            const agentTrigger = trigger;
+            this.mcpServer?.register(action, agentTrigger);
+            this.logger.info("Registered MCP tool", {
+              tool: agentTrigger.tool,
+              action: action.config.name
+            });
+            break;
+          }
+        }
+      }
+    }
+    this.logger.info("Gravity initialized", {
+      actions: this.actions.length,
+      routes: this.router.getRoutes().length
+    });
+  }
+  async start() {
+    await this.httpServer.start();
+    this.scheduler.start();
+    if (this.mcpServer) {
+      await this.mcpServer.start();
+    }
+  }
+  getRouter() {
+    return this.router;
+  }
+  getEventBus() {
+    return this.eventBus;
+  }
+  getActions() {
+    return this.actions;
+  }
+  getStore() {
+    return this.store;
+  }
+  getHttpUrl() {
+    return this.httpServer.getUrl();
+  }
+  async stop() {
+    await this.httpServer.stop();
+    this.scheduler.stop();
+    await this.mcpServer?.stop();
+    this.store?.close();
+  }
+}
+
+// src/runtime/dev.ts
+async function createDevServer(config) {
+  const logger = new Logger(config.logger ?? {});
+  const server = new GravityServer(config);
+  await server.initialize();
+  if (config.dev?.watch !== false) {
+    const actionsDir = config.actionsDir || "./src/actions";
+    const watcher = watch(actionsDir, { recursive: true }, async (eventType, filename) => {
+      if (!filename)
+        return;
+      if (!/\.(ts|js)$/.test(filename))
+        return;
+      logger.info("Action file changed, regenerating...", {
+        filename,
+        eventType
+      });
+      try {
+        const actions = await loadActions(actionsDir, logger);
+        await generateActionTypes(actions);
+        logger.info("Types regenerated");
+      } catch (error) {
+        logger.error("Failed to regenerate types", {
+          error: error.message
+        });
+      }
+    });
+    process.on("SIGINT", () => {
+      watcher.close();
+      server.stop();
+      process.exit(0);
+    });
+  }
+  return server;
+}
+
+// src/cli/commands/dev.ts
+var devCommand = new Command3("dev").description("Start the development server").option("-p, --port <number>", "Port to listen on", parseInt).action(async (options) => {
+  console.log(`\uD83C\uDF0B Starting Basalt dev server...
+`);
+  const config = await loadConfig();
+  if (options.port) {
+    config.server = { ...config.server, port: options.port };
+  }
+  const actions = await loadActions(config.actionsDir || "./src/actions");
+  console.log("✓ Loaded actions");
+  const server = await createDevServer(config);
+  await server.start();
+  const port = config.server?.port || 3000;
+  const host = config.server?.host || "localhost";
+  console.log(`
+  ✓ Server ready
+  
+    Local:    http://${host}:${port}
+    Actions:  ${actions.length}
+    Watch:    ${config.dev?.watch !== false ? "enabled" : "disabled"}
+  
+  Press Ctrl+C to stop
+    `);
+});
+
+// src/cli/commands/start.ts
+import { Command as Command4 } from "commander";
+var startCommand = new Command4("start").description("Start the production server").action(async () => {
+  console.log("Starting production server...");
+  const config = await loadConfig();
+  const server = new GravityServer(config);
+  await server.initialize();
+  await server.start();
+});
+
+// src/cli/index.ts
+var program = new Command5;
+program.name("basalt").description("Basalt CLI").version("0.1.0");
+program.addCommand(devCommand);
+program.addCommand(buildCommand);
+program.addCommand(startCommand);
+program.addCommand(createActionCommand);
+program.parse(process.argv);