@moxxy/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,695 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/config-defaults.ts
+var DEFAULT_CONFIG, CONFIG_DIR, CONFIG_FILE;
+var init_config_defaults = __esm({
+  "src/config/config-defaults.ts"() {
+    "use strict";
+    DEFAULT_CONFIG = {
+      version: 1,
+      webhook: { port: 3456, host: "0.0.0.0", path: "/webhook/github" },
+      repos: []
+    };
+    CONFIG_DIR = ".moxxy";
+    CONFIG_FILE = "config.json";
+  }
+});
+
+// src/config/config-manager.ts
+var import_promises, import_node_fs, import_node_path, import_node_os, import_types, ConfigManager;
+var init_config_manager = __esm({
+  "src/config/config-manager.ts"() {
+    "use strict";
+    import_promises = require("fs/promises");
+    import_node_fs = require("fs");
+    import_node_path = require("path");
+    import_node_os = require("os");
+    import_types = require("@moxxy/types");
+    init_config_defaults();
+    ConfigManager = class {
+      configPath;
+      config = null;
+      constructor(configDir) {
+        const base = configDir || (0, import_node_path.join)((0, import_node_os.homedir)(), CONFIG_DIR);
+        this.configPath = (0, import_node_path.join)(base, CONFIG_FILE);
+      }
+      async load() {
+        if (!(0, import_node_fs.existsSync)(this.configPath)) {
+          throw new Error(`Config not found at ${this.configPath}. Run 'moxxy config init' first.`);
+        }
+        const raw = await (0, import_promises.readFile)(this.configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        this.config = import_types.moxxyConfigSchema.parse(parsed);
+        return this.config;
+      }
+      async save(config) {
+        const dir = (0, import_node_path.join)(this.configPath, "..");
+        if (!(0, import_node_fs.existsSync)(dir)) {
+          await (0, import_promises.mkdir)(dir, { recursive: true });
+        }
+        this.config = import_types.moxxyConfigSchema.parse(config);
+        await (0, import_promises.writeFile)(this.configPath, JSON.stringify(this.config, null, 2) + "\n");
+      }
+      async init(config) {
+        const merged = { ...DEFAULT_CONFIG, ...config };
+        await this.save(merged);
+        return merged;
+      }
+      getConfig() {
+        if (!this.config) throw new Error("Config not loaded. Call load() first.");
+        return this.config;
+      }
+      async addRepo(repo) {
+        const config = this.getConfig();
+        const exists = config.repos.find((r) => r.owner === repo.owner && r.repo === repo.repo);
+        if (exists) throw new Error(`Repo ${repo.owner}/${repo.repo} already configured.`);
+        config.repos.push(repo);
+        await this.save(config);
+      }
+      async removeRepo(owner, repo) {
+        const config = this.getConfig();
+        config.repos = config.repos.filter((r) => !(r.owner === owner && r.repo === repo));
+        await this.save(config);
+      }
+      async set(key, value) {
+        const config = this.getConfig();
+        const keys = key.split(".");
+        let obj = config;
+        for (let i = 0; i < keys.length - 1; i++) {
+          obj = obj[keys[i]] ??= {};
+        }
+        obj[keys[keys.length - 1]] = value;
+        await this.save(config);
+      }
+      get(key) {
+        const config = this.getConfig();
+        const keys = key.split(".");
+        let obj = config;
+        for (const k of keys) {
+          obj = obj?.[k];
+        }
+        return obj;
+      }
+      get path() {
+        return this.configPath;
+      }
+    };
+  }
+});
+
+// src/utils/logger.ts
+function info(message) {
+  console.log(`${import_chalk.default.cyan("i")} ${message}`);
+}
+function success(message) {
+  console.log(`${import_chalk.default.green("\u2714")} ${message}`);
+}
+function error(message) {
+  console.error(`${import_chalk.default.red("\u2716")} ${message}`);
+}
+function warn(message) {
+  console.warn(`${import_chalk.default.yellow("\u26A0")} ${message}`);
+}
+function spinner(text) {
+  return (0, import_ora.default)({ text, color: "cyan" }).start();
+}
+function printBanner() {
+  console.log();
+  console.log(import_chalk.default.bold.cyan("  Moxxy"));
+  console.log(import_chalk.default.dim("  Agent orchestration platform"));
+  console.log();
+}
+function section(title) {
+  console.log();
+  console.log(import_chalk.default.bold(title));
+  console.log(import_chalk.default.dim("\u2500".repeat(title.length)));
+}
+function keyValue(key, value) {
+  console.log(`  ${import_chalk.default.dim(key + ":")} ${value}`);
+}
+function listItem(text) {
+  console.log(`  ${import_chalk.default.dim("\u2022")} ${text}`);
+}
+var import_chalk, import_ora;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    import_chalk = __toESM(require("chalk"));
+    import_ora = __toESM(require("ora"));
+  }
+});
+
+// src/commands/start.ts
+async function createSDK(config) {
+  const provider = config.sdk || "molt";
+  const sdkName = SDK_NAMES[provider] || provider;
+  if (provider === "claude") {
+    const { ClaudeSDK } = await import("@moxxy/claude");
+    const claudeConfig = config.claude || {};
+    const sdk2 = await ClaudeSDK.create({
+      cliPath: claudeConfig.cliPath,
+      model: claudeConfig.model,
+      timeout: claudeConfig.timeout,
+      permissionMode: claudeConfig.permissionMode
+    });
+    return { sdk: sdk2, sdkName };
+  }
+  if (!config.gateway) {
+    throw new Error('Gateway configuration is required for the molt SDK. Run "moxxy config init --sdk molt --gateway-url <url>".');
+  }
+  const { MoltSDK } = await import("@moxxy/molt");
+  const sdk = await MoltSDK.create({
+    gatewayUrl: config.gateway.url,
+    authToken: config.gateway.authToken,
+    deviceId: config.gateway.deviceId,
+    devicePrivateKey: config.gateway.devicePrivateKey
+  });
+  return { sdk, sdkName };
+}
+function registerStartCommand(program) {
+  program.command("start").description("Start Moxxy orchestration").action(async () => {
+    const configManager = new ConfigManager();
+    try {
+      const config = await configManager.load();
+      printBanner();
+      const { MoltAgentSupervisor } = await import("@moxxy/agents");
+      const { IntegrationManager } = await import("@moxxy/integration-base");
+      const { GitHubIntegration } = await import("@moxxy/integration-github");
+      const provider = config.sdk || "molt";
+      const sdkName = SDK_NAMES[provider] || provider;
+      const connectSpinner = spinner(`Connecting to ${sdkName}`);
+      try {
+        const { sdk } = await createSDK(config);
+        connectSpinner.succeed(`Connected to ${sdkName}`);
+        const supervisorSpinner = spinner("Initializing agent supervisor");
+        const supervisor = new MoltAgentSupervisor(sdk);
+        const agentId = config.agent?.moltAgentId;
+        if (agentId) {
+          await supervisor.assignAgent(agentId, "developer");
+          supervisorSpinner.succeed(`Agent ${import_chalk.default.bold(agentId)} assigned`);
+        } else {
+          supervisorSpinner.succeed("Supervisor ready (no agent configured)");
+        }
+        const integrationManager = new IntegrationManager();
+        const github = new GitHubIntegration();
+        integrationManager.register(github);
+        integrationManager.on("*", (event) => {
+          info(
+            `${import_chalk.default.dim(`[${event.integration}]`)} ${event.type}: ${JSON.stringify(event.data).slice(0, 200)}`
+          );
+        });
+        const webhookConfig = config.webhook || {
+          port: 3456,
+          host: "0.0.0.0",
+          path: "/webhook/github"
+        };
+        const webhookSpinner = spinner("Starting webhook server");
+        await github.connect({
+          github: config.github,
+          webhook: webhookConfig,
+          sdk,
+          supervisor,
+          moltAgentId: agentId || ""
+        });
+        webhookSpinner.succeed(
+          `Webhook server listening on ${import_chalk.default.cyan(`${webhookConfig.host}:${webhookConfig.port}${webhookConfig.path}`)}`
+        );
+        if (config.repos.length > 0) {
+          const watchSpinner = spinner(
+            `Watching ${config.repos.length} repositories`
+          );
+          const targets = config.repos.map((r) => `${r.owner}/${r.repo}`);
+          await github.watch(targets);
+          watchSpinner.succeed(
+            `Watching ${import_chalk.default.bold(String(targets.length))} repositories: ${targets.join(", ")}`
+          );
+        }
+        console.log();
+        success(import_chalk.default.bold("Moxxy is running.") + " Press Ctrl+C to stop.");
+        const shutdown = async () => {
+          console.log();
+          info("Shutting down...");
+          await integrationManager.stopAll();
+          sdk.disconnect();
+          success("Shutdown complete.");
+          process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+        await new Promise(() => {
+        });
+      } catch (innerErr) {
+        connectSpinner.fail(
+          `Failed to start: ${innerErr instanceof Error ? innerErr.message : innerErr}`
+        );
+        process.exitCode = 1;
+      }
+    } catch (err) {
+      error(`Failed to start: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+}
+var SDK_NAMES;
+var init_start = __esm({
+  "src/commands/start.ts"() {
+    "use strict";
+    init_config_manager();
+    init_logger();
+    SDK_NAMES = {
+      molt: "Molt Gateway",
+      claude: "Claude CLI"
+    };
+  }
+});
+
+// src/commands/repo.ts
+function registerRepoCommand(program) {
+  const repo = program.command("repo").description("Manage watched repositories");
+  repo.command("add").description("Add a repository to watch").argument("<repo>", "Repository in owner/repo format").option("--branch <branch>", "Default branch", "main").option("--events <events>", "Comma-separated events to watch", "issues.opened,issues.labeled").action(async (repoStr, options) => {
+    const [owner, name] = repoStr.split("/");
+    if (!owner || !name) {
+      error("Repository must be in owner/repo format");
+      process.exitCode = 1;
+      return;
+    }
+    const manager = new ConfigManager();
+    try {
+      await manager.load();
+      await manager.addRepo({
+        owner,
+        repo: name,
+        defaultBranch: options.branch,
+        enabledEvents: options.events.split(",")
+      });
+      success(`Added ${import_chalk.default.bold(`${owner}/${name}`)}`);
+    } catch (err) {
+      error(`Failed: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+  repo.command("list").description("List watched repositories").action(async () => {
+    const manager = new ConfigManager();
+    try {
+      await manager.load();
+      const config = manager.getConfig();
+      if (config.repos.length === 0) {
+        info("No repositories configured.");
+        return;
+      }
+      section(`Repositories (${config.repos.length})`);
+      for (const r of config.repos) {
+        listItem(
+          `${import_chalk.default.bold(`${r.owner}/${r.repo}`)} ${import_chalk.default.dim(`branch: ${r.defaultBranch}`)} ${import_chalk.default.dim(`events: ${r.enabledEvents.join(", ")}`)}`
+        );
+      }
+      console.log();
+    } catch (err) {
+      error(`Failed: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+  repo.command("remove").description("Remove a watched repository").argument("<repo>", "Repository in owner/repo format").action(async (repoStr) => {
+    const [owner, name] = repoStr.split("/");
+    if (!owner || !name) {
+      error("Repository must be in owner/repo format");
+      process.exitCode = 1;
+      return;
+    }
+    const manager = new ConfigManager();
+    try {
+      await manager.load();
+      await manager.removeRepo(owner, name);
+      success(`Removed ${import_chalk.default.bold(`${owner}/${name}`)}`);
+    } catch (err) {
+      error(`Failed: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+}
+var init_repo = __esm({
+  "src/commands/repo.ts"() {
+    "use strict";
+    init_config_manager();
+    init_logger();
+  }
+});
+
+// src/utils/prompt.ts
+async function interactiveInit() {
+  console.log();
+  console.log(import_chalk2.default.bold.cyan("  Moxxy Config Setup"));
+  console.log(import_chalk2.default.dim("  Answer the prompts below to initialize your configuration.\n"));
+  const { sdk } = await (0, import_prompts.default)({
+    type: "select",
+    name: "sdk",
+    message: "SDK provider",
+    choices: [
+      { title: "Molt", value: "molt" },
+      { title: "Claude", value: "claude" }
+    ]
+  });
+  if (!sdk) return null;
+  let gatewayUrl;
+  let authToken;
+  let claudeApiKey;
+  let claudeModel;
+  let claudeCliPath;
+  if (sdk === "molt") {
+    const molt = await (0, import_prompts.default)([
+      {
+        type: "text",
+        name: "gatewayUrl",
+        message: "Gateway URL",
+        validate: (v) => v.length > 0 ? true : "Gateway URL is required"
+      },
+      {
+        type: "text",
+        name: "authToken",
+        message: "Auth token (optional, press Enter to skip)"
+      }
+    ]);
+    if (!molt.gatewayUrl) return null;
+    gatewayUrl = molt.gatewayUrl;
+    authToken = molt.authToken || void 0;
+  } else {
+    const claude = await (0, import_prompts.default)([
+      {
+        type: "text",
+        name: "apiKey",
+        message: "Anthropic API key (optional, press Enter to skip)"
+      },
+      {
+        type: "text",
+        name: "model",
+        message: "Claude model",
+        initial: "claude-sonnet-4-5"
+      },
+      {
+        type: "text",
+        name: "cliPath",
+        message: "Claude CLI path",
+        initial: "claude"
+      }
+    ]);
+    if (claude.model === void 0) return null;
+    claudeApiKey = claude.apiKey || void 0;
+    claudeModel = claude.model;
+    claudeCliPath = claude.cliPath;
+  }
+  const shared = await (0, import_prompts.default)([
+    {
+      type: "password",
+      name: "githubToken",
+      message: "GitHub personal access token",
+      validate: (v) => v.length > 0 ? true : "GitHub token is required"
+    },
+    {
+      type: "password",
+      name: "webhookSecret",
+      message: "Webhook secret (optional, press Enter to skip)"
+    },
+    {
+      type: "number",
+      name: "webhookPort",
+      message: "Webhook port",
+      initial: 3456
+    },
+    {
+      type: "text",
+      name: "agentId",
+      message: "Agent ID (optional, press Enter to skip)"
+    }
+  ]);
+  if (!shared.githubToken) return null;
+  return {
+    sdk,
+    gatewayUrl,
+    authToken,
+    claudeApiKey,
+    claudeModel,
+    claudeCliPath,
+    githubToken: shared.githubToken,
+    webhookSecret: shared.webhookSecret || void 0,
+    webhookPort: String(shared.webhookPort ?? 3456),
+    agentId: shared.agentId || void 0
+  };
+}
+var import_prompts, import_chalk2;
+var init_prompt = __esm({
+  "src/utils/prompt.ts"() {
+    "use strict";
+    import_prompts = __toESM(require("prompts"));
+    import_chalk2 = __toESM(require("chalk"));
+  }
+});
+
+// src/commands/config.ts
+function registerConfigCommand(program) {
+  const config = program.command("config").description("Manage Moxxy configuration");
+  config.command("init").description("Initialize Moxxy configuration").option("--sdk <provider>", "SDK provider (molt or claude)").option("--github-token <token>", "GitHub personal access token").option("--gateway-url <url>", "Gateway URL (molt SDK)").option("--auth-token <token>", "Gateway auth token (molt SDK)").option("--claude-api-key <key>", "Anthropic API key (claude SDK)").option("--claude-model <model>", "Claude model (claude SDK)", "claude-sonnet-4-5").option("--claude-cli-path <path>", "Claude CLI path (claude SDK)", "claude").option("--webhook-secret <secret>", "GitHub webhook secret").option("--webhook-port <port>", "Webhook server port", "3456").option("--agent-id <id>", "Agent ID").action(async (options) => {
+    if (!options.sdk) {
+      const result = await interactiveInit();
+      if (!result) {
+        warn("Config init cancelled.");
+        return;
+      }
+      options = { ...options, ...result };
+    }
+    const sdk = options.sdk;
+    if (sdk !== "molt" && sdk !== "claude") {
+      error('--sdk must be "molt" or "claude"');
+      process.exitCode = 1;
+      return;
+    }
+    if (!options.githubToken) {
+      error("--github-token is required");
+      process.exitCode = 1;
+      return;
+    }
+    if (sdk === "molt" && !options.gatewayUrl) {
+      error("--gateway-url is required when using the molt SDK");
+      process.exitCode = 1;
+      return;
+    }
+    const manager = new ConfigManager();
+    try {
+      await manager.init({
+        version: 1,
+        sdk,
+        gateway: sdk === "molt" ? { url: options.gatewayUrl, authToken: options.authToken } : void 0,
+        github: { token: options.githubToken, webhookSecret: options.webhookSecret },
+        webhook: {
+          port: parseInt(options.webhookPort, 10),
+          host: "0.0.0.0",
+          path: "/webhook/github"
+        },
+        repos: [],
+        agent: options.agentId ? { moltAgentId: options.agentId } : void 0,
+        claude: sdk === "claude" ? {
+          apiKey: options.claudeApiKey,
+          cliPath: options.claudeCliPath,
+          model: options.claudeModel
+        } : void 0
+      });
+      success(`Config created at ${import_chalk.default.dim(manager.path)}`);
+    } catch (err) {
+      error(`Failed to init config: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+  config.command("set").description("Set a config value").argument("<key>", "Config key (dot notation)").argument("<value>", "Config value").action(async (key, value) => {
+    const manager = new ConfigManager();
+    try {
+      await manager.load();
+      let parsed = value;
+      try {
+        parsed = JSON.parse(value);
+      } catch {
+      }
+      await manager.set(key, parsed);
+      success(`Set ${import_chalk.default.bold(key)}`);
+    } catch (err) {
+      error(`Failed: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+  config.command("get").description("Get a config value").argument("<key>", "Config key (dot notation)").action(async (key) => {
+    const manager = new ConfigManager();
+    try {
+      await manager.load();
+      const value = manager.get(key);
+      console.log(import_chalk.default.cyan(JSON.stringify(value, null, 2)));
+    } catch (err) {
+      error(`Failed: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+}
+var init_config = __esm({
+  "src/commands/config.ts"() {
+    "use strict";
+    init_config_manager();
+    init_logger();
+    init_prompt();
+  }
+});
+
+// src/commands/status.ts
+function registerStatusCommand(program) {
+  program.command("status").description("Show Moxxy configuration status").action(async () => {
+    const configManager = new ConfigManager();
+    try {
+      const config = await configManager.load();
+      printBanner();
+      const provider = config.sdk || "molt";
+      section("SDK");
+      keyValue("Provider", import_chalk.default.bold(provider));
+      if (provider === "molt" && config.gateway) {
+        section("Gateway");
+        keyValue("URL", import_chalk.default.cyan(config.gateway.url));
+        keyValue(
+          "Auth",
+          config.gateway.authToken ? import_chalk.default.green("configured") : import_chalk.default.dim("not set")
+        );
+        keyValue(
+          "Device",
+          config.gateway.deviceId || import_chalk.default.dim("not set")
+        );
+      }
+      if (provider === "claude" && config.claude) {
+        section("Claude");
+        keyValue(
+          "API Key",
+          config.claude.apiKey ? import_chalk.default.yellow("***" + config.claude.apiKey.slice(-4)) : import_chalk.default.dim("not set")
+        );
+        keyValue("CLI Path", import_chalk.default.cyan(config.claude.cliPath || "claude"));
+        keyValue("Model", import_chalk.default.cyan(config.claude.model || "claude-sonnet-4-5"));
+      }
+      section("GitHub");
+      keyValue(
+        "Token",
+        config.github.token ? import_chalk.default.yellow("***" + config.github.token.slice(-4)) : import_chalk.default.dim("not set")
+      );
+      keyValue(
+        "Webhook Secret",
+        config.github.webhookSecret ? import_chalk.default.green("configured") : import_chalk.default.dim("not set")
+      );
+      if (config.webhook) {
+        section("Webhook Server");
+        keyValue("Port", import_chalk.default.cyan(String(config.webhook.port)));
+        keyValue("Path", import_chalk.default.cyan(config.webhook.path));
+      }
+      section(`Repositories (${config.repos.length})`);
+      if (config.repos.length === 0) {
+        keyValue("", import_chalk.default.dim("None configured"));
+      } else {
+        for (const r of config.repos) {
+          listItem(
+            `${import_chalk.default.bold(`${r.owner}/${r.repo}`)} ${import_chalk.default.dim(`(${r.defaultBranch})`)}`
+          );
+        }
+      }
+      if (config.agent) {
+        section("Agent");
+        keyValue(
+          "Agent ID",
+          config.agent.moltAgentId || import_chalk.default.dim("not set")
+        );
+        keyValue(
+          "Max Concurrent",
+          String(config.agent.maxConcurrentTasks || 1)
+        );
+      }
+      console.log();
+    } catch (err) {
+      error(`${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+}
+var init_status = __esm({
+  "src/commands/status.ts"() {
+    "use strict";
+    init_config_manager();
+    init_logger();
+  }
+});
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  createProgram: () => createProgram
+});
+function createProgram() {
+  const program = new import_commander.Command();
+  program.name("moxxy").description("Moxxy - Agent orchestration platform").version("1.0.0");
+  registerStartCommand(program);
+  registerRepoCommand(program);
+  registerConfigCommand(program);
+  registerStatusCommand(program);
+  return program;
+}
+var import_commander;
+var init_cli = __esm({
+  "src/cli.ts"() {
+    "use strict";
+    import_commander = require("commander");
+    init_start();
+    init_repo();
+    init_config();
+    init_status();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConfigManager: () => ConfigManager,
+  createProgram: () => createProgram,
+  run: () => run
+});
+module.exports = __toCommonJS(index_exports);
+init_cli();
+init_config_manager();
+async function run() {
+  const { createProgram: createProgram2 } = await Promise.resolve().then(() => (init_cli(), cli_exports));
+  const program = createProgram2();
+  await program.parseAsync(process.argv);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigManager,
+  createProgram,
+  run
+});