vibebox 0.0.0 → 0.0.2

package/dist/agents/auth.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCredentialStore = getCredentialStore;
+exports.readCredentialsFile = readCredentialsFile;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+function getCredentialStore() {
+    switch ((0, node_os_1.platform)()) {
+        case "darwin":
+            return {
+                get: (service, account) => {
+                    try {
+                        return (0, node_child_process_1.execSync)(`security find-generic-password -a "${account}" -s "${service}" -w`, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+                    }
+                    catch {
+                        return null;
+                    }
+                },
+                set: (service, account, value) => {
+                    const hexData = Buffer.from(value, "utf-8").toString("hex");
+                    const input = `add-generic-password -U -a "${account}" -s "${service}" -X "${hexData}"\n`;
+                    (0, node_child_process_1.execSync)("security -i", {
+                        input,
+                        stdio: ["pipe", "pipe", "pipe"],
+                    });
+                },
+            };
+        case "win32":
+            // Use cmdkey (built-in) instead of CredentialManager module
+            return {
+                get: (service, account) => {
+                    try {
+                        const target = `${service}:${account}`.replace(/"/g, '""');
+                        // cmdkey /list doesn't expose password, use PowerShell with Windows Vault API
+                        const ps = `[Runtime.InteropServices.Marshal]::PtrToStringAuto([Runtime.InteropServices.Marshal]::SecureStringToBSTR((Get-StoredCredential -Target '${target}' -AsCredentialObject).Password))`;
+                        return (0, node_child_process_1.execSync)(`powershell -Command "${ps.replace(/"/g, '\\"')}"`, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim() || null;
+                    }
+                    catch {
+                        return null;
+                    }
+                },
+                set: (service, account, value) => {
+                    const target = `${service}:${account}`.replace(/"/g, '""');
+                    // Use base64 to avoid shell escaping issues with credentials
+                    const b64 = Buffer.from(value, "utf8").toString("base64");
+                    const ps = `$cred = [System.Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${b64}')); cmdkey /generic:"${target}" /user:"${account.replace(/"/g, '""')}" /pass:"$cred"`;
+                    (0, node_child_process_1.execSync)(`powershell -Command "${ps.replace(/"/g, '\\"')}"`, { stdio: ["pipe", "pipe", "pipe"] });
+                },
+            };
+        default:
+            // Linux: secret-tool (libsecret)
+            return {
+                get: (service, account) => {
+                    try {
+                        return (0, node_child_process_1.execSync)(`secret-tool lookup service "${service}" account "${account}"`, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+                    }
+                    catch {
+                        return null;
+                    }
+                },
+                set: (service, account, value) => {
+                    (0, node_child_process_1.execSync)(`echo -n "${value}" | secret-tool store --label="${service}" service "${service}" account "${account}"`);
+                },
+            };
+    }
+}
+function readCredentialsFile(path) {
+    try {
+        if (!(0, node_fs_1.existsSync)(path))
+            return null;
+        return JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/agents/claude/index.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claude = void 0;
+exports.getCredentialPaths = getCredentialPaths;
+const auth_1 = require("../auth");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_crypto_1 = require("node:crypto");
+const KEYCHAIN_SERVICES = [
+    "Claude Code-credentials",
+    "claude-code-credentials",
+    "claude.ai",
+];
+function getKeychainServiceName() {
+    const configDir = process.env.CLAUDE_CONFIG_DIR;
+    if (configDir) {
+        const hash = (0, node_crypto_1.createHash)("sha256")
+            .update(configDir)
+            .digest("hex")
+            .substring(0, 8);
+        return `Claude Code-credentials-${hash}`;
+    }
+    return "Claude Code-credentials";
+}
+function extractFromKeychain() {
+    const store = (0, auth_1.getCredentialStore)();
+    const user = (0, node_os_1.userInfo)().username;
+    for (const svc of KEYCHAIN_SERVICES) {
+        const data = store.get(svc, user);
+        if (data) {
+            try {
+                const creds = JSON.parse(data);
+                if (creds.claudeAiOauth?.accessToken)
+                    return creds;
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return null;
+}
+function compareFreshness(first, second) {
+    const firstExpiry = first?.claudeAiOauth?.expiresAt;
+    const secondExpiry = second?.claudeAiOauth?.expiresAt;
+    if (!first?.claudeAiOauth?.accessToken && !second?.claudeAiOauth?.accessToken) {
+        return "unknown";
+    }
+    if (!first?.claudeAiOauth?.accessToken)
+        return "second";
+    if (!second?.claudeAiOauth?.accessToken)
+        return "first";
+    if (firstExpiry === undefined && secondExpiry === undefined)
+        return "equal";
+    if (firstExpiry === undefined)
+        return "second";
+    if (secondExpiry === undefined)
+        return "first";
+    if (firstExpiry > secondExpiry)
+        return "first";
+    if (secondExpiry > firstExpiry)
+        return "second";
+    return "equal";
+}
+exports.claude = {
+    name: "claude",
+    command: "claude",
+    configDir: (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude"),
+    isInstalledOnHost: () => {
+        try {
+            (0, node_child_process_1.execSync)("claude --version", { stdio: "pipe" });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    dockerArgs: ({ workspace, home, containerOnly }) => {
+        const claudeDir = (0, node_path_1.join)(home, ".claude");
+        const configCopy = (0, node_path_1.join)(workspace, ".vibebox", "claude.json");
+        const config = (0, node_path_1.join)(home, ".claude.json");
+        // Container-only mode: minimal mounts, container manages its own ~/.claude
+        if (containerOnly) {
+            return [
+                // Mount config copy (not the original, to prevent corruption)
+                "-v", `${configCopy}:${config}`,
+            ];
+        }
+        // Host mode: mount ~/.claude with selective hiding for isolation
+        const projectFolder = workspace.replace(/[\\/]/g, "-");
+        const emptyDir = (0, node_path_1.join)(workspace, ".vibebox", "empty");
+        const emptyFile = (0, node_path_1.join)(workspace, ".vibebox", "empty-file");
+        const credentials = (0, node_path_1.join)(claudeDir, ".credentials.json");
+        return [
+            // Mount ~/.claude with selective hiding
+            "-v", `${claudeDir}:${claudeDir}`,
+            "-v", `${emptyDir}:${claudeDir}/projects`,
+            "-v", `${emptyFile}:${claudeDir}/history.jsonl`,
+            "-v", `${claudeDir}/projects/${projectFolder}:${claudeDir}/projects/${projectFolder}`,
+            // Mount credentials
+            "-v", `${credentials}:${credentials}`,
+            // Mount config copy (not the original, to prevent corruption)
+            "-v", `${configCopy}:${config}`,
+        ];
+    },
+    install: (containerName) => {
+        console.log("Installing Claude Code...");
+        (0, node_child_process_1.spawnSync)("docker", ["exec", containerName, "bash", "-c", "curl -fsSL https://claude.ai/install.sh | sh"], { stdio: "inherit" });
+    },
+    setup: ({ workspace, containerOnly }) => {
+        const home = (0, node_os_1.homedir)();
+        const claudeDir = (0, node_path_1.join)(home, ".claude");
+        const credFile = (0, node_path_1.join)(claudeDir, ".credentials.json");
+        // Ensure directories exist
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(workspace, ".vibebox", "empty"), { recursive: true });
+        // Create empty overlay file
+        const emptyFile = (0, node_path_1.join)(workspace, ".vibebox", "empty-file");
+        if (!(0, node_fs_1.existsSync)(emptyFile))
+            (0, node_fs_1.writeFileSync)(emptyFile, "");
+        // Create minimal config to skip onboarding and trust prompts
+        const configCopy = (0, node_path_1.join)(workspace, ".vibebox", "claude.json");
+        const minimalConfig = {
+            hasCompletedOnboarding: true,
+            projects: {
+                [workspace]: {
+                    allowedTools: [],
+                    hasTrustDialogAccepted: true,
+                    hasCompletedProjectOnboarding: true,
+                },
+            },
+        };
+        (0, node_fs_1.writeFileSync)(configCopy, JSON.stringify(minimalConfig, null, 2));
+        // Container-only mode: skip credential sync, agent will prompt for login
+        if (containerOnly)
+            return;
+        // Host mode: sync credentials from system credential store
+        (0, node_fs_1.mkdirSync)(claudeDir, { recursive: true });
+        // Clean up if credentials file is a directory (Claude bug)
+        if ((0, node_fs_1.existsSync)(credFile) && (0, node_fs_1.lstatSync)(credFile).isDirectory()) {
+            (0, node_fs_1.rmSync)(credFile, { recursive: true, force: true });
+        }
+        // Sync credentials from system credential store (macOS only for now)
+        if (process.platform === "darwin") {
+            const keychainCreds = extractFromKeychain();
+            const fileCreds = (0, auth_1.readCredentialsFile)(credFile);
+            const freshness = compareFreshness(keychainCreds, fileCreds);
+            if (freshness === "first" || freshness === "equal") {
+                if (!keychainCreds)
+                    throw new Error("No credentials. Run: claude auth login");
+                (0, node_fs_1.writeFileSync)(credFile, JSON.stringify(keychainCreds, null, 2));
+            }
+            else if (freshness === "second" && fileCreds) {
+                // File is fresher, sync back to keychain
+                const store = (0, auth_1.getCredentialStore)();
+                store.set(getKeychainServiceName(), (0, node_os_1.userInfo)().username, JSON.stringify(fileCreds));
+            }
+            else if (!keychainCreds && !fileCreds) {
+                throw new Error("No credentials. Run: claude auth login");
+            }
+        }
+        else {
+            if (!(0, node_fs_1.existsSync)(credFile)) {
+                throw new Error("No credentials. Run: claude auth login");
+            }
+        }
+    },
+    versionCommand: "claude --version",
+};
+function getCredentialPaths() {
+    return {
+        credentials: (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude", ".credentials.json"),
+        config: (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude.json"),
+    };
+}

package/dist/agents/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agents = void 0;
+exports.detectInstalledAgents = detectInstalledAgents;
+exports.isAgentInstalled = isAgentInstalled;
+const node_child_process_1 = require("node:child_process");
+const claude_1 = require("./claude");
+exports.agents = {
+    claude: claude_1.claude,
+};
+function detectInstalledAgents() {
+    return Object.entries(exports.agents)
+        .filter(([_, agent]) => agent.isInstalledOnHost())
+        .map(([name]) => name);
+}
+function isAgentInstalled(containerName, agent) {
+    try {
+        (0, node_child_process_1.execSync)(`docker exec ${containerName} which ${agent.command}`, { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/agents/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/auth.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCredentialPaths = void 0;
+exports.ensureCredentials = ensureCredentials;
+// Re-export from Claude agent for backward compatibility
+const claude_1 = require("./agents/claude");
+Object.defineProperty(exports, "getCredentialPaths", { enumerable: true, get: function () { return claude_1.getCredentialPaths; } });
+function ensureCredentials() {
+    // Delegates to Claude agent's setup with current working directory
+    claude_1.claude.setup?.({ workspace: process.cwd() });
+}