@pixlcore/xycli 1.0.0

package/docs/tutorial.md

@@ -0,0 +1,204 @@
+# xyCLI Tutorial
+
+Let's build a small piece of automation from your terminal. You'll explore the dashboard, create a shell Event, watch a job run, and add a Web Hook that fires when the job succeeds. Then you'll update your script and export the finished automation.
+
+For installation and connection settings, start with [Getting started](../README.md#getting-started). The [command reference](help.md) has the full options for every command used here.
+
+## Before you begin
+
+This walkthrough assumes:
+
+- xyCLI is installed and connected to your xyOps instance.
+- You have an online Linux or macOS worker with a POSIX shell, the built-in Shell Plugin (`shellplug`), and an enabled Category.
+- Your API Key can create and edit Events, run jobs, and use the selected Category and Group. For the Web Hook steps, it also needs `create_web_hooks` and `edit_web_hooks`.
+- You have an HTTP endpoint that accepts JSON POST requests and lets you inspect incoming requests. This could be your own application or a request-capture endpoint. The xyOps conductor must be able to reach it.
+
+Use the IDs printed by xyCLI as you go. Replace placeholders such as `EVENT_ID` and `HOOK_ID` with those actual IDs, and replace the example Hook URL with your endpoint.
+
+## 1. Explore the dashboard
+
+Run `xy` to see your system at a glance:
+
+```sh
+xy
+```
+
+The dashboard brings together server health, active Alerts and jobs, queued work, and rate limits. Check the upcoming schedule to see what xyOps expects to run soon:
+
+```sh
+xy upcoming
+```
+
+Now browse the workers and resources available for your first Event:
+
+```sh
+xy servers
+xy groups
+xy categories
+xy plugins --type event
+```
+
+Choose a Group with an online, enabled worker, and note its ID. Also note an enabled Category ID and confirm that the Shell Plugin is available. You can inspect a worker or Group more closely with `xy server SERVER_ID` or `xy group GROUP_ID`.
+
+- **Command reference:** [Dashboard](help.md#dashboard), [Servers](help.md#servers), and [Groups](help.md#groups).
+
+## 2. Create your first Event
+
+An Event is a reusable definition of what to run and where to run it. Each execution of that Event becomes a separate job.
+
+Make a local file named `hello.sh` containing:
+
+```sh
+#!/bin/sh
+echo "Hello from xyCLI!"
+echo "Running on $(hostname)"
+sleep 3
+echo "All done."
+```
+
+Create an enabled Event with a manual trigger. Replace `CATEGORY_ID` and `GROUP_ID` with the IDs you selected:
+
+```sh
+xy event create --title "Hello from xyCLI" \
+	--enabled true --category CATEGORY_ID \
+	--plugin shellplug --targets '["GROUP_ID"]' \
+	--params.script @./hello.sh \
+	--triggers '[{"type":"manual","enabled":true}]'
+```
+
+The `@./hello.sh` value reads your local script into the Event. The Group determines which workers are eligible to run it, and the manual trigger allows you to launch it on demand. There is no schedule, so this Event runs when you ask it to.
+
+The creation command prints the new Event ID. Use it to review the saved definition:
+
+```sh
+xy event EVENT_ID
+```
+
+- **Command reference:** [Event creation](help.md#event-create).
+- **Learn more about xyOps:** [xyOps Events](https://docs.xyops.io/events) and [xyOps Triggers](https://docs.xyops.io/triggers).
+
+## 3. Run a job and follow its output
+
+Launch the Event and follow the job until it finishes:
+
+```sh
+xy run EVENT_ID --follow
+```
+
+You should see the greeting, the worker's hostname, and the final message. xyCLI then displays the completed job report.
+
+Each run gets its own Job ID. Use the ID printed at launch to revisit its report or read its output log:
+
+```sh
+xy job JOB_ID
+xy job log JOB_ID
+```
+
+Find all of today's completed runs of your Event:
+
+```sh
+xy jobs --event EVENT_ID --date today
+```
+
+You can also launch without `--follow` and open the Job ID afterward. `xy job JOB_ID` follows an active job or displays a completed report, depending on its state.
+
+- **Command reference:** [Running Events](help.md#event-run), [Job searches](help.md#jobs), and [Job reports](help.md#job).
+
+## 4. Create a custom Web Hook
+
+Let's send a JSON notification to your HTTP endpoint. A Web Hook stores the destination and request settings; an Event action will decide when to fire it.
+
+Create a local file named `notification-body.txt` containing this request template:
+
+```text
+{
+	"source": "xycli-tutorial",
+	"message": {{ stringify(text) }}
+}
+```
+
+`text` is the notification message generated by xyOps. `stringify(text)` turns it into a quoted JSON string, including escaping quotes and line breaks. Leave that expression unquoted in the template: xyOps fills it in before sending the request, producing valid JSON.
+
+Create the Hook, replacing `https://hooks.example.com/xycli` with your endpoint:
+
+```sh
+xy hook create --title "xyCLI Success Notification" \
+	--url https://hooks.example.com/xycli \
+	--method POST --body @./notification-body.txt
+```
+
+xyCLI prints the new Hook ID. The default headers include `Content-Type: application/json`, and new Hooks are enabled. Creating the Hook saves its definition without sending a request.
+
+Inspect it, then send a test request:
+
+```sh
+xy hook HOOK_ID
+xy hook test HOOK_ID
+```
+
+The test makes a real HTTP request from xyOps and displays the request, response, and timing details. Your endpoint should receive a JSON object with `source` set to `xycli-tutorial` and a test notification in `message`. The test uses sample notification data; it does not run your Event.
+
+If the request fails, check the URL, the endpoint's response, and network access from the conductor. If your destination needs authentication or a different payload, adjust the Hook to match its API before continuing.
+
+- **Command reference:** [Hook creation](help.md#hook-create) and [Hook testing](help.md#hook-test).
+- **Learn more about xyOps:** [xyOps Web Hooks](https://docs.xyops.io/webhooks).
+
+## 5. Fire the Hook when your Event succeeds
+
+Attach an enabled Web Hook action to the Event. Replace `HOOK_ID` inside the JSON with the Hook ID from the previous step:
+
+```sh
+xy event update EVENT_ID \
+	--action '{"type":"web_hook","enabled":true,"condition":"success","web_hook":"HOOK_ID","text":"Hello from xyCLI finished successfully."}'
+```
+
+The `success` condition fires when the job completes successfully. The `web_hook` field selects the saved Hook, and `text` adds your custom message to the notification. A failed run will not fire this success action.
+
+The singular `--action` option **appends** to the Event's existing actions. Run this update once; repeating it adds another action entry. Review the Event to confirm the new action is present:
+
+```sh
+xy event EVENT_ID
+```
+
+Now run the Event again:
+
+```sh
+xy run EVENT_ID --follow
+```
+
+After the job succeeds, check your endpoint for the notification. The same Hook template now receives the real job's notification text, including your custom message. Your Event and Hook are saved, so future successful runs use the same action automatically.
+
+The completed job report includes the actions that fired and their results. If the notification does not arrive, revisit `xy job JOB_ID` and inspect the Web Hook action result as well as your endpoint's request log.
+
+- **Command reference:** [Event updates](help.md#event-update).
+- **Learn more about xyOps:** [xyOps Actions](https://docs.xyops.io/actions).
+
+## 6. Update your script from your editor
+
+Add another message to your local `hello.sh`, then upload the revised script:
+
+```sh
+xy event update EVENT_ID --params.script @./hello.sh
+xy run EVENT_ID --follow
+```
+
+The update changes the saved script while preserving the Event's other settings, including the success action. Editing your local file alone does not update xyOps; the update command sends the new contents.
+
+This is a simple way to iterate on automation with your usual editor. For a larger collection of Events and Plugins, explore the [filesystem sync overview](../README.md#sync-your-automation-with-local-files).
+
+## 7. Export the Event and its Hook together
+
+Save your finished Event as an xyOps Portable Data Format (XYPDF) file, including the Web Hook referenced by its action:
+
+```sh
+xy event EVENT_ID --export ./hello-event.json --deps web_hooks
+```
+
+The export includes the Event's saved script, manual trigger, and success action, plus the custom Hook definition. You can review the file, keep it in Git, or import it into another instance using xyCLI or the xyOps web interface.
+
+This example selects only the Hook dependency. Importing elsewhere also requires compatible Plugins, Categories, and target Groups; use `--deps all` to include all supported portable dependencies. Individual workers are not portable.
+
+- **Command reference:** [Export](help.md#export) and [Import](help.md#import).
+- **Learn more about xyOps:** [xyOps Portable Data Format](https://docs.xyops.io/xypdf).
+
+For more ideas, return to [Explore and manage xyOps](../README.md#explore-and-manage-xyops) or browse the [screenshot gallery](screenshots.md).

package/index.js

@@ -0,0 +1,444 @@
+#!/usr/bin/env node
+
+// xyOps CLI
+// See: https://github.com/pixlcore/xyops
+// Copyright (c) 2019 - 2026 PixlCore LLC, BSD 3-Clause License
+
+// Config Keys: api_key, base_url, temp_dir, color, suggest, items_per_page
+
+const fs = require('fs');
+const os = require('os');
+const cp = require('child_process');
+const Path = require('path');
+const Uncatch = require('uncatch');
+const cli = require('pixl-cli');
+const pkg = require('./package.json');
+
+if (!process.env.XYOPS_USER_AGENT) {
+	process.env.XYOPS_USER_AGENT = `xyOps CLI v${pkg.version} (Node.js); ${os.hostname()} (${os.platform()}/${os.arch()})`;
+}
+
+cli.global();
+
+cli.mapArgs({
+	'v': 'verbose',
+	'q': 'quiet',
+	'd': 'debug',
+	'f': 'format',
+	'r': 'raw',
+	'h': 'help'
+});
+
+process.on('SIGINT', function() { cli.progress.end(); process.exit(130); } );
+process.on('SIGTERM', function() { cli.progress.end(); process.exit(143); } );
+process.on('SIGHUP', function() { cli.progress.end(); process.exit(129); } );
+
+Uncatch.on('uncaughtException', function(err) {
+	// execute your own application shutdown routine here
+	// do not call any async code, and do not call process.exit
+	cli.progress.end();
+});
+
+const { api } = require('@pixlcore/xyops-sdk');
+var highlight = require('cli-highlight').highlight;
+const Tools = cli.Tools;
+const chalk = cli.chalk;
+
+// minimum xyops version
+const XYOPS_MIN_VERSION = '1.0.96';
+
+// These API parameters are always opaque strings, even when their contents
+// happen to look like JSON or come from a file with a .json extension.
+const JSON_ARG_EXCEPTIONS = ['body'];
+
+// Keep the public command inventory in one place, so typo suggestions and the
+// fallback help text always advertise the exact same top-level commands.
+const TOP_LEVEL_COMMANDS = [
+	'help', 'config', 'doc', 'dashboard', 'system', 'upcoming',
+	'alerts', 'alert', 'buckets', 'bucket', 'categories', 'category',
+	'channels', 'channel', 'events', 'event', 'run', 'groups', 'group',
+	'jobs', 'job', 'keys', 'key', 'log', 'monitors', 'monitor',
+	'plugins', 'plugin', 'servers', 'server', 'secrets', 'secret',
+	'snapshots', 'snapshot', 'tags', 'tag', 'tickets', 'ticket',
+	'hooks', 'hook', 'marketplace',
+	'import', 'api', 'repl'
+];
+
+// coerce true/false into booleans
+for (var key in cli.args) {
+	if (cli.args[key] === 'true') cli.args[key] = true;
+	else if (cli.args[key] === 'false') cli.args[key] = false;
+}
+
+// make our own copy of cli.args
+var args = Object.assign( {}, cli.args );
+
+if (!args.other || !args.other.length) args.other = ['dashboard'];
+else if (args.help) args.other = ['help'];
+
+var cmd = args.other.shift().toLowerCase();
+
+const app = {
+	
+	epoch: Tools.timeNow(),
+	
+	colors: {
+		"theme": [55, 145, 245],
+		"gray": [127, 127, 127],
+		
+		"red": [251, 44, 54],
+		"fire": [255, 77, 7],
+		"orange": [255, 105, 0],
+		"tangerine": [255, 130, 0],
+		"amber": [254, 154, 0],
+		"gold": [248, 165, 0],
+		"yellow": [240, 177, 0],
+		"lemon": [198, 191, 0],
+		"lime": [124, 207, 0],
+		"grass": [74, 204, 38],
+		"green": [0, 201, 80],
+		"mint": [0, 195, 106],
+		"emerald": [0, 188, 125],
+		"aqua": [0, 188, 148],
+		"teal": [0, 187, 167],
+		"turquoise": [0, 187, 195],
+		"cyan": [0, 184, 219],
+		"ice": [0, 176, 232],
+		"sky": [0, 166, 244],
+		"azure": [0, 148, 254],
+		"blue": [43, 127, 255],
+		"sapphire": [75, 111, 255],
+		"indigo": [97, 95, 255],
+		"lavender": [120, 88, 255],
+		"violet": [142, 81, 255],
+		"orchid": [158, 76, 255],
+		"purple": [173, 70, 255],
+		"magenta": [199, 59, 255],
+		"fuchsia": [225, 42, 251],
+		"hotpink": [241, 43, 201],
+		"pink": [246, 51, 154],
+		"blush": [252, 40, 122],
+		"rose": [255, 32, 86]
+	},
+	
+	condition_colors: {
+		'start': 'sky',
+		'complete': 'emerald',
+		'continue': 'gray',
+		'success': 'green',
+		'error': 'red',
+		'user': 'orange',
+		'warning': 'yellow',
+		'critical': 'purple',
+		'abort': 'gray'
+	},
+	
+	events: [],
+	categories: [],
+	groups: [],
+	plugins: [],
+	tags: [],
+	api_keys: [],
+	buckets: [],
+	roles: [],
+	secrets: [],
+	web_hooks: [],
+	
+	activeJobs: {},
+	activeAlerts: {},
+	internalJobs: {},
+	servers: {},
+	serverCache: {},
+	state: {},
+	stats: {},
+	
+	lastMonthDayCache: {},
+	
+	async run() {
+		// main entry point
+		var self = this;
+		
+		this.loadConfig();
+		
+		this.version = pkg.version;
+		this.args = args;
+		this.api = api;
+		this.cli = cli;
+		this.highlight = highlight;
+		
+		this.debug = args.debug;
+		this.verbose = args.verbose;
+		this.quiet = args.quiet;
+		
+		// process global common args
+		this.format = args.format || '';
+		delete args.format;
+		
+		this.raw = args.raw || this.config.raw || false;
+		delete args.raw;
+		
+		this.dry = args.dry || false;
+		delete args.dry;
+		
+		// show invisible jobs: config prop only
+		this.invisible = this.config.invisible || false;
+		
+		// optionally disable all ANSI color
+		if (("color" in this.config) && !this.config.color) {
+			cli.chalk.enabled = false;
+			highlight = this.highlight = function(text) { return text; };
+		}
+		
+		println( "\n " + cli.emoji('🚀') + " " + this.color('theme').bold("xyOps CLI ") + gray("v" + this.version) );
+		
+		// call config cmd early (before contacting xyops)
+		if (cmd == 'config') {
+			await this['cmd_' + cmd]();
+			print("\n");
+			return;
+		}
+		
+		delete args.debug;
+		delete args.echo;
+		delete args.quiet;
+		delete args.verbose;
+		
+		// create temp dir if needed
+		this.tempDir = this.config.temp_dir || Path.join( os.tmpdir(), 'xyops', 'cli' );
+		if (!fs.existsSync(this.tempDir)) Tools.mkdirpSync( this.tempDir );
+		
+		if (!this.config.api_key) {
+			this.die("Missing xyOps API Key.  Set an 'api_key' property in " + this.configFiles.join(', or ') + ", or set a 'XYOPS_API_KEY' environment variable.");
+		}
+		if (!this.config.base_url) {
+			this.die("Missing xyOps Base URL.  Set a 'base_url' property in " + this.configFiles.join(', or ') + ", or set a 'XYOPS_BASE_URL' environment variable.");
+		}
+		
+		println( ' ' + gray(this.config.base_url) );
+		
+		if (this.dry) {
+			this.toast('⚠️', 'orange', bold("DRY RUN: ") + "No changes will actually be made.");
+		}
+		
+		// optionally read STDIN into a named arg (use curl @- convention)
+		var stdin_arg_key = null;
+		for (var key in args) {
+			if (args[key] === '@-') { stdin_arg_key = key; break; }
+		}
+		if (stdin_arg_key) {
+			verboseln("Reading STDIN into: " + stdin_arg_key);
+			const chunks = [];
+			for await (const chunk of process.stdin) chunks.push(chunk);
+			args[stdin_arg_key] = chunks.join('');
+			
+			// Some API parameters are opaque strings even when they look like JSON.
+			if (!JSON_ARG_EXCEPTIONS.includes(stdin_arg_key) && (args[stdin_arg_key].trim().match(/^\{[\s\S]*\}$/) || args[stdin_arg_key].trim().match(/^\[[\s\S]*\]$/))) {
+				try { args[stdin_arg_key] = JSON.parse(args[stdin_arg_key]); }
+				catch (err) { this.die("Failed to parse JSON from STDIN: " + err); }
+			}
+		}
+		
+		// optionally read any file into any arg (use curl @FILE convention)
+		for (var key in args) {
+			if (String(args[key]).match(/^@(.+)$/)) {
+				var file = RegExp.$1;
+				if (!fs.existsSync(file)) this.die("File not found: " + file);
+				if (!JSON_ARG_EXCEPTIONS.includes(key) && file.match(/\.json$/i)) args[key] = JSON.parse( fs.readFileSync(file, 'utf8') );
+				else args[key] = fs.readFileSync(file, 'utf8');
+			}
+		}
+		
+		// if 'json' arg is present and an object, merge into top-level
+		// (so user can pipe entire request in from STDIN or file)
+		if (args.json && (typeof(args.json) == 'object')) {
+			Tools.mergeHashInto( args, args.json );
+			delete args.json;
+		}
+		
+		// any arg value that looks like json will be parsed
+		for (var key in args) {
+			if (!JSON_ARG_EXCEPTIONS.includes(key) && args[key] && (typeof(args[key]) == 'string') && (args[key].trim().match(/^\{[\s\S]*\}$/) || args[key].trim().match(/^\[[\s\S]*\]$/))) {
+				try { args[key] = JSON.parse( args[key] ); }
+				catch (err) { this.die("Failed to parse JSON from argument: " + err); }
+			}
+		}
+		
+		// Export is an explicit read-only variant, including portable object types
+		// whose full resource routers are not yet implemented. Do not let the flag
+		// become a search filter or an accidental field in a create/update request.
+		if (('export' in args) && (cmd != 'api')) {
+			await this.cacheConfig();
+			await this.cmd_export_object(cmd);
+			print("\n");
+			return;
+		}
+		
+		if (!this['cmd_' + cmd]) {
+			// allow user to swap first two args, if 2nd is known command
+			if (this['cmd_' + args.other[0]]) {
+				var new_cmd = args.other[0];
+				args.other[0] = cmd;
+				cmd = new_cmd;
+			}
+			else {
+				var suggestion = this.findClosestString(cmd, TOP_LEVEL_COMMANDS);
+				this.die(
+					"Unknown command: " + cmd + (suggestion ? '. Did you mean "' + suggestion + '"?' : ''),
+					"Available Commands: " + TOP_LEVEL_COMMANDS.join(', ') + "\n\n"
+				);
+			}
+		}
+		
+		// merge in config from xyops
+		await this.cacheConfig();
+		
+		// make sure we have a compatible version of xyops
+		if (this.compareVersions(XYOPS_MIN_VERSION, this.xyopsVersion) > 0) {
+			this.die("The CLI requires xyOps v" + XYOPS_MIN_VERSION + " or higher.");
+		}
+		
+		// go go go
+		await this['cmd_' + cmd]();
+		
+		// always end with empty line
+		print("\n");
+	},
+	
+	async cmd_repl() {
+		// open repl for user to debug
+		await this.getMultiple();
+		
+		println( "\n" + this.markdown(
+			"The REPL exposes `app`, `xy`, `config`, `cli`, and `Tools` in its context.\n\n" + 
+			"Type `.exit` or hit `Ctrl-C` to exit."
+		) );
+		
+		print("\n");
+		var repl = this.repl = require('repl').start({ prompt: '> ', useGlobal: true, ignoreUndefined: true });
+		
+		repl.context.app = this;
+		repl.context.config = this.config;
+		repl.context.cli = cli;
+		repl.context.Tools = Tools;
+		repl.context.xy = this;
+		
+		await new Promise((resolve) => {
+			repl.once('exit', () => {
+				delete app.repl;
+				resolve();
+			});
+		});
+	},
+	
+	async cmd_api() {
+		// perform arbitrary xyops api call
+		// e.g. "xy api getEvents"
+		var name = this.args.other.shift() || this.dieUsage('api');
+		delete this.args.other;
+		
+		this.mergeDotArgs( this.args, this.args );
+		if (this.verbose) this.args.verbose = true;
+		
+		println( "\n " + this.color('theme').bold("Calling API: " + name) );
+		
+		print( "\n " + cyan.bold("Request:") );
+		this.jsonOutput(this.args);
+		
+		if (this.dry) {
+			this.toast('⚠️', 'orange', bold("DRY RUN: ") + "Exiting without sending request.");
+			return;
+		}
+		
+		cli.progress.start({ amount: 1, pct: false, text: gray('→ ' + name) });
+		var { err, data } = await this.api[name](this.args);
+		cli.progress.end();
+		if (err) this.die(err);
+		
+		print( "\n " + cyan.bold("Response:") );
+		this.jsonOutput(data);
+	},
+	
+	async cmd_help() {
+		// show help section
+		var parts = this.args.other.slice(0);
+		var heading = parts.join(' ') || 'help';
+		this.printHelp(heading);
+	},
+	
+	printHelp(heading) {
+		// print named section from help file
+		heading = heading.toLowerCase();
+		var md = fs.readFileSync(Path.join(__dirname, 'docs', 'help.md'), 'utf8').trim() + "\n\n# end sentinel\n";
+		var re = new RegExp( "(^|\\n)(\\#+)\\s+(" + Tools.escapeRegExp(heading) + ")\\n([\\s\\S]*?)\\n\#+\\s+" );
+		var matches = md.match(re);
+		if (!matches) {
+			var msg = 'Could not find help chapter for "' + heading + '".';
+			
+			// Extract the user-visible Markdown headings and reuse the same conservative
+			// Levenshtein matcher used for API property typo suggestions.  The final
+			// heading is synthetic and exists only to terminate the section regex.
+			var headings = Array.from( md.matchAll(/^\#+\s+(.+?)\s*$/gm), match => match[1] );
+			headings = headings.filter( heading => heading != 'end sentinel' );
+			var suggestion = this.findClosestString(heading, headings);
+			if (suggestion) msg += ' Did you mean "' + suggestion + '"?';
+			
+			this.die(msg);
+		}
+		
+		if (heading == 'help') heading = 'overview';
+		println( "\n " + this.color('theme').bold( 'HELP: ' + heading.toUpperCase() ) );
+		println( "\n" + this.markdown( matches[4].trim() ).trimEnd() );
+	},
+	
+	dieUsage(heading) {
+		// print help and exit
+		this.printHelp(heading);
+		println("");
+		process.exit(1);
+	},
+	
+	die(msg, extra = "") {
+		// colorful die
+		cli.progress.end();
+		if (typeof(msg) == 'object') {
+			print("\n");
+			console.error(msg);
+			if (msg.message) msg = msg.message;
+		}
+		cli.args.quiet = false;
+		die( "\n ❌ " + red.bold("ERROR: ") + yellow.bold(msg) + "\n\n" + extra );
+	}
+	
+};
+
+Tools.mergeHashInto( app, require('./lib/utils.js') );
+Tools.mergeHashInto( app, require('./lib/config.js') );
+Tools.mergeHashInto( app, require('./lib/doc.js') );
+Tools.mergeHashInto( app, require('./lib/dashboard.js') );
+Tools.mergeHashInto( app, require('./lib/system.js') );
+Tools.mergeHashInto( app, require('./lib/events.js') );
+Tools.mergeHashInto( app, require('./lib/jobs.js') );
+Tools.mergeHashInto( app, require('./lib/apikey.js') );
+Tools.mergeHashInto( app, require('./lib/alerts.js') );
+Tools.mergeHashInto( app, require('./lib/buckets.js') );
+Tools.mergeHashInto( app, require('./lib/categories.js') );
+Tools.mergeHashInto( app, require('./lib/channels.js') );
+Tools.mergeHashInto( app, require('./lib/log.js') );
+Tools.mergeHashInto( app, require('./lib/monitors.js') );
+Tools.mergeHashInto( app, require('./lib/plugins.js') );
+Tools.mergeHashInto( app, require('./lib/servers.js') );
+Tools.mergeHashInto( app, require('./lib/groups.js') );
+Tools.mergeHashInto( app, require('./lib/snapshots.js') );
+Tools.mergeHashInto( app, require('./lib/secrets.js') );
+Tools.mergeHashInto( app, require('./lib/tags.js') );
+Tools.mergeHashInto( app, require('./lib/tickets.js') );
+Tools.mergeHashInto( app, require('./lib/webhook.js') );
+Tools.mergeHashInto( app, require('./lib/transfer.js') );
+Tools.mergeHashInto( app, require('./lib/marketplace.js') );
+Tools.mergeHashInto( app, require('./lib/sync.js') );
+
+global.app = app;
+
+app.run().catch( function(err) {
+	app.die(err);
+} );