vibebox 0.0.0 → 0.0.2

package/dist/update.js

@@ -0,0 +1,256 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashString = hashString;
+exports.getExpectedBuildHash = getExpectedBuildHash;
+exports.getImageBuildHash = getImageBuildHash;
+exports.checkForUpdates = checkForUpdates;
+exports.checkVersions = checkVersions;
+const node_child_process_1 = require("node:child_process");
+const node_readline_1 = require("node:readline");
+const node_fs_1 = require("node:fs");
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = require("node:path");
+function getVersion(cmd) {
+    const out = (0, node_child_process_1.execSync)(cmd, { encoding: "utf8" });
+    const match = out.match(/^(\d+\.\d+\.\d+(-[^\s]+)?)/);
+    return match ? match[1] : out.trim();
+}
+function parseSemVer(version) {
+    const match = version.match(/^(\d+)\.(\d+)\.(\d+)(-([^\s]+))?$/);
+    if (!match)
+        return null;
+    return {
+        major: parseInt(match[1], 10),
+        minor: parseInt(match[2], 10),
+        patch: parseInt(match[3], 10),
+        prerelease: match[5] || "",
+    };
+}
+function compareVersions(v1, v2) {
+    const a = parseSemVer(v1);
+    const b = parseSemVer(v2);
+    if (!a || !b)
+        return 0; // Can't compare, treat as equal
+    if (a.major !== b.major)
+        return a.major - b.major;
+    if (a.minor !== b.minor)
+        return a.minor - b.minor;
+    if (a.patch !== b.patch)
+        return a.patch - b.patch;
+    // Handle prerelease: no prerelease > prerelease, then lexicographic
+    if (!a.prerelease && b.prerelease)
+        return 1;
+    if (a.prerelease && !b.prerelease)
+        return -1;
+    if (a.prerelease && b.prerelease) {
+        return a.prerelease.localeCompare(b.prerelease);
+    }
+    return 0;
+}
+function promptUser(question) {
+    const rl = (0, node_readline_1.createInterface)({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+function updateHost(agentCommand, version) {
+    console.log(`\nUpdating host ${agentCommand}${version ? ` to ${version}` : " to latest"}...`);
+    const args = version ? ["install", version] : ["install"];
+    const result = (0, node_child_process_1.spawnSync)(agentCommand, args, {
+        stdio: "inherit",
+    });
+    if (result.status !== 0) {
+        throw new Error(`Failed to update host ${agentCommand}`);
+    }
+}
+function updateSandbox(sandboxName, agentCommand, version) {
+    console.log(`\nUpdating sandbox ${agentCommand}${version ? ` to ${version}` : " to latest"}...`);
+    const args = ["exec", "-it", sandboxName, agentCommand, "install"];
+    if (version)
+        args.push(version);
+    const result = (0, node_child_process_1.spawnSync)("docker", args, { stdio: "inherit" });
+    if (result.status !== 0) {
+        throw new Error(`Failed to update sandbox ${agentCommand}`);
+    }
+}
+function verifyVersionsMatch({ sandboxName, versionCommand, successMsg }) {
+    const newHost = getVersion(versionCommand);
+    const newSandbox = getVersion(`docker exec ${sandboxName} ${versionCommand}`);
+    if (newHost === newSandbox) {
+        console.log(`\nSuccess! ${successMsg} ${newHost}`);
+    }
+    else {
+        console.error(`\nWarning: Versions still differ after update. Host: ${newHost}, Sandbox: ${newSandbox}`);
+        process.exit(1);
+    }
+}
+// ============ Build Hash Functions ============
+function hashString(content) {
+    return (0, node_crypto_1.createHash)("sha256").update(content).digest("hex").slice(0, 16);
+}
+function getExpectedBuildHash() {
+    try {
+        const pkgPath = (0, node_path_1.join)((0, node_path_1.dirname)(__dirname), "package.json");
+        const pkg = JSON.parse((0, node_fs_1.readFileSync)(pkgPath, "utf8"));
+        return pkg.vibebox?.version?.build ?? null;
+    }
+    catch { }
+    return null;
+}
+function getImageBuildHash() {
+    try {
+        const out = (0, node_child_process_1.execFileSync)("docker", ["image", "inspect", "vibebox", "--format", '{{index .Config.Labels "vibebox.version.build"}}'], { encoding: "utf8" }).trim();
+        return out || null;
+    }
+    catch { }
+    return null;
+}
+function getLatestNpmVersion() {
+    try {
+        return (0, node_child_process_1.execSync)("npm view vibebox version", { encoding: "utf8" }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function getCurrentVersion() {
+    const pkgPath = (0, node_path_1.join)((0, node_path_1.dirname)(__dirname), "package.json");
+    const pkg = JSON.parse((0, node_fs_1.readFileSync)(pkgPath, "utf8"));
+    return pkg.version;
+}
+async function checkForUpdates() {
+    const currentVersion = getCurrentVersion();
+    const latestVersion = getLatestNpmVersion();
+    // Check npm version FIRST - if updated, new code will handle hash checks
+    if (latestVersion && compareVersions(latestVersion, currentVersion) > 0) {
+        console.log(`\nvibebox update available: ${latestVersion} (current: ${currentVersion})`);
+        const answer = await promptUser(`\nUpdate now? [Y/n]: `);
+        if (answer.toLowerCase() !== "n") {
+            console.log("\nUpdating vibebox...");
+            const r = (0, node_child_process_1.spawnSync)("npm", ["install", "-g", "vibebox@latest"], { stdio: "inherit" });
+            if (r.status !== 0) {
+                console.error("Failed to update vibebox");
+                process.exit(1);
+            }
+            console.log("\nUpdate complete! Please run your command again.");
+            process.exit(0);
+        }
+    }
+    // Check image build hash
+    const expectedHash = getExpectedBuildHash();
+    const imageHash = getImageBuildHash();
+    let needsRebuild = false;
+    if (expectedHash && imageHash && expectedHash !== imageHash) {
+        console.log("\nvibebox image is outdated (build files have changed)");
+        needsRebuild = true;
+    }
+    else if (expectedHash && !imageHash) {
+        // Image exists but has no/old hash label
+        try {
+            (0, node_child_process_1.execSync)("docker image inspect vibebox", { stdio: "pipe" });
+            console.log("\nvibebox image is outdated (missing build hash)");
+            needsRebuild = true;
+        }
+        catch {
+            // No image exists, will be built on first use
+        }
+    }
+    if (needsRebuild) {
+        const answer = await promptUser(`Rebuild image? [Y/n]: `);
+        if (answer.toLowerCase() !== "n") {
+            console.log("\nRebuilding vibebox image...");
+            try {
+                (0, node_child_process_1.execSync)("docker rmi vibebox", { stdio: "pipe" });
+            }
+            catch { }
+            const { buildImage } = await Promise.resolve().then(() => __importStar(require("./index")));
+            buildImage();
+            console.log("Image rebuilt!");
+        }
+    }
+}
+async function checkVersions(sandboxName, agent) {
+    const versionCommand = agent?.versionCommand ?? "claude --version";
+    const agentName = agent?.name ?? "Claude Code";
+    const agentCommand = agent?.command ?? "claude";
+    try {
+        const host = getVersion(versionCommand);
+        const sandbox = getVersion(`docker exec ${sandboxName} ${versionCommand}`);
+        if (host !== sandbox) {
+            const comparison = compareVersions(host, sandbox);
+            const higher = comparison >= 0 ? host : sandbox;
+            console.error(`\n${agentName} version mismatch! Host: ${host}, Sandbox: ${sandbox}`);
+            const answer = await promptUser(`\nChoose update strategy:
+  [1] Sync to higher version (${higher})
+  [2] Update both to latest
+  [N] Cancel
+
+Your choice: `);
+            if (answer === "1") {
+                // Sync to higher version
+                if (comparison >= 0) {
+                    updateSandbox(sandboxName, agentCommand, host);
+                }
+                else {
+                    updateHost(agentCommand, sandbox);
+                }
+                verifyVersionsMatch({ sandboxName, versionCommand, successMsg: "Both synced to" });
+            }
+            else if (answer === "2") {
+                // Update both to latest
+                updateHost(agentCommand);
+                updateSandbox(sandboxName, agentCommand);
+                verifyVersionsMatch({ sandboxName, versionCommand, successMsg: "Both updated to" });
+            }
+            else {
+                console.error(`
+Manual update options:
+  Update host:    ${agentCommand} install
+  Update sandbox: vibebox exec ${agentCommand} install
+  Or recreate:    vibebox rm && vibebox agent ${agentCommand}
+
+Note: If using alias, run 'unalias ${agentCommand}' first or 'command ${agentCommand} install' (macOS and linux).`);
+                process.exit(1);
+            }
+        }
+    }
+    catch {
+        /* sandbox not running, skip */
+    }
+}

package/package.json

@@ -1,37 +1,38 @@
 {
   "name": "vibebox",
-  "version": "0.0.0",
-  "description": "Sandboxed AI coding sessions with Claude Code in Docker containers",
-  "main": "dist/index.js",
+  "version": "0.0.2",
+  "license": "SEE LICENSE IN LICENSE.md",
   "bin": {
-    "vibebox": "./dist/cli.js"
+    "vibebox": "./dist/index.js"
   },
+  "files": [
+    "README.md",
+    "LICENSE.md",
+    "dist",
+    "Dockerfile",
+    "container-scripts"
+  ],
   "scripts": {
     "build": "tsc",
-    "dev": "tsc --watch",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "postbuild": "chmod +x dist/index.js",
+    "build:image": "docker build -t vibebox .",
+    "rebuild": "tsc && node scripts/update-build-hashes.mjs && vibebox rm --all && vibebox rebuild",
+    "preversion": "npm run build && node scripts/update-build-hashes.mjs",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
-  "keywords": [
-    "cli",
-    "docker",
-    "claude",
-    "ai",
-    "sandbox"
-  ],
-  "author": "",
-  "license": "",
   "dependencies": {
-    "chalk": "^4.1.2",
-    "commander": "^12.1.0",
-    "ora": "^5.4.1"
+    "commander": "^12.0.0"
   },
   "devDependencies": {
-    "@anthropic-ai/claude-code": "^1.0.53",
-    "@types/node": "^20.14.0",
-    "prettier": "^3.6.2",
-    "typescript": "^5.8.3"
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
   },
-  "engines": {
-    "node": ">=18.0.0"
+  "vibebox": {
+    "version": {
+      "build": "bc83a65b541a24ce"
+    }
   }
 }

package/.dockerignore

@@ -1,13 +0,0 @@
-node_modules
-dist
-.git
-.gitignore
-*.md
-.vscode
-.idea
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-.DS_Store
-Thumbs.db

package/LICENSE

@@ -1 +0,0 @@
-2025-present (c) Giuseppe Gurgone