gravity-run 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,398 @@
+type DatabaseConfig = {};
+type LoggerOptions = {};
+type StorageConfig = {};
+interface BasaltConfig {
+	/**
+	* Project name (used for logging, defaults, etc.)
+	*/
+	name?: string;
+	/**
+	* Server configuration
+	*/
+	server?: {
+		port?: number;
+		host?: string;
+		cors?: {
+			origin?: string | string[];
+			credentials?: boolean;
+		};
+	};
+	/**
+	* Database configuration
+	*/
+	db?: DatabaseConfig;
+	/**
+	* Storage configuration
+	*/
+	storage?: StorageConfig;
+	/**
+	* Authentication configuration
+	*/
+	/**
+	* Logger configuration
+	*/
+	logger?: LoggerOptions;
+	/**
+	* Actions directory (default: './src/actions' or './actions')
+	*/
+	actionsDir?: string;
+	/**
+	* OpenAPI/docs generation
+	*/
+	docs?: {
+		enabled?: boolean;
+		path?: string;
+		title?: string;
+		version?: string;
+	};
+	/**
+	* MCP server configuration
+	*/
+	mcp?: {
+		enabled?: boolean;
+		name?: string;
+		version?: string;
+	};
+	/**
+	* Development server options
+	*/
+	dev?: {
+		watch?: boolean;
+		hmr?: boolean;
+	};
+	/**
+	* Custom middleware or hooks
+	*/
+	plugins?: BasaltPlugin[];
+}
+interface BasaltPlugin {
+	name: string;
+	setup: (context: BasaltPluginContext) => Promise<void> | void;
+}
+interface BasaltPluginContext {
+	config: BasaltConfig;
+}
+declare function loadConfig(): Promise<BasaltConfig>;
+declare function defineConfig(config: BasaltConfig): BasaltConfig;
+import { TSchema as TSchema2 } from "typebox";
+import { Static, TSchema } from "typebox";
+declare const LEVELS: {
+	readonly DEBUG: 10;
+	readonly INFO: 20;
+	readonly WARNING: 30;
+	readonly ERROR: 40;
+	readonly CRITICAL: 50;
+};
+type LogLevel = keyof typeof LEVELS;
+type LogListener = (level: LogLevel, msg: string, args?: unknown) => void;
+declare class Logger {
+	readonly isVerbose: boolean;
+	private readonly meta;
+	private readonly coreListeners;
+	private readonly listeners;
+	constructor(isVerbose?: boolean, meta?: Record<string, unknown>, coreListeners?: LogListener[]);
+	child(meta: Record<string, unknown>): Logger;
+	private _log;
+	info(message: string, args?: unknown): void;
+	error(message: string, args?: unknown): void;
+	debug(message: string, args?: unknown): void;
+	warn(message: string, args?: unknown): void;
+	addListener(listener: LogListener): void;
+}
+/**
+* The Standard Identity Structure for Basalt
+*/
+interface BasaltActor {
+	type: "user" | "agent" | "system" | "public";
+	id?: string;
+	name?: string;
+	roles?: string[];
+	metadata?: Record<string, unknown>;
+}
+type Actor = BasaltActor;
+type TriggerKind = "api" | "agent" | "cron" | "event" | "custom";
+/**
+* The Unified Trigger Contract
+*/
+interface BasaltTrigger<
+	TName extends string,
+	TInput
+> {
+	readonly name: TName;
+	readonly kind: TriggerKind;
+	readonly config: any;
+	/** Transforms source data to Action Input */
+	readonly map: (source: any) => TInput | Promise<TInput>;
+	/** Defines who is performing the action for this trigger */
+	readonly actor?: BasaltActor | ((source: any) => BasaltActor | Promise<BasaltActor>);
+}
+declare const trigger: {
+	api: <T>(options: {
+		method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+		path?: string;
+		map: (req: Request) => T | Promise<T>;
+		actor?: BasaltActor | ((req: Request) => BasaltActor | Promise<BasaltActor>);
+	}) => BasaltTrigger<"api", T>;
+	cron: <T>(options: {
+		schedule: string;
+		input: T;
+		actor?: BasaltActor;
+	}) => BasaltTrigger<"cron", T>;
+	event: <T>(options: {
+		name: string;
+		map: (payload: any) => T | Promise<T>;
+		actor?: BasaltActor | ((payload: any) => BasaltActor | Promise<BasaltActor>);
+	}) => BasaltTrigger<"event", T>;
+	agent: <T>(options?: {
+		name?: string;
+		map?: (args: any) => T | Promise<T>;
+		actor?: BasaltActor;
+	}) => BasaltTrigger<"agent", T>;
+	custom: <
+		TName extends string,
+		T
+	>(options: {
+		name: TName;
+		map: (source: any) => T | Promise<T>;
+		actor: BasaltActor;
+	}) => BasaltTrigger<TName, T>;
+};
+interface Organization {
+	id: string;
+	plan?: string;
+	[key: string]: any;
+}
+interface JobOptions {
+	delay?: string | number;
+}
+type BaseActionContext = {
+	actor: BasaltActor;
+	org?: Organization;
+	db: any;
+	storage: any;
+	enqueue: (event: string, input: any) => void | Promise<void>;
+	schedule: <
+		TInput extends TSchema,
+		TOutput extends TSchema
+	>(when: number | Date | string, action: Action<TInput, TOutput>, input: Static<TInput>) => void | Promise<void>;
+	logger: Logger;
+	triggerName: string;
+	triggerType: TriggerKind;
+	requestId: string;
+};
+type ExtendActionContext = {};
+type ActionContext = BaseActionContext & ExtendActionContext;
+interface RateLimitRule {
+	/** How many requests */
+	limit: number;
+	/** Time window, e.g., "1s", "1m", "1h" */
+	window: string;
+	/** What to group by: 'actor' (user), 'org' (tenant), or 'ip' (guest) */
+	by: "actor" | "org" | "ip";
+	/** Optional: custom identifier, e.g., 'ai-budget' */
+	name?: string;
+}
+type RateLimitConfig = RateLimitRule | RateLimitRule[];
+type ActionRateLimit = RateLimitConfig | {
+	common?: RateLimitConfig;
+	api?: RateLimitConfig;
+	agent?: RateLimitConfig;
+	[key: string]: RateLimitConfig | undefined;
+};
+interface AccessConfig {
+	common?: {
+		authenticated?: boolean;
+	};
+	api?: {
+		roles?: string[];
+	};
+	agent?: {
+		authenticated?: boolean;
+	};
+	authenticated?: boolean;
+	roles?: string[];
+}
+type GuardFunction<TInput> = (input: TInput, ctx: ActionContext) => boolean | Promise<boolean>;
+interface GuardConfig<TInput> {
+	api?: GuardFunction<TInput>;
+	event?: GuardFunction<TInput>;
+	cron?: GuardFunction<TInput>;
+	agent?: GuardFunction<TInput>;
+	[key: string]: GuardFunction<TInput> | undefined;
+}
+interface ActionConfig<
+	TInput extends TSchema = TSchema,
+	TOutput extends TSchema = TSchema
+> {
+	name: string;
+	description?: string;
+	input?: TInput;
+	output?: TOutput;
+	triggers?: BasaltTrigger<string, Static<TInput>>[];
+	access?: AccessConfig;
+	guard?: GuardConfig<Static<TInput>>;
+	rateLimit?: ActionRateLimit;
+}
+type ActionHandler<
+	TInput extends TSchema,
+	TOutput extends TSchema
+> = (input: Static<TInput>, ctx: ActionContext) => Promise<Static<TOutput>>;
+interface Action<
+	TInput extends TSchema = TSchema,
+	TOutput extends TSchema = TSchema
+> {
+	config: ActionConfig<TInput, TOutput>;
+	handler: ActionHandler<TInput, TOutput>;
+	(input: Static<TInput>, ctx: ActionContext): Promise<Static<TOutput>>;
+}
+declare function action<
+	TInput extends TSchema2 = TSchema2,
+	TOutput extends TSchema2 = TSchema2
+>(config: ActionConfig<TInput, TOutput>, handler: ActionHandler<TInput, TOutput>): Action<TInput, TOutput>;
+type TriggerKind2 = "api" | "cron" | "event" | "agent";
+interface BaseTrigger<TKind extends TriggerKind2 = TriggerKind2> {
+	kind: TKind;
+	name: string;
+	/**
+	* Transform source data into action input
+	*/
+	map?: (source: never) => unknown | Promise<unknown>;
+	/**
+	* Resolve actor from source data or provide static actor
+	*/
+	actor?: BasaltActor | ((source: never) => BasaltActor | Promise<BasaltActor>);
+}
+interface ApiTrigger extends BaseTrigger<"api"> {
+	method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+	path: string;
+	/**
+	* Map HTTP request to action input
+	* Default: body for POST/PUT/PATCH, query for GET/DELETE
+	*/
+	map?: (req: ApiRequest) => unknown | Promise<unknown>;
+	/**
+	* Extract actor from request (session, JWT, API key, etc.)
+	*/
+	actor?: BasaltActor | ((req: ApiRequest) => BasaltActor | Promise<BasaltActor>);
+}
+interface ApiRequest {
+	method: string;
+	path: string;
+	params: Record<string, string>;
+	query: Record<string, string>;
+	body: unknown;
+	headers: Record<string, string>;
+	raw?: unknown;
+}
+interface CronTrigger extends BaseTrigger<"cron"> {
+	/**
+	* Cron expression (e.g., '0 * * * *')
+	*/
+	schedule: string;
+	/**
+	* Timezone (default: UTC)
+	*/
+	timezone?: string;
+	/**
+	* Provide static input for cron jobs
+	*/
+	map?: () => unknown | Promise<unknown>;
+}
+interface EventTrigger extends BaseTrigger<"event"> {
+	/**
+	* Event pattern to match (e.g., 'order.created', 'user.*')
+	*/
+	event: string;
+	/**
+	* Map event payload to action input
+	*/
+	map?: (event: BasaltEvent) => unknown | Promise<unknown>;
+	/**
+	* Extract actor from event metadata
+	*/
+	actor?: BasaltActor | ((event: BasaltEvent) => BasaltActor | Promise<BasaltActor>);
+}
+interface BasaltEvent<T = unknown> {
+	id: string;
+	type: string;
+	data: T;
+	timestamp: Date;
+	actor?: BasaltActor;
+	metadata?: Record<string, unknown>;
+}
+interface AgentTrigger extends BaseTrigger<"agent"> {
+	/**
+	* MCP tool name
+	*/
+	tool: string;
+	/**
+	* Tool description for LLM
+	*/
+	description: string;
+	/**
+	* Map MCP call arguments to action input
+	*/
+	map?: (args: Record<string, unknown>) => unknown | Promise<unknown>;
+	/**
+	* Extract actor from MCP context
+	*/
+	actor?: BasaltActor | ((context: McpContext) => BasaltActor | Promise<BasaltActor>);
+}
+interface McpContext {
+	toolName: string;
+	args: Record<string, unknown>;
+	sessionId?: string;
+	metadata?: Record<string, unknown>;
+}
+type Trigger = ApiTrigger | CronTrigger | EventTrigger | AgentTrigger;
+type ApiTriggerOptions = {
+	map?: (req: ApiRequest) => unknown | Promise<unknown>;
+	actor?: BasaltActor | ((req: ApiRequest) => BasaltActor | Promise<BasaltActor>);
+};
+type ApiTriggerBuilder = {
+	(method: ApiTrigger["method"], path: string, options?: ApiTriggerOptions): ApiTrigger;
+	get: (path: string, options?: Omit<ApiTriggerOptions, never>) => ApiTrigger;
+	post: (path: string, options?: Omit<ApiTriggerOptions, never>) => ApiTrigger;
+	put: (path: string, options?: Omit<ApiTriggerOptions, never>) => ApiTrigger;
+	patch: (path: string, options?: Omit<ApiTriggerOptions, never>) => ApiTrigger;
+	delete: (path: string, options?: Omit<ApiTriggerOptions, never>) => ApiTrigger;
+};
+declare const api: ApiTriggerBuilder;
+declare function cron(schedule: string, options?: {
+	timezone?: string;
+	map?: () => unknown | Promise<unknown>;
+	actor?: BasaltActor;
+}): CronTrigger;
+declare function event(eventPattern: string, options?: {
+	map?: (event: BasaltEvent) => unknown | Promise<unknown>;
+	actor?: BasaltActor | ((event: BasaltEvent) => BasaltActor | Promise<BasaltActor>);
+}): EventTrigger;
+declare function agent(tool: string, description: string, options?: {
+	map?: (args: Record<string, unknown>) => unknown | Promise<unknown>;
+	actor?: BasaltActor | ((context: McpContext) => BasaltActor | Promise<BasaltActor>);
+}): AgentTrigger;
+declare class BasaltError extends Error {
+	code: string;
+	status: number;
+	constructor(message: string, code: string, status: number);
+}
+declare class NotFoundError extends BasaltError {
+	constructor(message?: string);
+}
+declare class UnauthorizedError extends BasaltError {
+	constructor(message?: string);
+}
+declare class ForbiddenError extends BasaltError {
+	constructor(message?: string);
+}
+declare class BadRequestError extends BasaltError {
+	constructor(message?: string);
+}
+declare class InternalServerError extends BasaltError {
+	constructor(message?: string);
+}
+declare class NonRetriableError extends BasaltError {
+	constructor(message: string);
+}
+import { Type } from "typebox";
+export { trigger, Type as t, loadConfig, event, defineConfig, cron, api, agent, action, UnauthorizedError, Trigger, RateLimitRule, RateLimitConfig, Organization, NotFoundError, NonRetriableError, McpContext, JobOptions, InternalServerError, GuardFunction, GuardConfig, ForbiddenError, ExtendActionContext, EventTrigger, CronTrigger, BaseTrigger, BaseActionContext, BasaltTrigger, BasaltEvent, BasaltError, BasaltActor, BadRequestError, ApiTrigger, ApiRequest, AgentTrigger, Actor, ActionRateLimit, ActionHandler, ActionContext, ActionConfig, Action, AccessConfig };

package/dist/index.js

@@ -0,0 +1,212 @@
+import {
+  BadRequestError,
+  BasaltError,
+  ForbiddenError,
+  InternalServerError,
+  NonRetriableError,
+  NotFoundError,
+  UnauthorizedError,
+  defineConfig,
+  globalLogger,
+  loadConfig
+} from "./shared/chunk-b636e30q.js";
+// src/core/action.ts
+import { Value } from "typebox/value";
+function 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 function checkRateLimit(ctx, config) {
+  if (!config.rateLimit)
+    return;
+  const rules = resolveRateLimitRules(config.rateLimit, ctx.triggerType);
+  if (rules.length === 0)
+    return;
+  for (const rule of rules) {}
+}
+async function 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 function 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");
+    }
+  }
+}
+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)];
+        throw new BadRequestError(`Validation Error: ${JSON.stringify(errors)}`);
+      }
+      await checkRateLimit(ctx, config);
+      if (config.access) {
+        await checkAccess(ctx, config.access);
+      }
+      await checkGuard(ctx, input, config);
+      const result = await handler(input, ctx);
+      logger.info("Action completed successfully");
+      return result;
+    } catch (error) {
+      logger.error("Action failed", {
+        error: error.message,
+        stack: error.stack
+      });
+      throw error;
+    }
+  };
+  wrapped.config = config;
+  wrapped.handler = handler;
+  return wrapped;
+}
+// src/core/types.ts
+var trigger = {
+  api: (options) => ({
+    name: "api",
+    kind: "api",
+    config: options,
+    map: options.map,
+    actor: options.actor
+  }),
+  cron: (options) => ({
+    name: "cron",
+    kind: "cron",
+    config: options,
+    map: () => options.input,
+    actor: options.actor ?? { type: "system", name: "Basalt Scheduler" }
+  }),
+  event: (options) => ({
+    name: "event",
+    kind: "event",
+    config: options,
+    map: options.map,
+    actor: options.actor
+  }),
+  agent: (options = {}) => ({
+    name: "agent",
+    kind: "agent",
+    config: options,
+    map: options.map || ((args) => args),
+    actor: options.actor
+  }),
+  custom: (options) => ({
+    name: options.name,
+    kind: "custom",
+    config: options,
+    map: options.map,
+    actor: options.actor
+  })
+};
+// src/triggers/index.ts
+var api = (method, path, options) => {
+  return {
+    kind: "api",
+    name: `api:${method}:${path}`,
+    method,
+    path,
+    ...options
+  };
+};
+api.get = (path, options) => api("GET", path, options);
+api.post = (path, options) => api("POST", path, options);
+api.put = (path, options) => api("PUT", path, options);
+api.patch = (path, options) => api("PATCH", path, options);
+api.delete = (path, options) => api("DELETE", path, options);
+function cron(schedule, options) {
+  return {
+    kind: "cron",
+    name: `cron:${schedule}`,
+    schedule,
+    ...options
+  };
+}
+function event(eventPattern, options) {
+  return {
+    kind: "event",
+    name: `event:${eventPattern}`,
+    event: eventPattern,
+    ...options
+  };
+}
+function agent(tool, description, options) {
+  return {
+    kind: "agent",
+    name: `agent:${tool}`,
+    tool,
+    description,
+    ...options
+  };
+}
+// src/utils/typebox.ts
+import { Type } from "typebox";
+export {
+  trigger,
+  Type as t,
+  loadConfig,
+  event,
+  defineConfig,
+  cron,
+  api,
+  agent,
+  action,
+  UnauthorizedError,
+  NotFoundError,
+  NonRetriableError,
+  InternalServerError,
+  ForbiddenError,
+  BasaltError,
+  BadRequestError
+};