viberun 0.0.1 → 0.3.5

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, AUTHORS
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -1,3 +1,380 @@
-# TypeScript Starter
+<p align="center">
+  <img src="assets/viberun-logo.png" alt="viberun logo" width="320">
+</p>
 
-Slim Boilerplate for TypeScript based projects.
+# viberun
+
+`viberun` is a CLI-first, agent-native app host. Run `viberun <app>` locally and get dropped into an agent session inside a persistent Ubuntu container on a remote host. App data is stored under `/home/viberun` and survives container restarts or image updates.
+
+## Quick start (end-to-end)
+
+You need a local machine with `ssh` and a reachable Ubuntu host (VM or server) that you can SSH into with sudo access.
+
+### 1) Install the CLI
+
+```bash
+curl -fsSL https://viberun.sh | bash
+```
+
+Verify:
+
+```bash
+viberun --version
+```
+
+Optional overrides (advanced):
+
+```bash
+curl -fsSL https://viberun.sh | bash -s -- --nightly
+curl -fsSL https://viberun.sh | bash -s -- --dir ~/.local/bin --bin viberun
+```
+
+Or with env vars:
+
+```bash
+curl -fsSL https://viberun.sh | VIBERUN_INSTALL_DIR=~/.local/bin VIBERUN_INSTALL_BIN=viberun bash
+```
+
+### 2) Bootstrap a host (once per VM)
+
+Use any SSH host alias (for example, `myhost` in `~/.ssh/config`):
+
+```bash
+viberun bootstrap myhost
+```
+
+Optional: set it as your default host (and agent) so you can omit `@host` later:
+
+```bash
+viberun config --host myhost --agent codex
+```
+
+### 3) Start your first app
+
+```bash
+viberun hello-world
+```
+
+If this is the first run, the server will prompt to create the container. Press Enter to accept.
+
+Detach without stopping the agent: Ctrl-\\ . Reattach later with `viberun hello-world`.
+Paste clipboard images into the session with Ctrl-V; `viberun` uploads the image and inserts a `/tmp/viberun-clip-*.png` path.
+
+### 4) Hello-world prompt (paste inside the session)
+
+```
+Create a beautiful hello-world web app with a simple, tasteful landing page.
+```
+
+### 5) Open the app
+
+While the session is active, `viberun` starts a localhost proxy to the host port. The agent will print a URL like:
+
+```
+http://localhost:8080
+```
+
+Open it in your browser.
+If you've configured app URLs, `viberun <app> url` shows the HTTPS address.
+
+## Common commands
+
+```bash
+viberun myapp
+viberun myapp@hostb
+viberun --forward-agent myapp
+viberun myapp shell
+viberun myapp snapshot
+viberun myapp snapshots
+viberun myapp restore latest
+viberun myapp url
+viberun myapp users
+viberun myapp --delete -y
+viberun myapp update
+viberun bootstrap [<host>]
+viberun proxy setup
+viberun users list
+viberun wipe
+viberun config --host myhost --agent codex
+viberun version
+```
+
+<details>
+<summary>Table of contents</summary>
+
+- [Quick start (end-to-end)](#quick-start-end-to-end)
+- [Common commands](#common-commands)
+- [Git setup](#git-setup)
+- [Development](#development)
+- [Architecture](#architecture)
+  - [High-level flow](#high-level-flow)
+  - [Core components](#core-components)
+  - [Session lifecycle](#session-lifecycle)
+  - [Bootstrap pipeline](#bootstrap-pipeline)
+  - [Networking and ports](#networking-and-ports)
+  - [App URLs and proxy](#app-urls-and-proxy)
+  - [Snapshots and restore](#snapshots-and-restore)
+  - [Host RPC bridge](#host-rpc-bridge)
+  - [Configuration and state](#configuration-and-state)
+  - [Agents](#agents)
+  - [Security model](#security-model)
+  - [Wipe (safety)](#wipe-safety)
+  - [Repository layout](#repository-layout)
+  - [Troubleshooting](#troubleshooting)
+
+</details>
+
+## Git setup
+
+Git, SSH, and the GitHub CLI are installed in containers. viberun seeds `git config --global user.name` and `user.email` from your local Git config into a host-managed config file that is mounted into each app container and applied on startup. This removes the common "first commit" setup step without auto-authing you.
+
+Choose one of these auth paths:
+
+- **SSH (agent forwarding)**: Run `viberun --forward-agent <app>`. For existing apps, run `viberun <app> update` once to recreate the container with the agent socket mounted. Then `ssh -T git@github.com` inside the container to verify access.
+- **HTTPS (GitHub CLI)**: Run `gh auth login` and choose HTTPS, then `gh auth setup-git`. Verify with `gh auth status`.
+
+If you update your local Git identity later, restart the app container (or run `viberun <app> update`) to re-apply the new values on startup.
+
+## Development
+
+This repo is Go-first and uses `mise` for tool and task orchestration.
+
+### Setup
+
+```bash
+mise install
+```
+
+### Build
+
+```bash
+mise exec -- go build ./cmd/viberun
+mise exec -- go build ./cmd/viberun-server
+```
+
+### Run locally
+
+```bash
+mise exec -- go run ./cmd/viberun -- --help
+mise exec -- go run ./cmd/viberun-server -- --help
+```
+
+### Test and vet
+
+```bash
+mise exec -- go test ./...
+mise exec -- go vet ./...
+```
+
+### Container image
+
+```bash
+mise run build:image
+# fallback: docker build -t viberun .
+# proxy image (Caddy + auth):
+docker build -f Dockerfile.proxy -t viberun-proxy .
+```
+
+### E2E and integration
+
+```bash
+bin/viberun-e2e-local
+bin/viberun-integration
+```
+
+### Bootstrap in development
+
+When you run `viberun` via `go run` (or a dev build), bootstrap defaults to staging the local server binary and building the container image locally. This is equivalent to:
+
+```bash
+viberun bootstrap --local --local-image myhost
+```
+
+Under the hood, it builds a `viberun:dev` image for the host architecture, streams it over `ssh` with `docker save | docker load`, and tags it as `viberun:latest` on the host.
+
+If you want to explicitly pass a local server binary:
+
+```bash
+mise exec -- go build -o /tmp/viberun-server ./cmd/viberun-server
+viberun bootstrap --local-path /tmp/viberun-server myhost
+```
+
+For the full build/test/E2E flow, see `DEVELOPMENT.md`.
+
+## Architecture
+
+### High-level flow
+
+```
+viberun <app>
+  -> ssh <host>
+    -> viberun-server <app>
+      -> docker container viberun-<app>
+        -> agent session (tmux)
+
+container port 8080
+  -> host port (assigned per app)
+    -> ssh -L localhost:<port>
+      -> http://localhost:<port>
+    -> (optional) host proxy (Caddy)
+      -> https://<app>.<domain>
+```
+
+### Core components
+
+- Client: `viberun` CLI on your machine.
+- Server: `viberun-server` executed on the host via SSH (no long-running daemon required).
+- Container: `viberun-<app>` Docker container built from the `viberun:latest` image.
+- Agent: runs inside the container in a tmux session (default provider: `codex`).
+- Host RPC: local Unix socket used by the container to request snapshot/restore operations.
+- Proxy (optional): `viberun-proxy` (Caddy + `viberun-auth`) for app URLs and login.
+
+### Session lifecycle
+
+1. `viberun <app>` resolves the host (from `@host` or your default config) and runs `viberun-server` over SSH.
+2. The server creates the container if needed, or starts it if it already exists.
+3. The agent process is attached via `docker exec` inside a tmux session so it persists across disconnects.
+4. `viberun` sets up a local port forward so you can open the app on `http://localhost:<port>`.
+
+### Bootstrap pipeline
+
+The bootstrap script (run on the host) does the following:
+
+- Verifies the host is Ubuntu.
+- Installs Docker (if missing) and enables it.
+- Installs Btrfs tools (`btrfs-progs`) for volume snapshots.
+- Pulls the `viberun` container image from GHCR (unless using local image mode).
+- Downloads and installs the `viberun-server` binary.
+
+If bootstrap is run from a TTY, it will offer to set up a public domain name (same as `viberun proxy setup`).
+
+Useful bootstrap overrides:
+
+- `VIBERUN_SERVER_REPO`: GitHub repo for releases (default `shayne/viberun`).
+- `VIBERUN_SERVER_VERSION`: release tag or `latest`.
+- `VIBERUN_IMAGE`: container image override.
+- `VIBERUN_PROXY_IMAGE`: proxy container image override (for app URLs).
+- `VIBERUN_SERVER_INSTALL_DIR`: install directory on the host.
+- `VIBERUN_SERVER_BIN`: server binary name on the host.
+- `VIBERUN_SERVER_LOCAL_PATH`: use a local server binary staged over SSH.
+- `VIBERUN_SKIP_IMAGE_PULL`: skip pulling from GHCR (used for local builds).
+
+### Networking and ports
+
+- Each app container exposes port `8080` internally.
+- The host port is assigned per app (starting at `8080`) and stored in the host server state.
+- `viberun` opens an SSH local forward so `http://localhost:<port>` connects to the host port.
+- If the proxy is configured, apps can also be served over HTTPS at `https://<app>.<domain>` (or a custom domain). Access requires login by default and can be made public per app.
+
+### App URLs and proxy
+
+`viberun` can optionally expose apps via a host-side proxy (Caddy + `viberun-auth`).
+Set it up once per host:
+
+```bash
+viberun proxy setup [<host>]
+```
+
+You'll be prompted for a base domain and public IP (for DNS), plus a primary username/password.
+Create an A record (or wildcard) pointing to the host's public IP.
+
+After setup:
+
+- `viberun <app> url` shows the current URL and access status.
+- `viberun <app> url --make-public` or `--require-login` toggles access (default requires login).
+- `viberun <app> url --set-domain <domain>` or `--reset-domain` manages custom domains.
+- `viberun <app> url --disable` or `--enable` turns the URL off/on.
+- `viberun <app> url --open` opens the URL in your browser.
+- `viberun users ...` manages login accounts; `viberun <app> users` controls who can access the app.
+
+If URL settings change, run `viberun <app> update` to refresh `VIBERUN_PUBLIC_URL` and `VIBERUN_PUBLIC_DOMAIN` inside the container.
+
+### Snapshots and restore
+
+Snapshots are Btrfs subvolume snapshots of the app's `/home/viberun` volume (auto-incremented versions).
+On the host, each app uses a loop-backed Btrfs file under `/var/lib/viberun/apps/<app>/home.btrfs`.
+
+- `viberun <app> snapshot` creates the next `vN` snapshot.
+- `viberun <app> snapshots` lists versions with timestamps.
+- `viberun <app> restore <vN|latest>` restores from a snapshot (`latest` picks the highest `vN`).
+- `viberun <app> --delete -y` removes the container, the app volume + snapshots, and the host RPC directory.
+
+Restore details:
+- The host stops the container (if running) to safely unmount the volume.
+- The current `@home` subvolume is replaced by a new writable snapshot of `@snapshots/vN`.
+- The container is started again, and s6 reloads services from `/home/viberun/.local/services`.
+
+### Host RPC bridge
+
+When you open a session, the server creates a Unix socket on the host and mounts it into the container at `/var/run/viberun-hostrpc`. The container uses it to request snapshot and restore operations. Access is protected by a per-session token file mounted alongside the socket.
+
+### Configuration and state
+
+Local config lives at `~/.config/viberun/config.toml` (or `$XDG_CONFIG_HOME/viberun/config.toml`) and stores:
+
+- `default_host`
+- `agent_provider`
+- `hosts` (alias mapping)
+
+Host server state lives at `~/.config/viberun/server-state.json` (or `$XDG_CONFIG_HOME/viberun/server-state.json`) and stores the port mapping for each app.
+
+Proxy config (when enabled) lives at `/var/lib/viberun/proxy.toml` (or `$VIBERUN_PROXY_CONFIG_PATH`) and stores the base domain, access rules, and users.
+When enabled, the server injects `VIBERUN_PUBLIC_URL` and `VIBERUN_PUBLIC_DOMAIN` into containers.
+
+### Agents
+
+Supported agent providers:
+
+- `codex` (default)
+- `claude`
+- `gemini`
+- `ampcode` (alias: `amp`)
+- `opencode`
+
+Custom agents can be run via `npx:<pkg>` or `uvx:<pkg>` (for example, `viberun --agent npx:@sourcegraph/amp@latest <app>`).
+
+Set globally with `viberun config --agent <provider>` or per-run with `viberun --agent <provider> <app>`.
+To forward your local SSH agent into the container, use `viberun --forward-agent <app>`. For existing apps, run `viberun <app> update` once to recreate the container with the agent socket mounted.
+
+Base skills are shipped in `/opt/viberun/skills` and symlinked into each agent's skills directory. User skills can be added directly to the agent-specific skills directory under `/home/viberun`.
+
+### Security model
+
+- All control traffic goes over SSH; the server is invoked on demand and does not expose a network port.
+- The host RPC socket is local-only and protected by filesystem permissions and a per-session token.
+- Containers are isolated by Docker and only the app port is exposed.
+- App URLs are optional: the proxy requires login by default and can be made public per app with `viberun <app> url --make-public`.
+
+### Wipe (safety)
+
+`viberun wipe [<host>]` deletes local config and wipes all viberun data on the host.
+It requires a TTY and asks you to type `WIPE`.
+
+On the host, wipe removes:
+
+- All containers named `viberun-*`, any containers using `viberun` images, and the proxy container (default `viberun-proxy`).
+- All `viberun` images (including the proxy image).
+- App data and snapshots under `/var/lib/viberun` (including per-app Btrfs volumes).
+- Host RPC sockets in `/tmp/viberun-hostrpc` and `/var/run/viberun-hostrpc`.
+- `/etc/viberun`, `/etc/sudoers.d/viberun-server`, and `/usr/local/bin/viberun-server`.
+
+Locally, it removes `~/.config/viberun/config.toml` (and legacy config if present).
+
+### Repository layout
+
+- `cmd/`: Go entrypoints (`viberun`, `viberun-server`, `viberun-auth`).
+- `internal/`: Core packages (config, server state, SSH args, target parsing, TUI helpers).
+- `bin/`: Helper scripts for installs, integration/E2E flows, and container utilities.
+- `skills/`: Codex skill definitions used inside containers.
+- `config/`: Shell/TMUX/Starship config, auth assets, and runtime configs.
+- `Dockerfile`: Base container image definition.
+- `Dockerfile.proxy`: Proxy image definition (Caddy + auth).
+
+### Troubleshooting
+
+- `unsupported OS: ... expected ubuntu`: bootstrap currently supports Ubuntu only.
+- `docker is required but was not found in PATH`: install Docker on the host or re-run bootstrap.
+- `missing btrfs on host`: rerun bootstrap to install `btrfs-progs` and ensure sudo access.
+- `no host provided and no default host configured`: run `viberun config --host myhost` or use `myapp@host`.
+- `container image architecture mismatch`: delete and recreate the app (`viberun <app> --delete -y`).
+- `proxy is not configured`: run `viberun proxy setup` (then retry `viberun <app> url`).

package/bin/viberun.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+// Unified entry point for the viberun CLI.
+
+import { spawn } from "node:child_process";
+import { existsSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+// __dirname equivalent in ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const { platform, arch } = process;
+
+let targetTriple = null;
+switch (platform) {
+  case "linux":
+  case "android":
+    switch (arch) {
+      case "x64":
+        targetTriple = "x86_64-unknown-linux-musl";
+        break;
+      case "arm64":
+        targetTriple = "aarch64-unknown-linux-musl";
+        break;
+      default:
+        break;
+    }
+    break;
+  case "darwin":
+    switch (arch) {
+      case "x64":
+        targetTriple = "x86_64-apple-darwin";
+        break;
+      case "arm64":
+        targetTriple = "aarch64-apple-darwin";
+        break;
+      default:
+        break;
+    }
+    break;
+  case "win32":
+    switch (arch) {
+      case "x64":
+        targetTriple = "x86_64-pc-windows-msvc";
+        break;
+      case "arm64":
+        targetTriple = "aarch64-pc-windows-msvc";
+        break;
+      default:
+        break;
+    }
+    break;
+  default:
+    break;
+}
+
+if (!targetTriple) {
+  throw new Error(`Unsupported platform: ${platform} (${arch})`);
+}
+
+const vendorRoot = path.join(__dirname, "..", "vendor");
+const archRoot = path.join(vendorRoot, targetTriple);
+const viberunBinaryName = process.platform === "win32" ? "viberun.exe" : "viberun";
+const binaryPath = path.join(archRoot, "viberun", viberunBinaryName);
+
+// Use an asynchronous spawn instead of spawnSync so that Node is able to
+// respond to signals (e.g. Ctrl-C / SIGINT) while the native binary is
+// executing. This allows us to forward those signals to the child process
+// and guarantees that when either the child terminates or the parent
+// receives a fatal signal, both processes exit in a predictable manner.
+
+function getUpdatedPath(newDirs) {
+  const pathSep = process.platform === "win32" ? ";" : ":";
+  const existingPath = process.env.PATH || "";
+  const updatedPath = [
+    ...newDirs,
+    ...existingPath.split(pathSep).filter(Boolean),
+  ].join(pathSep);
+  return updatedPath;
+}
+
+/**
+ * Use heuristics to detect the package manager that was used to install viberun
+ * in order to give the user a hint about how to update it.
+ */
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (/\bbun\//.test(userAgent)) {
+    return "bun";
+  }
+
+  const execPath = process.env.npm_execpath || "";
+  if (execPath.includes("bun")) {
+    return "bun";
+  }
+
+  if (
+    __dirname.includes(".bun/install/global") ||
+    __dirname.includes(".bun\\install\\global")
+  ) {
+    return "bun";
+  }
+
+  return userAgent ? "npm" : null;
+}
+
+const additionalDirs = [];
+const pathDir = path.join(archRoot, "path");
+if (existsSync(pathDir)) {
+  additionalDirs.push(pathDir);
+}
+const updatedPath = getUpdatedPath(additionalDirs);
+
+const env = { ...process.env, PATH: updatedPath };
+const packageManagerEnvVar =
+  detectPackageManager() === "bun"
+    ? "VIBERUN_MANAGED_BY_BUN"
+    : "VIBERUN_MANAGED_BY_NPM";
+env[packageManagerEnvVar] = "1";
+
+const child = spawn(binaryPath, process.argv.slice(2), {
+  stdio: "inherit",
+  env,
+});
+
+child.on("error", (err) => {
+  // Typically triggered when the binary is missing or not executable.
+  // Re-throwing here will terminate the parent with a non-zero exit code
+  // while still printing a helpful stack trace.
+  // eslint-disable-next-line no-console
+  console.error(err);
+  process.exit(1);
+});
+
+// Forward common termination signals to the child so that it shuts down
+// gracefully. In the handler we temporarily disable the default behavior of
+// exiting immediately; once the child has been signaled we simply wait for
+// its exit event which will in turn terminate the parent (see below).
+const forwardSignal = (signal) => {
+  if (child.killed) {
+    return;
+  }
+  try {
+    child.kill(signal);
+  } catch {
+    /* ignore */
+  }
+};
+
+["SIGINT", "SIGTERM", "SIGHUP"].forEach((sig) => {
+  process.on(sig, () => forwardSignal(sig));
+});
+
+// When the child exits, mirror its termination reason in the parent so that
+// shell scripts and other tooling observe the correct exit status.
+// Wrap the lifetime of the child process in a Promise so that we can await
+// its termination in a structured way. The Promise resolves with an object
+// describing how the child exited: either via exit code or due to a signal.
+const childResult = await new Promise((resolve) => {
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      resolve({ type: "signal", signal });
+    } else {
+      resolve({ type: "code", exitCode: code ?? 1 });
+    }
+  });
+});
+
+if (childResult.type === "signal") {
+  // Re-emit the same signal so that the parent terminates with the expected
+  // semantics (this also sets the correct exit code of 128 + n).
+  process.kill(process.pid, childResult.signal);
+} else {
+  process.exit(childResult.exitCode);
+}

package/package.json

@@ -1,95 +1,22 @@
 {
   "name": "viberun",
-  "version": "0.0.1",
-  "description": "CLI for quick app development",
-  "main": "dist/index.js",
-  "author": "Marvin Hagemeister <marvin@marvinhagemeister.de>",
-  "license": "MIT",
+  "version": "0.3.5",
+  "license": "BSD-3-Clause",
   "bin": {
-    "viberun": "dist/cli/bin.js"
+    "viberun": "bin/viberun.js"
   },
-  "scripts": {
-    "cleanup": "rimraf dist/",
-    "lint": "tslint 'src/**/*.ts'",
-    "watch": "tsc -w",
-    "build": "npm run cleanup && tsc",
-    "test": "mocha --compilers ts:ts-node/register 'src/**/__tests__/*.spec.ts'",
-    "test-watch": "npm t -- -w -R min",
-    "coverage": "nyc npm t",
-    "prepublish": "npm run lint && npm t && npm run build"
+  "type": "module",
+  "engines": {
+    "node": ">=16"
   },
-  "dependencies": {
-    "@types/autoprefixer": "^6.7.1",
-    "@types/html-webpack-plugin": "^2.28.0",
-    "@types/rimraf": "^0.0.28",
-    "@types/webpack": "^2.2.15",
-    "@types/webpack-dev-server": "^2.4.0",
-    "@types/webpack-merge": "^0.0.4",
-    "@types/yargs": "^6.6.0",
-    "autoprefixer": "^7.1.1",
-    "awesome-typescript-loader": "^3.1.3",
-    "babel-core": "^6.24.1",
-    "babel-loader": "^7.0.0",
-    "babel-plugin-syntax-dynamic-import": "^6.18.0",
-    "babel-plugin-transform-react-jsx-self": "^6.22.0",
-    "babel-plugin-transform-react-jsx-source": "^6.22.0",
-    "babel-preset-env": "^1.5.1",
-    "css-loader": "^0.28.2",
-    "extract-text-webpack-plugin": "^2.1.0",
-    "file-loader": "^0.11.1",
-    "html-webpack-plugin": "^2.28.0",
-    "nicer-fs": "^1.0.0",
-    "node-sass": "^4.5.3",
-    "raw-loader": "^0.5.1",
-    "sass-loader": "^6.0.5",
-    "script-ext-html-webpack-plugin": "^1.8.0",
-    "style-loader": "^0.18.0",
-    "url-loader": "^0.5.8",
-    "webpack": "^2.6.0",
-    "webpack-bundle-analyzer": "^2.8.2",
-    "webpack-dev-server": "^2.4.5",
-    "webpack-merge": "^4.1.0",
-    "yargs": "^8.0.1"
-  },
-  "devDependencies": {
-    "@types/chai": "^3.5.1",
-    "@types/extract-text-webpack-plugin": "^2.1.0",
-    "@types/mocha": "^2.2.41",
-    "@types/node": "^7.0.22",
-    "chai": "^4.0.0",
-    "mocha": "^3.3.0",
-    "nyc": "^10.2.0",
-    "rimraf": "^2.6.1",
-    "ts-node": "^3.0.2",
-    "tslint": "^5.1.0",
-    "tslint-config-sevenval": "^0.6.0",
-    "typescript": "^2.3.1"
-  },
-  "nyc": {
-    "include": [
-      "src/*.ts",
-      "src/**/*.ts"
-    ],
-    "exclude": [
-      "typings",
-      "node_modules/",
-      "**/__tests__/**",
-      "__tests__/**",
-      "**/*.d.ts"
-    ],
-    "extension": [
-      ".ts"
-    ],
-    "require": [
-      "ts-node/register"
-    ],
-    "reporter": [
-      "json",
-      "html",
-      "text",
-      "text-summary",
-      "lcovonly"
-    ],
-    "all": true
+  "files": [
+    "bin",
+    "vendor",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shayne/viberun.git"
   }
 }