gravity-run 0.0.2

package/dist/cli/index.js

@@ -0,0 +1,845 @@
+#!/usr/bin/env node
+import {
+  BadRequestError,
+  ForbiddenError,
+  UnauthorizedError,
+  globalLogger,
+  loadConfig
+} from "../shared/chunk-b636e30q.js";
+
+// 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 = ".basalt") {
+  const typeMap = {};
+  for (const action of actions) {
+    const inputType = schemaToTypeString(action.config.input);
+    typeMap[action.config.name] = inputType;
+  }
+  const dts = `
+// Auto-generated by Basalt - DO NOT EDIT
+// Generated at ${new Date().toISOString()}
+
+declare module 'basalt/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/runtime/loader.ts
+import { pathToFileURL } from "node:url";
+async function loadActions(dir) {
+  const glob = new Bun.Glob(`${dir}/**/*.ts`);
+  const files = glob.scanSync();
+  const actions = [];
+  for (const file of files) {
+    const module = await import(pathToFileURL(file).href);
+    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/runtime/executor.ts
+import { Value } from "typebox/value";
+class ActionExecutor {
+  baseContext;
+  constructor(baseContext) {
+    this.baseContext = baseContext;
+  }
+  async execute(action, triggerName, sourceData) {
+    const config = action.config;
+    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 ctx = {
+      requestId: this.baseContext.requestId || `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      triggerName,
+      triggerType: trigger.kind,
+      actor,
+      logger: this.baseContext.logger || globalLogger,
+      db: this.baseContext.db,
+      storage: this.baseContext.storage,
+      enqueue: this.baseContext.enqueue || this.createEnqueueFn(),
+      schedule: this.baseContext.schedule || this.createScheduleFn(),
+      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) {
+        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) {
+        await this.checkAccess(ctx, config.access);
+      }
+      await this.checkGuard(ctx, input, config);
+      const result = await action(input, ctx);
+      logger.info("Action execution completed");
+      return result;
+    } catch (error) {
+      logger.error("Action execution failed", {
+        error: error.message,
+        stack: error.stack
+      });
+      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");
+      }
+    }
+  }
+  createEnqueueFn() {
+    return async (eventType, data) => {
+      globalLogger.warn("enqueue called but no event bus configured", {
+        eventType,
+        data
+      });
+    };
+  }
+  createScheduleFn() {
+    return async (actionName, input, runAt) => {
+      globalLogger.warn("schedule called but no scheduler configured", {
+        actionName,
+        runAt,
+        input
+      });
+    };
+  }
+}
+
+// src/runtime/event-bus.ts
+class EventBus {
+  subscriptions = [];
+  executor;
+  constructor(baseContext) {
+    this.executor = new ActionExecutor(baseContext);
+  }
+  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) {
+      globalLogger.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", {
+          event: event.type,
+          action: sub.action.config.name,
+          error: error.message
+        });
+        throw error;
+      }
+    }));
+    const failed = results.filter((r) => r.status === "rejected").length;
+    const succeeded = results.filter((r) => r.status === "fulfilled").length;
+    globalLogger.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;
+  server;
+  router;
+  constructor(config, router) {
+    this.config = config;
+    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);
+            } else if (contentType.includes("multipart/form-data")) {
+              const formData = await req.formData();
+              body = Object.fromEntries(formData);
+            } 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) {
+          globalLogger.error("HTTP request failed", {
+            error: error.message,
+            stack: error.stack
+          });
+          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) {
+        globalLogger.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"
+          }
+        });
+      }
+    });
+    globalLogger.info("HTTP server started", {
+      url: `http://${host}:${port}`
+    });
+  }
+  async stop() {
+    if (this.server) {
+      this.server.stop();
+      globalLogger.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;
+  constructor(context) {
+    this.context = context;
+  }
+  register(action, trigger) {
+    globalLogger.info("Registering MCP tool", {
+      tool: trigger.tool,
+      action: action.config.name,
+      context: this.context
+    });
+  }
+  async start() {
+    globalLogger.info("MCP Server started");
+  }
+  async stop() {
+    globalLogger.info("MCP Server stopped");
+  }
+}
+
+// src/runtime/router.ts
+class Router {
+  routes = [];
+  executor;
+  constructor(baseContext) {
+    this.executor = new ActionExecutor(baseContext);
+  }
+  register(action, trigger) {
+    const { pattern, paramNames } = this.pathToRegex(trigger.path);
+    this.routes.push({
+      method: trigger.method,
+      pattern,
+      paramNames,
+      action,
+      trigger
+    });
+  }
+  async handle(req) {
+    const route = this.match(req.method, req.path);
+    if (!route) {
+      throw new Error(`Route not found: ${req.method} ${req.path}`);
+    }
+    const match = req.path.match(route.pattern);
+    const params = {};
+    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);
+  }
+  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.map((r) => ({
+      method: r.method,
+      path: r.trigger.path,
+      action: r.action.config.name
+    }));
+  }
+}
+
+// src/runtime/scheduler.ts
+import Baker from "cronbake";
+class Scheduler {
+  baker = Baker.create();
+  executor;
+  constructor(baseContext) {
+    this.executor = new ActionExecutor(baseContext);
+  }
+  schedule(action, trigger) {
+    this.baker.add({
+      name: `${action.config.name}:${trigger.name || "cron"}`,
+      cron: trigger.schedule,
+      callback: async () => {
+        try {
+          globalLogger.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", {
+            action: action.config.name,
+            error: error.message,
+            stack: error.stack
+          });
+        }
+      }
+    });
+  }
+  start() {
+    this.baker.bakeAll();
+    globalLogger.info("Scheduler started");
+  }
+  stop() {
+    this.baker.stopAll();
+    globalLogger.info("Stopped all cron jobs");
+  }
+}
+
+// src/runtime/server.ts
+class BasaltServer {
+  config;
+  router;
+  eventBus;
+  scheduler;
+  mcpServer;
+  httpServer;
+  actions = [];
+  constructor(config) {
+    this.config = config;
+    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);
+    if (this.config.mcp?.enabled) {
+      this.mcpServer = new McpServer(baseContext);
+    }
+  }
+  buildBaseContext() {
+    return {
+      logger: globalLogger,
+      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);
+      globalLogger.info("Scheduling action", { actionName, runAt, input });
+    } else if (when instanceof Date) {
+      globalLogger.info("Scheduling action", { actionName, runAt: when, input });
+    } else if (typeof when === "string") {
+      globalLogger.info("Scheduling recurring action", {
+        actionName,
+        cron: when,
+        input
+      });
+    }
+  }
+  async initialize() {
+    this.actions = await loadActions(this.config.actionsDir || "./src/actions");
+    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);
+            globalLogger.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);
+            globalLogger.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);
+            globalLogger.info("Registered event handler", {
+              event: eventTrigger.event,
+              action: action.config.name
+            });
+            break;
+          }
+          case "agent": {
+            const agentTrigger = trigger;
+            this.mcpServer?.register(action, agentTrigger);
+            globalLogger.info("Registered MCP tool", {
+              tool: agentTrigger.tool,
+              action: action.config.name
+            });
+            break;
+          }
+        }
+      }
+    }
+    globalLogger.info("Basalt 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;
+  }
+  getHttpUrl() {
+    return this.httpServer.getUrl();
+  }
+  async stop() {
+    await this.httpServer.stop();
+    this.scheduler.stop();
+    await this.mcpServer?.stop();
+  }
+}
+
+// src/runtime/dev.ts
+async function createDevServer(config) {
+  const server = new BasaltServer(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;
+      globalLogger.info("Action file changed, regenerating...", {
+        filename,
+        eventType
+      });
+      try {
+        const actions = await loadActions(actionsDir);
+        await generateActionTypes(actions);
+        globalLogger.info("Types regenerated");
+      } catch (error) {
+        globalLogger.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 BasaltServer(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);