gravity-run 0.0.5 → 0.0.7

package/dist/cli/index.js

@@ -3,9 +3,80 @@ import {
   BadRequestError,
   ForbiddenError,
   UnauthorizedError,
-  globalLogger,
+  __commonJS,
+  __toESM,
   loadConfig
-} from "../shared/chunk-b636e30q.js";
+} from "../shared/chunk-s3hrp89d.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";
@@ -152,17 +223,219 @@ function schemaToTypeString(schema) {
   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;
+  constructor(options = {}, meta = {}, coreListeners = []) {
+    this.options = options;
+    this.meta = meta;
+    this.coreListeners = coreListeners;
+    this.minLevel = options.level ? levelMap[options.level] ?? LEVELS.INFO : LEVELS.INFO;
+  }
+  child(meta) {
+    return new Logger(this.options, { ...this.meta, ...meta }, this.coreListeners);
+  }
+  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 ?? {} };
+    const isVerbose = this.options.verbose ?? false;
+    prettyPrint({ level, time, msg, ...meta }, !isVerbose);
+    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
-import { pathToFileURL } from "node:url";
-import { glob } from "glob";
-async function loadActions(dir) {
-  const files = glob.sync(`**/*.ts`, {
-    cwd: dir,
-    ignore: `**/*.spec.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(pathToFileURL(file).href);
+    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);
@@ -183,34 +456,34 @@ class ActionExecutor {
     this.baseContext = baseContext;
   }
   async execute(action, triggerName, sourceData) {
+    const traceId = Bun.randomUUIDv7();
     const config = action.config;
+    const baseLogger = this.baseContext.logger ?? new Logger;
+    const logger = baseLogger.child({
+      action: config.name,
+      traceId,
+      trigger: triggerName
+    });
     const trigger = config.triggers?.find((t) => t.name === triggerName);
     if (!trigger) {
       throw new BadRequestError(`Trigger '${triggerName}' not found for action '${config.name}'`);
     }
     const actor = await this.resolveActor(trigger, sourceData);
+    const session = logger.session(`Basalt Action: ${config.name}`);
+    session.bar().info("Trigger", `${trigger.kind} (${triggerName})`).info("Identity", `${actor.id ?? "anonymous"} (${actor.type})`).bar();
     const ctx = {
-      requestId: this.baseContext.requestId || `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      traceId,
       triggerName,
       triggerType: trigger.kind,
       actor,
-      logger: this.baseContext.logger || globalLogger,
+      logger,
       db: this.baseContext.db,
       storage: this.baseContext.storage,
-      enqueue: this.baseContext.enqueue || this.createEnqueueFn(),
-      schedule: this.baseContext.schedule || this.createScheduleFn(),
+      enqueue: this.baseContext.enqueue || this.createEnqueueFn(logger),
+      schedule: this.baseContext.schedule || this.createScheduleFn(logger),
       org: this.baseContext.org,
       ...this.baseContext
     };
-    const logger = ctx.logger.child({
-      action: config.name,
-      requestId: ctx.requestId,
-      trigger: triggerName
-    });
-    logger.info("Action execution started", {
-      actor: actor.type,
-      triggerType: trigger.kind
-    });
     try {
       let input = sourceData;
       if (trigger.map) {
@@ -222,17 +495,21 @@ class ActionExecutor {
       }
       await this.checkRateLimit(ctx, config);
       if (config.access) {
+        session.step("Access", "checking...");
         await this.checkAccess(ctx, config.access);
+        session.success("Access", "passed");
+      }
+      if (config.guard) {
+        session.step("Guard", "checking...");
+        await this.checkGuard(ctx, input, config);
+        session.success("Guard", "passed");
       }
-      await this.checkGuard(ctx, input, config);
       const result = await action(input, ctx);
-      logger.info("Action execution completed");
+      session.end("Success");
       return result;
     } catch (error) {
-      logger.error("Action execution failed", {
-        error: error.message,
-        stack: error.stack
-      });
+      session.error("Error", error.message);
+      session.fail("Failed");
       throw error;
     }
   }
@@ -316,17 +593,17 @@ class ActionExecutor {
       }
     }
   }
-  createEnqueueFn() {
+  createEnqueueFn(logger) {
     return async (eventType, data) => {
-      globalLogger.warn("enqueue called but no event bus configured", {
+      logger.warn("enqueue called but no event bus configured", {
         eventType,
         data
       });
     };
   }
-  createScheduleFn() {
+  createScheduleFn(logger) {
     return async (actionName, input, runAt) => {
-      globalLogger.warn("schedule called but no scheduler configured", {
+      logger.warn("schedule called but no scheduler configured", {
         actionName,
         runAt,
         input
@@ -339,8 +616,10 @@ class ActionExecutor {
 class EventBus {
   subscriptions = [];
   executor;
+  logger;
   constructor(baseContext) {
     this.executor = new ActionExecutor(baseContext);
+    this.logger = baseContext.logger;
   }
   subscribe(pattern, action, triggerName) {
     this.subscriptions.push({ pattern, action, triggerName });
@@ -348,14 +627,14 @@ class EventBus {
   async publish(event) {
     const matching = this.subscriptions.filter((sub) => this.matchPattern(sub.pattern, event.type));
     if (matching.length === 0) {
-      globalLogger.debug("No subscribers for event", { eventType: event.type });
+      this.logger.debug("No subscribers for event", { eventType: event.type });
       return;
     }
     const results = await Promise.allSettled(matching.map(async (sub) => {
       try {
         return await this.executor.execute(sub.action, sub.triggerName, event);
       } catch (error) {
-        globalLogger.error("Event handler failed", {
+        this.logger.error("Event handler failed", {
           event: event.type,
           action: sub.action.config.name,
           error: error.message
@@ -365,7 +644,7 @@ class EventBus {
     }));
     const failed = results.filter((r) => r.status === "rejected").length;
     const succeeded = results.filter((r) => r.status === "fulfilled").length;
-    globalLogger.info("Event published", {
+    this.logger.info("Event published", {
       event: event.type,
       handlers: matching.length,
       succeeded,
@@ -381,10 +660,12 @@ class EventBus {
 // src/runtime/http.ts
 class HttpServer {
   config;
+  logger;
   server;
   router;
-  constructor(config, router) {
+  constructor(config, router, logger = new Logger) {
     this.config = config;
+    this.logger = logger;
     this.router = router;
   }
   async start() {
@@ -412,10 +693,10 @@ class HttpServer {
               body = await req.json();
             } else if (contentType.includes("application/x-www-form-urlencoded")) {
               const formData = await req.formData();
-              body = Object.fromEntries(formData);
+              body = Object.fromEntries(formData.entries());
             } else if (contentType.includes("multipart/form-data")) {
               const formData = await req.formData();
-              body = Object.fromEntries(formData);
+              body = Object.fromEntries(formData.entries());
             } else {
               body = await req.text();
             }
@@ -446,7 +727,7 @@ class HttpServer {
             }
           });
         } catch (error) {
-          globalLogger.error("HTTP request failed", {
+          this.logger.error("HTTP request failed", {
             error: error.message,
             stack: error.stack
           });
@@ -474,8 +755,8 @@ class HttpServer {
           });
         }
       },
-      error(error) {
-        globalLogger.error("HTTP server error", {
+      error: (error) => {
+        this.logger.error("HTTP server error", {
           error: error.message,
           stack: error.stack
         });
@@ -487,14 +768,14 @@ class HttpServer {
         });
       }
     });
-    globalLogger.info("HTTP server started", {
+    this.logger.info("HTTP server started", {
       url: `http://${host}:${port}`
     });
   }
   async stop() {
     if (this.server) {
       this.server.stop();
-      globalLogger.info("HTTP server stopped");
+      this.logger.info("HTTP server stopped");
     }
   }
   getUrl() {
@@ -522,21 +803,23 @@ function getCorsHeaders(corsConfig) {
 // src/runtime/mcp-server.ts
 class McpServer {
   context;
-  constructor(context) {
+  logger;
+  constructor(context, logger = new Logger) {
     this.context = context;
+    this.logger = logger;
   }
   register(action, trigger) {
-    globalLogger.info("Registering MCP tool", {
+    this.logger.info("Registering MCP tool", {
       tool: trigger.tool,
       action: action.config.name,
       context: this.context
     });
   }
   async start() {
-    globalLogger.info("MCP Server started");
+    this.logger.info("MCP Server started");
   }
   async stop() {
-    globalLogger.info("MCP Server stopped");
+    this.logger.info("MCP Server stopped");
   }
 }
 
@@ -590,11 +873,7 @@ class Router {
     };
   }
   getRoutes() {
-    return this.routes.map((r) => ({
-      method: r.method,
-      path: r.trigger.path,
-      action: r.action.config.name
-    }));
+    return this.routes;
   }
 }
 
@@ -603,8 +882,10 @@ import Baker from "cronbake";
 class Scheduler {
   baker = Baker.create();
   executor;
+  logger;
   constructor(baseContext) {
     this.executor = new ActionExecutor(baseContext);
+    this.logger = baseContext.logger;
   }
   schedule(action, trigger) {
     this.baker.add({
@@ -612,13 +893,13 @@ class Scheduler {
       cron: trigger.schedule,
       callback: async () => {
         try {
-          globalLogger.info("Running scheduled action", {
+          this.logger.info("Running scheduled action", {
             action: action.config.name,
             schedule: trigger.schedule
           });
           await this.executor.execute(action, trigger.name, {});
         } catch (error) {
-          globalLogger.error("Scheduled action failed", {
+          this.logger.error("Scheduled action failed", {
             action: action.config.name,
             error: error.message,
             stack: error.stack
@@ -629,11 +910,11 @@ class Scheduler {
   }
   start() {
     this.baker.bakeAll();
-    globalLogger.info("Scheduler started");
+    this.logger.info("Scheduler started");
   }
   stop() {
     this.baker.stopAll();
-    globalLogger.info("Stopped all cron jobs");
+    this.logger.info("Stopped all cron jobs");
   }
 }
 
@@ -645,21 +926,23 @@ class BasaltServer {
   scheduler;
   mcpServer;
   httpServer;
+  logger;
   actions = [];
   constructor(config) {
     this.config = config;
+    this.logger = new Logger(config.logger ?? {});
     const baseContext = this.buildBaseContext();
     this.router = new Router(baseContext);
     this.eventBus = new EventBus(baseContext);
     this.scheduler = new Scheduler(baseContext);
-    this.httpServer = new HttpServer(this.config, this.router);
+    this.httpServer = new HttpServer(this.config, this.router, this.logger);
     if (this.config.mcp?.enabled) {
-      this.mcpServer = new McpServer(baseContext);
+      this.mcpServer = new McpServer(baseContext, this.logger);
     }
   }
   buildBaseContext() {
     return {
-      logger: globalLogger,
+      logger: this.logger,
       db: undefined,
       storage: undefined,
       enqueue: async (eventType, data) => {
@@ -680,11 +963,11 @@ class BasaltServer {
     const actionName = action.config.name;
     if (typeof when === "number") {
       const runAt = new Date(Date.now() + when * 1000);
-      globalLogger.info("Scheduling action", { actionName, runAt, input });
+      this.logger.info("Scheduling action", { actionName, runAt, input });
     } else if (when instanceof Date) {
-      globalLogger.info("Scheduling action", { actionName, runAt: when, input });
+      this.logger.info("Scheduling action", { actionName, runAt: when, input });
     } else if (typeof when === "string") {
-      globalLogger.info("Scheduling recurring action", {
+      this.logger.info("Scheduling recurring action", {
         actionName,
         cron: when,
         input
@@ -692,7 +975,7 @@ class BasaltServer {
     }
   }
   async initialize() {
-    this.actions = await loadActions(this.config.actionsDir || "./src/actions");
+    this.actions = await loadActions(this.config.actionsDir || "./src/actions", this.logger);
     for (const action of this.actions) {
       if (!action.config.triggers)
         continue;
@@ -701,7 +984,7 @@ class BasaltServer {
           case "api": {
             const apiTrigger = trigger;
             this.router.register(action, apiTrigger);
-            globalLogger.info("Registered API route", {
+            this.logger.info("Registered API route", {
               method: apiTrigger.method,
               path: apiTrigger.path,
               action: action.config.name
@@ -711,7 +994,7 @@ class BasaltServer {
           case "cron": {
             const cronTrigger = trigger;
             this.scheduler.schedule(action, cronTrigger);
-            globalLogger.info("Registered cron job", {
+            this.logger.info("Registered cron job", {
               schedule: cronTrigger.schedule,
               action: action.config.name
             });
@@ -720,7 +1003,7 @@ class BasaltServer {
           case "event": {
             const eventTrigger = trigger;
             this.eventBus.subscribe(eventTrigger.event, action, eventTrigger.name);
-            globalLogger.info("Registered event handler", {
+            this.logger.info("Registered event handler", {
               event: eventTrigger.event,
               action: action.config.name
             });
@@ -729,7 +1012,7 @@ class BasaltServer {
           case "agent": {
             const agentTrigger = trigger;
             this.mcpServer?.register(action, agentTrigger);
-            globalLogger.info("Registered MCP tool", {
+            this.logger.info("Registered MCP tool", {
               tool: agentTrigger.tool,
               action: action.config.name
             });
@@ -738,7 +1021,7 @@ class BasaltServer {
         }
       }
     }
-    globalLogger.info("Basalt initialized", {
+    this.logger.info("Basalt initialized", {
       actions: this.actions.length,
       routes: this.router.getRoutes().length
     });
@@ -771,6 +1054,7 @@ class BasaltServer {
 
 // src/runtime/dev.ts
 async function createDevServer(config) {
+  const logger = new Logger(config.logger ?? {});
   const server = new BasaltServer(config);
   await server.initialize();
   if (config.dev?.watch !== false) {
@@ -780,16 +1064,16 @@ async function createDevServer(config) {
         return;
       if (!/\.(ts|js)$/.test(filename))
         return;
-      globalLogger.info("Action file changed, regenerating...", {
+      logger.info("Action file changed, regenerating...", {
         filename,
         eventType
       });
       try {
-        const actions = await loadActions(actionsDir);
+        const actions = await loadActions(actionsDir, logger);
         await generateActionTypes(actions);
-        globalLogger.info("Types regenerated");
+        logger.info("Types regenerated");
       } catch (error) {
-        globalLogger.error("Failed to regenerate types", {
+        logger.error("Failed to regenerate types", {
           error: error.message
         });
       }

package/dist/index.d.ts

@@ -1,5 +1,11 @@
 type DatabaseConfig = {};
-type LoggerOptions = {};
+type LogLevel = "debug" | "info" | "warn" | "error" | "critical";
+type LoggerOptions = {
+	/** Minimum log level (default: 'info') */
+	level?: LogLevel;
+	/** Show verbose output with metadata details (default: false) */
+	verbose?: boolean;
+};
 type StorageConfig = {};
 interface BasaltConfig {
 	/**
@@ -76,6 +82,32 @@ declare function loadConfig(): Promise<BasaltConfig>;
 declare function defineConfig(config: BasaltConfig): BasaltConfig;
 import { TSchema as TSchema2 } from "typebox";
 import { Static, TSchema } from "typebox";
+/**
+* A structured logging session with clack-style box-drawing output.
+* Created via `logger.session("title")`.
+*/
+declare class LoggerSession {
+	private output;
+	private startTime;
+	constructor(title: string, output?: NodeJS.WritableStream);
+	private write;
+	/** Static info line: ◇  label: detail */
+	info(label: string, detail?: string): this;
+	/** In-progress step: ●  label: detail */
+	step(label: string, detail?: string): this;
+	/** Completed step: ✔  label: detail */
+	success(label: string, detail?: string): this;
+	/** Warning step: ▲  label: detail */
+	warn(label: string, detail?: string): this;
+	/** Error step: ✖  label: detail */
+	error(label: string, detail?: string): this;
+	/** Empty separator bar: │ */
+	bar(): this;
+	/** Close the session with success: └  message (Xms) */
+	end(message?: string): void;
+	/** Close the session as error: └  message (Xms) */
+	fail(message?: string): void;
+}
 declare const LEVELS: {
 	readonly DEBUG: 10;
 	readonly INFO: 20;
@@ -83,15 +115,20 @@ declare const LEVELS: {
 	readonly ERROR: 40;
 	readonly CRITICAL: 50;
 };
-type LogLevel = keyof typeof LEVELS;
-type LogListener = (level: LogLevel, msg: string, args?: unknown) => void;
+type LogLevel2 = keyof typeof LEVELS;
+type LogListener = (level: LogLevel2, msg: string, args?: unknown) => void;
 declare class Logger {
-	readonly isVerbose: boolean;
+	private readonly options;
 	private readonly meta;
 	private readonly coreListeners;
 	private readonly listeners;
-	constructor(isVerbose?: boolean, meta?: Record<string, unknown>, coreListeners?: LogListener[]);
+	private readonly minLevel;
+	constructor(options?: LoggerOptions, meta?: Record<string, unknown>, coreListeners?: LogListener[]);
+	/** Create a child logger with additional metadata */
 	child(meta: Record<string, unknown>): Logger;
+	/** Start a structured logging session with clack-style output */
+	session(title: string): LoggerSession;
+	private shouldLog;
 	private _log;
 	info(message: string, args?: unknown): void;
 	error(message: string, args?: unknown): void;
@@ -128,7 +165,7 @@ interface ApiTrigger extends BaseTrigger<"api"> {
 interface ApiRequest {
 	method: string;
 	path: string;
-	params: Record<string, string>;
+	params: Record<string, string | undefined>;
 	query: Record<string, string>;
 	body: unknown;
 	headers: Record<string, string>;
@@ -256,7 +293,7 @@ type BaseActionContext = {
 	logger: Logger;
 	triggerName: string;
 	triggerType: TriggerKind;
-	requestId: string;
+	traceId: string;
 };
 type ExtendActionContext = {};
 type ActionContext = BaseActionContext & ExtendActionContext;

package/dist/index.js

@@ -7,9 +7,8 @@ import {
   NotFoundError,
   UnauthorizedError,
   defineConfig,
-  globalLogger,
   loadConfig
-} from "./shared/chunk-b636e30q.js";
+} from "./shared/chunk-s3hrp89d.js";
 // src/core/action.ts
 import { Value } from "typebox/value";
 function resolveRateLimitRules(config, triggerType) {
@@ -85,8 +84,6 @@ async function checkGuard(ctx, input, config) {
 }
 function action(config, handler) {
   const wrapped = async (input, ctx) => {
-    const logger = ctx.log ? ctx.log.child({ action: config.name, requestId: ctx.requestId }) : globalLogger.child({ action: config.name, requestId: ctx.requestId });
-    logger.info("Action started", { input, trigger: ctx.triggerName });
     try {
       if (config.input && !Value.Check(config.input, input)) {
         const errors = [...Value.Errors(config.input, input)];
@@ -97,14 +94,8 @@ function action(config, handler) {
         await checkAccess(ctx, config.access);
       }
       await checkGuard(ctx, input, config);
-      const result = await handler(input, ctx);
-      logger.info("Action completed successfully");
-      return result;
+      return await handler(input, ctx);
     } catch (error) {
-      logger.error("Action failed", {
-        error: error.message,
-        stack: error.stack
-      });
       throw error;
     }
   };

package/dist/shared/chunk-s3hrp89d.js

@@ -0,0 +1,79 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// src/config/loader.ts
+function loadConfig() {
+  return Promise.resolve({});
+}
+
+// src/config/index.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/utils/errors.ts
+class BasaltError extends Error {
+  code;
+  status;
+  constructor(message, code, status) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class NotFoundError extends BasaltError {
+  constructor(message = "Resource not found") {
+    super(message, "NOT_FOUND", 404);
+  }
+}
+
+class UnauthorizedError extends BasaltError {
+  constructor(message = "Unauthorized") {
+    super(message, "UNAUTHORIZED", 401);
+  }
+}
+
+class ForbiddenError extends BasaltError {
+  constructor(message = "Forbidden") {
+    super(message, "FORBIDDEN", 403);
+  }
+}
+
+class BadRequestError extends BasaltError {
+  constructor(message = "Bad Request") {
+    super(message, "BAD_REQUEST", 400);
+  }
+}
+
+class InternalServerError extends BasaltError {
+  constructor(message = "Internal Server Error") {
+    super(message, "INTERNAL_SERVER_ERROR", 500);
+  }
+}
+
+class NonRetriableError extends BasaltError {
+  constructor(message) {
+    super(message, "NON_RETRIABLE_ERROR", 500);
+  }
+}
+
+export { __toESM, __commonJS, loadConfig, defineConfig, BasaltError, NotFoundError, UnauthorizedError, ForbiddenError, BadRequestError, InternalServerError, NonRetriableError };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gravity-run",
-	"version": "0.0.5",
+	"version": "0.0.7",
 	"description": "A framework for building scalable applications",
 	"homepage": "https://github.com/alihussnainrb/gravity#readme",
 	"bugs": {
@@ -80,6 +80,7 @@
 		"cronbake": "^0.4.0",
 		"glob": "^13.0.1",
 		"inquirer": "^13.2.2",
+		"is-unicode-supported": "^2.1.0",
 		"typebox": "^1.0.81"
 	}
 }

package/dist/shared/chunk-b636e30q.js

@@ -1,274 +0,0 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-
-// 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/config/loader.ts
-function loadConfig() {
-  return Promise.resolve({});
-}
-
-// src/config/index.ts
-function defineConfig(config) {
-  return config;
-}
-
-// src/utils/errors.ts
-class BasaltError extends Error {
-  code;
-  status;
-  constructor(message, code, status) {
-    super(message);
-    this.code = code;
-    this.status = status;
-    this.name = this.constructor.name;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-}
-
-class NotFoundError extends BasaltError {
-  constructor(message = "Resource not found") {
-    super(message, "NOT_FOUND", 404);
-  }
-}
-
-class UnauthorizedError extends BasaltError {
-  constructor(message = "Unauthorized") {
-    super(message, "UNAUTHORIZED", 401);
-  }
-}
-
-class ForbiddenError extends BasaltError {
-  constructor(message = "Forbidden") {
-    super(message, "FORBIDDEN", 403);
-  }
-}
-
-class BadRequestError extends BasaltError {
-  constructor(message = "Bad Request") {
-    super(message, "BAD_REQUEST", 400);
-  }
-}
-
-class InternalServerError extends BasaltError {
-  constructor(message = "Internal Server Error") {
-    super(message, "INTERNAL_SERVER_ERROR", 500);
-  }
-}
-
-class NonRetriableError extends BasaltError {
-  constructor(message) {
-    super(message, "NON_RETRIABLE_ERROR", 500);
-  }
-}
-
-// src/logger/pretty-print.ts
-var import_picocolors = __toESM(require_picocolors(), 1);
-var stepTag = (step) => step ? import_picocolors.default.bold(import_picocolors.default.cyan(step)) : "";
-var timestampTag = (timestamp) => import_picocolors.default.gray(timestamp);
-var traceIdTag = (traceId) => traceId ? import_picocolors.default.gray(traceId) : "";
-var levelTags = {
-  error: import_picocolors.default.red("[ERROR]"),
-  info: import_picocolors.default.blue("[INFO]"),
-  warn: import_picocolors.default.yellow("[WARN]"),
-  debug: import_picocolors.default.gray("[DEBUG]")
-};
-var numericTag = (value) => import_picocolors.default.green(value);
-var stringTag = (value) => import_picocolors.default.cyan(value);
-var booleanTag = (value) => import_picocolors.default.blue(value);
-var arrayBrackets = ["[", "]"].map((s) => import_picocolors.default.gray(s));
-var objectBrackets = ["{", "}"].map((s) => import_picocolors.default.gray(s));
-var prettyPrintObject = (obj, depth = 0, parentIsLast = false, prefix = "") => {
-  const tab = prefix + (depth === 0 ? "" : parentIsLast ? "│ " : "│ ");
-  if (depth > 2)
-    return `${tab} └ ${import_picocolors.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] ?? 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
-};
-var getLogLevel = () => {
-  const level = process.env.LOG_LEVEL ?? "info";
-  return levelMap[level] ?? LEVELS.INFO;
-};
-var shouldLog = (messageLevel) => {
-  return messageLevel >= getLogLevel();
-};
-
-class Logger {
-  isVerbose;
-  meta;
-  coreListeners;
-  listeners = [];
-  constructor(isVerbose = false, meta = {}, coreListeners = []) {
-    this.isVerbose = isVerbose;
-    this.meta = meta;
-    this.coreListeners = coreListeners;
-  }
-  child(meta) {
-    return new Logger(this.isVerbose, { ...this.meta, ...meta }, this.coreListeners);
-  }
-  _log(level, msg, args) {
-    const time = Date.now();
-    const meta = { ...this.meta, ...args ?? {} };
-    prettyPrint({ level, time, msg, ...meta }, !this.isVerbose);
-    this.coreListeners.forEach((listener) => {
-      listener(level, msg, meta);
-    });
-    this.listeners.forEach((listener) => {
-      listener(level, msg, meta);
-    });
-  }
-  info(message, args) {
-    if (shouldLog(LEVELS.INFO))
-      this._log("INFO", message, args);
-  }
-  error(message, args) {
-    if (shouldLog(LEVELS.ERROR))
-      this._log("ERROR", message, args);
-  }
-  debug(message, args) {
-    if (shouldLog(LEVELS.DEBUG))
-      this._log("DEBUG", message, args);
-  }
-  warn(message, args) {
-    if (shouldLog(LEVELS.WARNING))
-      this._log("WARNING", message, args);
-  }
-  addListener(listener) {
-    this.listeners.push(listener);
-  }
-}
-var globalLogger = new Logger;
-export { loadConfig, defineConfig, globalLogger, BasaltError, NotFoundError, UnauthorizedError, ForbiddenError, BadRequestError, InternalServerError, NonRetriableError };