@gwatch/gwatch-cli 1.0.0

package/README.md

@@ -0,0 +1,64 @@
+# G-Watch CLI
+
+G-Watch CLI is a tool that wraps Docker and Tmux to manage persistent development environments.
+
+## Features
+
+- **Workspace Management**: Clone remote repos or map local directories.
+- **Environment Automation**: Automatically installs Node.js, Tmux, and `@google/gemini-cli` inside the container.
+- **Session Management**: Wraps Tmux sessions for persistent development.
+- **Easy Access**: Simple commands to create, enter, list, and stop environments.
+
+## Installation
+
+Install globally via npm:
+
+```bash
+npm install -g @gwatch/gwatch-cli
+```
+
+Alternatively, to install from source:
+
+```bash
+git clone https://github.com/G-Watch/Watchtower.git
+cd Watchtower
+npm install -g .
+```
+
+## Usage
+
+### 1. Create a container from a remote git repo
+```bash
+gwatch-cli create --repo https://github.com/user/project.git --dockerfile ./Dockerfile
+```
+
+### 2. Create a container from current local directory
+```bash
+gwatch-cli create --dir . --dockerfile ./Dockerfile
+```
+
+### 3. Enter a container/session
+```bash
+# Enter container 0, default session
+gwatch-cli enter 0
+
+# Enter container 0, specific session (creates if not exists)
+gwatch-cli enter 0/debug_sass
+```
+
+### 4. List status
+```bash
+gwatch-cli ls
+```
+
+### 5. Stop commands
+```bash
+# Stops the Docker Container
+gwatch-cli stop 0
+
+# Kills only the specific tmux session inside the container
+gwatch-cli stop 0/debug_sass
+```
+
+## Internal Database
+Metadata is stored in `~/.watchtower/db.json`.

package/dist/commands/create.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAction = createAction;
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const docker_1 = require("../docker");
+const db_1 = require("../db");
+const ui_1 = require("../utils/ui");
+async function createAction(options) {
+    const { repo, dir, dockerfile, name: suffix } = options;
+    if (!repo && !dir) {
+        console.error('Error: You must provide either --repo or --dir');
+        process.exit(1);
+    }
+    let workspacePath;
+    let baseName;
+    if (repo) {
+        baseName = repo.split('/').pop()?.replace('.git', '') || 'unknown';
+        workspacePath = path_1.default.join(os_1.default.tmpdir(), 'watchtower', baseName);
+        await fs_extra_1.default.ensureDir(workspacePath);
+        await (0, docker_1.cloneRepo)(repo, workspacePath);
+    }
+    else {
+        workspacePath = path_1.default.resolve(dir);
+        baseName = path_1.default.basename(workspacePath);
+    }
+    const userName = os_1.default.userInfo().username;
+    const db = await (0, db_1.readDb)();
+    let index = 1;
+    const generateContainerName = (idx) => {
+        const parts = [baseName, userName];
+        if (suffix)
+            parts.push(suffix);
+        parts.push(idx.toString());
+        return parts.join('-');
+    };
+    let containerName = generateContainerName(index);
+    while (db.containers.some(c => c.name === containerName)) {
+        index++;
+        containerName = generateContainerName(index);
+    }
+    const imageName = await (0, docker_1.buildImage)(dockerfile, baseName, workspacePath);
+    const container = await (0, docker_1.createContainer)(imageName, containerName, workspacePath);
+    console.log('Setting up environment (Node.js, Tmux, Gemini CLI)...');
+    await (0, docker_1.ensureEnvironment)(container.id);
+    console.log('Setting up default tmux session...');
+    await (0, docker_1.setupDefaultTmux)(container.id);
+    await (0, db_1.addContainer)({
+        id: container.id,
+        name: containerName,
+        creator: userName,
+        repoUrl: repo,
+        localDir: dir ? path_1.default.resolve(dir) : undefined,
+        sessions: [{ name: 'default', lastAccess: new Date().toISOString() }],
+    });
+    (0, ui_1.logSuccess)(`Container ${containerName} created successfully! (Index: ${db.containers.length})`);
+}

package/dist/commands/enter.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enterAction = enterAction;
+const db_1 = require("../db");
+const execa_1 = require("execa");
+const ui_1 = require("../utils/ui");
+async function enterAction(target) {
+    const [indexStr, sessionName] = target.split('/');
+    const index = parseInt(indexStr, 10);
+    const db = await (0, db_1.readDb)();
+    const container = db.containers[index];
+    if (!container) {
+        (0, ui_1.logError)(`Container at index ${index} not found.`);
+        process.exit(1);
+    }
+    const finalSessionName = sessionName || 'default';
+    // Check if session exists, if not create it
+    try {
+        await (0, execa_1.execa)('docker', ['exec', container.id, 'tmux', 'has-session', '-t', finalSessionName]);
+    }
+    catch (e) {
+        (0, ui_1.logInfo)(`Session ${finalSessionName} not found. Creating it...`);
+        await (0, execa_1.execa)('docker', ['exec', container.id, 'tmux', 'new-session', '-d', '-s', finalSessionName]);
+    }
+    await (0, db_1.updateContainerSession)(container.name, finalSessionName);
+    (0, ui_1.logInfo)(`Entering session ${finalSessionName} in container ${container.name}...`);
+    try {
+        await (0, execa_1.execa)('docker', ['exec', '-it', container.id, 'tmux', 'attach', '-t', finalSessionName], {
+            stdio: 'inherit',
+        });
+    }
+    catch (e) {
+        (0, ui_1.logError)(`Error attaching to tmux session: ${e.message}`);
+    }
+}

package/dist/commands/ls.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lsAction = lsAction;
+const db_1 = require("../db");
+const docker_1 = require("../docker");
+const ui_1 = require("../utils/ui");
+async function lsAction() {
+    const db = await (0, db_1.readDb)();
+    const runningContainers = await (0, docker_1.getRunningContainers)();
+    let output = '| Index/Session | Container Name       | Creator | Uptime               | Last Access |\n';
+    output += '|---------------|----------------------|---------|----------------------|-------------|\n';
+    db.containers.forEach((container, idx) => {
+        const dockerInfo = runningContainers.find(c => c.Id === container.id || c.Names.some(n => n.includes(container.name)));
+        const uptime = dockerInfo ? dockerInfo.Status : 'Stopped';
+        container.sessions.forEach(session => {
+            const lastAccess = new Date(session.lastAccess);
+            const today = new Date();
+            let lastAccessStr = lastAccess.toLocaleString();
+            if (lastAccess.toDateString() === today.toDateString()) {
+                lastAccessStr = `${lastAccess.getHours().toString().padStart(2, '0')}:${lastAccess.getMinutes().toString().padStart(2, '0')} Today`;
+            }
+            output += `| ${(idx + '/' + session.name).padEnd(13)} | ${container.name.padEnd(20)} | ${container.creator.padEnd(7)} | ${uptime.padEnd(20)} | ${lastAccessStr} |\n`;
+        });
+    });
+    (0, ui_1.renderBox)(output, 'Watchtower Environments');
+}

package/dist/commands/stop.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopAction = stopAction;
+const db_1 = require("../db");
+const execa_1 = require("execa");
+const dockerode_1 = __importDefault(require("dockerode"));
+const ui_1 = require("../utils/ui");
+const docker = new dockerode_1.default();
+async function stopAction(target) {
+    const parts = target.split('/');
+    const index = parseInt(parts[0], 10);
+    const sessionName = parts[1];
+    const db = await (0, db_1.readDb)();
+    const containerInfo = db.containers[index];
+    if (!containerInfo) {
+        (0, ui_1.logError)(`Container at index ${index} not found.`);
+        process.exit(1);
+    }
+    if (sessionName) {
+        try {
+            await (0, execa_1.execa)('docker', ['exec', containerInfo.id, 'tmux', 'kill-session', '-t', sessionName]);
+            await (0, db_1.removeSession)(index, sessionName);
+            (0, ui_1.logSuccess)(`Tmux session ${sessionName} in container ${containerInfo.name} stopped.`);
+        }
+        catch (e) {
+            (0, ui_1.logError)(`Error killing session ${sessionName}: ${e.message}`);
+        }
+    }
+    else {
+        try {
+            const container = docker.getContainer(containerInfo.id);
+            await container.stop();
+            await container.remove();
+            await (0, db_1.removeContainer)(containerInfo.name);
+            (0, ui_1.logSuccess)(`Container ${containerInfo.name} stopped and removed.`);
+        }
+        catch (e) {
+            (0, ui_1.logError)(`Error stopping container ${containerInfo.name}: ${e.message}`);
+        }
+    }
+}

package/dist/db.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initDb = initDb;
+exports.readDb = readDb;
+exports.writeDb = writeDb;
+exports.updateContainerSession = updateContainerSession;
+exports.addContainer = addContainer;
+exports.removeContainer = removeContainer;
+exports.removeSession = removeSession;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const zod_1 = require("zod");
+const DB_DIR = path_1.default.join(os_1.default.homedir(), '.watchtower');
+const DB_FILE = path_1.default.join(DB_DIR, 'db.json');
+const SessionSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    lastAccess: zod_1.z.string(),
+});
+const ContainerSchema = zod_1.z.object({
+    id: zod_1.z.string(), // Docker container ID
+    name: zod_1.z.string(), // Watchtower container name
+    creator: zod_1.z.string(),
+    repoUrl: zod_1.z.string().optional(),
+    localDir: zod_1.z.string().optional(),
+    sessions: zod_1.z.array(SessionSchema),
+});
+const DatabaseSchema = zod_1.z.object({
+    containers: zod_1.z.array(ContainerSchema),
+});
+async function initDb() {
+    await fs_extra_1.default.ensureDir(DB_DIR);
+    if (!(await fs_extra_1.default.pathExists(DB_FILE))) {
+        await fs_extra_1.default.writeJson(DB_FILE, { containers: [] });
+    }
+}
+async function readDb() {
+    await initDb();
+    const data = await fs_extra_1.default.readJson(DB_FILE);
+    return DatabaseSchema.parse(data);
+}
+async function writeDb(db) {
+    await fs_extra_1.default.writeJson(DB_FILE, db, { spaces: 2 });
+}
+async function updateContainerSession(containerName, sessionName) {
+    const db = await readDb();
+    const container = db.containers.find(c => c.name === containerName);
+    if (container) {
+        const session = container.sessions.find(s => s.name === sessionName);
+        const now = new Date().toISOString();
+        if (session) {
+            session.lastAccess = now;
+        }
+        else {
+            container.sessions.push({ name: sessionName, lastAccess: now });
+        }
+        await writeDb(db);
+    }
+}
+async function addContainer(container) {
+    const db = await readDb();
+    db.containers.push(container);
+    await writeDb(db);
+}
+async function removeContainer(containerName) {
+    const db = await readDb();
+    db.containers = db.containers.filter(c => c.name !== containerName);
+    await writeDb(db);
+}
+async function removeSession(containerIndex, sessionName) {
+    const db = await readDb();
+    const container = db.containers[containerIndex];
+    if (container) {
+        container.sessions = container.sessions.filter(s => s.name !== sessionName);
+        await writeDb(db);
+    }
+}

package/dist/docker.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRunningContainers = getRunningContainers;
+exports.buildImage = buildImage;
+exports.createContainer = createContainer;
+exports.ensureEnvironment = ensureEnvironment;
+exports.setupDefaultTmux = setupDefaultTmux;
+exports.cloneRepo = cloneRepo;
+const dockerode_1 = __importDefault(require("dockerode"));
+const execa_1 = require("execa");
+const path_1 = __importDefault(require("path"));
+const ora_1 = __importDefault(require("ora"));
+const ui_1 = require("./utils/ui");
+const docker = new dockerode_1.default();
+async function getRunningContainers() {
+    return await docker.listContainers();
+}
+async function runInBox(title, cmd, args, options = {}) {
+    const dynamicBox = new ui_1.DynamicBox(title);
+    const subprocess = (0, execa_1.execa)(cmd, args, {
+        ...options,
+        all: true,
+    });
+    if (subprocess.all) {
+        subprocess.all.on('data', (data) => {
+            const lines = data.toString().split('\n');
+            lines.forEach((line) => dynamicBox.update(line));
+        });
+    }
+    try {
+        const result = await subprocess;
+        dynamicBox.stop();
+        return result;
+    }
+    catch (error) {
+        dynamicBox.stop();
+        throw error;
+    }
+}
+async function buildImage(dockerfilePath, repoName, contextDir) {
+    const imageName = `watchtower-${repoName.toLowerCase().replace(/[^a-z0-9]/g, '-')}`;
+    console.log(`Building image ${imageName}...`);
+    try {
+        await runInBox(`Building Image: ${imageName}`, 'docker', [
+            'build', '-t', imageName, '-f', path_1.default.resolve(dockerfilePath), '.'
+        ], {
+            cwd: contextDir,
+            env: { ...process.env, DOCKER_BUILDKIT: '0' }
+        });
+        (0, ui_1.logSuccess)(`Image ${imageName} built successfully.`);
+        return imageName;
+    }
+    catch (error) {
+        (0, ui_1.logError)(`Failed to build image ${imageName}.`);
+        (0, ui_1.renderBox)(error.stderr || error.message, 'Docker Build Error', 'red');
+        process.exit(1);
+    }
+}
+async function createContainer(imageName, containerName, workspacePath) {
+    const spinner = (0, ora_1.default)(`Creating container ${containerName}...`).start();
+    try {
+        const container = await docker.createContainer({
+            Image: imageName,
+            name: containerName,
+            Tty: true,
+            OpenStdin: true,
+            HostConfig: {
+                Binds: [`${path_1.default.resolve(workspacePath)}:/workspace`],
+            },
+            WorkingDir: '/workspace',
+            Cmd: ['/bin/bash'],
+        });
+        await container.start();
+        spinner.succeed(`Container ${containerName} started.`);
+        return container;
+    }
+    catch (error) {
+        spinner.fail(`Failed to create or start container ${containerName}.`);
+        (0, ui_1.renderBox)(error.json?.message || error.message, 'Docker Container Error', 'red');
+        process.exit(1);
+    }
+}
+async function ensureEnvironment(containerId) {
+    const container = docker.getContainer(containerId);
+    console.log('Configuring environment inside container...');
+    const setupCommands = [
+        { name: 'Node.js', cmd: 'which node || (apt-get update && apt-get install -y curl && curl -fsSL https://deb.nodesource.com/setup_current.x | bash - && apt-get install -y nodejs)' },
+        { name: 'Tmux', cmd: 'which tmux || (apt-get update && apt-get install -y tmux)' },
+        { name: 'Gemini CLI', cmd: 'which gemini || npm install -g @google/gemini-cli' },
+    ];
+    for (const item of setupCommands) {
+        try {
+            await runInBox(`Installing ${item.name}`, 'docker', ['exec', containerId, 'bash', '-c', item.cmd]);
+        }
+        catch (error) {
+            (0, ui_1.logError)(`Failed to install ${item.name}.`);
+            (0, ui_1.renderBox)(error.message, 'Environment Setup Error', 'red');
+            process.exit(1);
+        }
+    }
+    (0, ui_1.logSuccess)('Environment configured successfully.');
+}
+async function setupDefaultTmux(containerId) {
+    const spinner = (0, ora_1.default)('Starting default tmux session...').start();
+    try {
+        const container = docker.getContainer(containerId);
+        const exec = await container.exec({
+            Cmd: ['tmux', 'new-session', '-d', '-s', 'default'],
+        });
+        await exec.start({});
+        spinner.succeed('Default tmux session started.');
+    }
+    catch (error) {
+        spinner.fail('Failed to start default tmux session.');
+        process.exit(1);
+    }
+}
+async function cloneRepo(repoUrl, targetDir) {
+    console.log(`Cloning repository ${repoUrl}...`);
+    try {
+        await runInBox(`Cloning Repository`, 'git', ['clone', '--recursive', repoUrl, targetDir]);
+        (0, ui_1.logSuccess)('Repository cloned successfully.');
+    }
+    catch (error) {
+        (0, ui_1.logError)(`Failed to clone repository ${repoUrl}.`);
+        (0, ui_1.renderBox)(error.stderr || error.message, 'Git Clone Error', 'red');
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const create_1 = require("./commands/create");
+const enter_1 = require("./commands/enter");
+const ls_1 = require("./commands/ls");
+const stop_1 = require("./commands/stop");
+const { version } = require('../package.json');
+const program = new commander_1.Command();
+const LOGO = `
+
+▄▄▄▄  ▄▄▄  ▄▄▄▄                  ▄▄   ▄▄▄▄▄▄▄▄▄                        
+▀███  ███  ███▀       ██         ██   ▀▀▀███▀▀▀                        
+ ███  ███  ███  ▀▀█▄ ▀██▀▀ ▄████ ████▄   ███ ▄███▄ ██   ██ ▄█▀█▄ ████▄ 
+ ███▄▄███▄▄███ ▄█▀██  ██   ██    ██ ██   ███ ██ ██ ██ █ ██ ██▄█▀ ██ ▀▀ 
+  ▀████▀████▀  ▀█▄██  ██   ▀████ ██ ██   ███ ▀███▀  ██▀██  ▀█▄▄▄ ██    
+
+`;
+program
+    .name('gwatch-cli')
+    .description('Persistent development environments wrapper for Docker and Tmux')
+    .version(version)
+    .addHelpText('before', LOGO);
+program
+    .command('create')
+    .description('Create a container from a remote git repo or local directory')
+    .option('--repo <url>', 'Git repository URL')
+    .option('--dir <path>', 'Local directory path')
+    .option('--dockerfile <path>', 'Path to Dockerfile', './Dockerfile')
+    .option('--name <name>', 'Optional name override')
+    .action(create_1.createAction);
+program
+    .command('enter <target>')
+    .description('Enter a container/session (e.g., 0/default)')
+    .action(enter_1.enterAction);
+program
+    .command('ls')
+    .description('List containers and sessions')
+    .action(ls_1.lsAction);
+program
+    .command('stop <target>')
+    .description('Stop a container or a specific tmux session')
+    .action(stop_1.stopAction);
+// Logic to show logo and help if no command is provided
+if (process.argv.length === 2) {
+    program.help();
+}
+// Logic to show logo on version
+if (process.argv.includes('-V') || process.argv.includes('--version')) {
+    console.log(LOGO);
+}
+program.parse(process.argv);

package/dist/utils/ui.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicBox = void 0;
+exports.renderBox = renderBox;
+exports.logInfo = logInfo;
+exports.logSuccess = logSuccess;
+exports.logError = logError;
+const boxen_1 = __importDefault(require("boxen"));
+const chalk_1 = __importDefault(require("chalk"));
+const log_update_1 = __importDefault(require("log-update"));
+function renderBox(content, title, color = 'cyan') {
+    console.log((0, boxen_1.default)(content, {
+        padding: 1,
+        margin: 1,
+        borderStyle: 'round',
+        borderColor: color,
+        title: title ? chalk_1.default.bold(title) : undefined,
+        titleAlignment: 'left',
+    }));
+}
+function logInfo(message) {
+    console.log(chalk_1.default.blue('ℹ ') + message);
+}
+function logSuccess(message) {
+    console.log(chalk_1.default.green('✔ ') + message);
+}
+function logError(message) {
+    console.log(chalk_1.default.red('▀ ') + message);
+}
+class DynamicBox {
+    lines = [];
+    maxLines;
+    title;
+    color;
+    constructor(title, maxLines = 10, color = 'cyan') {
+        this.title = title;
+        this.maxLines = maxLines;
+        this.color = color;
+    }
+    update(line) {
+        if (!line.trim())
+            return;
+        this.lines.push(line.trim());
+        if (this.lines.length > this.maxLines) {
+            this.lines.shift();
+        }
+        this.render();
+    }
+    render() {
+        const content = this.lines.join('\n');
+        (0, log_update_1.default)((0, boxen_1.default)(content, {
+            padding: { left: 1, right: 1, top: 0, bottom: 0 },
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: this.color,
+            title: chalk_1.default.bold(this.title),
+            titleAlignment: 'left',
+        }));
+    }
+    stop() {
+        log_update_1.default.done();
+    }
+}
+exports.DynamicBox = DynamicBox;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@gwatch/gwatch-cli",
+  "version": "1.0.0",
+  "description": "Watchtower: Persistent development environments wrapper for Docker and Tmux",
+  "main": "dist/index.js",
+  "bin": {
+    "gwatch-cli": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "ts-node src/index.ts",
+    "watch": "tsc -w",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/G-Watch/Watchtower.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/G-Watch/Watchtower/issues"
+  },
+  "homepage": "https://github.com/G-Watch/Watchtower#readme",
+  "dependencies": {
+    "boxen": "5.1.2",
+    "chalk": "4.1.2",
+    "commander": "^14.0.3",
+    "dockerode": "^4.0.9",
+    "execa": "^9.6.1",
+    "fs-extra": "^11.3.3",
+    "log-update": "4.0.0",
+    "ora": "5.4.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/chalk": "^2.2.0",
+    "@types/dockerode": "^4.0.1",
+    "@types/fs-extra": "^11.0.4",
+    "@types/log-update": "^3.0.0",
+    "@types/node": "^25.2.2",
+    "@types/ora": "^5.2.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}