@rubytech/create-maxy 1.0.0

package/dist/index.js

@@ -0,0 +1,428 @@
+#!/usr/bin/env node
+import { execFileSync, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync, cpSync, readFileSync, rmSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { randomBytes } from "node:crypto";
+const INSTALL_DIR = resolve(process.env.HOME ?? "/root", "maxy");
+const PAYLOAD_DIR = resolve(import.meta.dirname, "../payload");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function log(step, total, message) {
+    console.log(`[${step}/${total}] ${message}`);
+}
+function shell(command, args, options) {
+    const cmd = options?.sudo ? "sudo" : command;
+    const cmdArgs = options?.sudo ? [command, ...args] : args;
+    const result = spawnSync(cmd, cmdArgs, {
+        stdio: "inherit",
+        timeout: 300_000,
+        cwd: options?.cwd,
+    });
+    if (result.status !== 0) {
+        throw new Error(`Command failed (exit ${result.status}): ${cmd} ${cmdArgs.join(" ")}`);
+    }
+}
+function commandExists(cmd) {
+    try {
+        execFileSync("which", [cmd], { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function nodeVersion() {
+    try {
+        const v = execFileSync("node", ["-v"], { encoding: "utf-8" }).trim();
+        return parseInt(v.replace("v", "").split(".")[0], 10);
+    }
+    catch {
+        return 0;
+    }
+}
+function isLinux() {
+    return process.platform === "linux";
+}
+function isArm64() {
+    return process.arch === "arm64";
+}
+// ---------------------------------------------------------------------------
+// Installation steps
+// ---------------------------------------------------------------------------
+const TOTAL = "10";
+function installSystemDeps() {
+    log("1", TOTAL, "System dependencies and network...");
+    if (!isLinux()) {
+        console.log("  Skipping Linux-specific setup (not on Linux).");
+        return;
+    }
+    shell("apt-get", ["update", "-qq"], { sudo: true });
+    shell("apt-get", ["install", "-y", "-qq", "curl", "git", "unzip", "avahi-daemon", "avahi-utils"], { sudo: true });
+    shell("apt-get", ["install", "-y", "-qq", "tigervnc-standalone-server", "python3-websockify", "novnc", "xdg-utils"], { sudo: true });
+    // Reinstall chromium cleanly — resolves conflicts between chromium and chromium-browser packages
+    shell("apt-get", ["install", "--reinstall", "-y", "-qq", "chromium"], { sudo: true });
+    // Set hostname to 'maxy'
+    try {
+        const hostname = execFileSync("hostname", [], { encoding: "utf-8" }).trim();
+        if (hostname !== "maxy") {
+            console.log(`  Setting hostname to 'maxy' (was '${hostname}')...`);
+            shell("hostnamectl", ["set-hostname", "maxy"], { sudo: true });
+            shell("sed", ["-i", `s/127\\.0\\.1\\.1.*$/127.0.1.1\\tmaxy/`, "/etc/hosts"], { sudo: true });
+        }
+    }
+    catch { /* not critical */ }
+    // Avahi service file for LAN discovery
+    const avahiService = `<?xml version="1.0" standalone='no'?>
+<!DOCTYPE service-group SYSTEM "avahi-service.dtd">
+<service-group>
+  <name replace-wildcards="yes">Maxy on %h</name>
+  <service>
+    <type>_http._tcp</type>
+    <port>19200</port>
+    <txt-record>role=maxy</txt-record>
+  </service>
+</service-group>`;
+    try {
+        writeFileSync("/tmp/maxy-avahi.service", avahiService);
+        shell("cp", ["/tmp/maxy-avahi.service", "/etc/avahi/services/maxy.service"], { sudo: true });
+        shell("systemctl", ["enable", "avahi-daemon"], { sudo: true });
+        shell("systemctl", ["restart", "avahi-daemon"], { sudo: true });
+    }
+    catch { /* not critical */ }
+    console.log("  Device reachable at http://maxy.local:19200");
+}
+function installNodejs() {
+    if (commandExists("node") && nodeVersion() >= 20) {
+        log("2", TOTAL, `Node.js v${nodeVersion()} already installed.`);
+        return;
+    }
+    log("2", TOTAL, "Installing Node.js...");
+    if (!isLinux()) {
+        throw new Error("Automatic Node.js installation is only supported on Linux. Install Node.js 20+ manually.");
+    }
+    spawnSync("bash", ["-c", "curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -"], { stdio: "inherit" });
+    shell("apt-get", ["install", "-y", "-qq", "nodejs"], { sudo: true });
+}
+function installClaudeCode() {
+    log("3", TOTAL, "Installing Claude Code (latest)...");
+    shell("npm", ["install", "-g", "@anthropic-ai/claude-code@latest"], { sudo: true });
+}
+function resetNeo4jWithFreshPassword() {
+    const password = randomBytes(24).toString("base64url");
+    console.log("  Resetting Neo4j with fresh password...");
+    spawnSync("sudo", ["systemctl", "stop", "neo4j"], { stdio: "inherit" });
+    // Wipe data so set-initial-password works again
+    spawnSync("sudo", ["rm", "-rf",
+        "/var/lib/neo4j/data/databases",
+        "/var/lib/neo4j/data/transactions",
+        "/var/lib/neo4j/data/dbms",
+    ], { stdio: "inherit" });
+    shell("neo4j-admin", ["dbms", "set-initial-password", password], { sudo: true });
+    shell("systemctl", ["start", "neo4j"], { sudo: true });
+    // Wait for Neo4j to start accepting connections
+    console.log("  Waiting for Neo4j to start...");
+    for (let i = 0; i < 15; i++) {
+        const check = spawnSync("cypher-shell", [
+            "-u", "neo4j", "-p", password,
+            "-a", "bolt://localhost:7687",
+            "RETURN 1",
+        ], { stdio: "pipe", timeout: 5000 });
+        if (check.status === 0)
+            break;
+        spawnSync("sleep", ["2"]);
+    }
+    return password;
+}
+/** Check Neo4j has a working password. Called AFTER deploy so config is in place. */
+function ensureNeo4jPassword() {
+    const passwordFile = join(INSTALL_DIR, "platform/config/.neo4j-password");
+    const configDir = resolve(INSTALL_DIR, "platform/config");
+    mkdirSync(configDir, { recursive: true });
+    // If password file exists, verify it works
+    if (existsSync(passwordFile)) {
+        const existingPassword = readFileSync(passwordFile, "utf-8").trim();
+        const check = spawnSync("cypher-shell", [
+            "-u", "neo4j", "-p", existingPassword,
+            "-a", "bolt://localhost:7687",
+            "RETURN 1",
+        ], { stdio: "pipe", timeout: 10000 });
+        if (check.status === 0) {
+            return; // Password works, data intact
+        }
+        console.log("  Stored password doesn't match Neo4j. Setting new password...");
+    }
+    else {
+        console.log("  No Neo4j password file found. Setting initial password...");
+    }
+    // Check if Neo4j has data (databases exist = not a fresh install)
+    const hasData = existsSync("/var/lib/neo4j/data/databases/neo4j");
+    if (hasData) {
+        // NEVER wipe an existing database. The user's data is more important
+        // than our ability to set a password. Fail with a clear message.
+        throw new Error("Neo4j has existing data but the password is unknown. " +
+            "Cannot reset without losing data. " +
+            "Set the password manually: cypher-shell -u neo4j -p <old-password> " +
+            "\"ALTER CURRENT USER SET PASSWORD FROM '<old>' TO '<new>'\" " +
+            "then write the new password to " + join(INSTALL_DIR, "platform/config/.neo4j-password"));
+    }
+    // Fresh install — safe to set initial password
+    const password = resetNeo4jWithFreshPassword();
+    writeFileSync(passwordFile, password, { mode: 0o600 });
+    // Also save to persistent location (~/.maxy/)
+    const persistDir = resolve(process.env.HOME ?? "/root", ".maxy");
+    mkdirSync(persistDir, { recursive: true });
+    writeFileSync(join(persistDir, ".neo4j-password"), password, { mode: 0o600 });
+}
+function installNeo4j() {
+    if (commandExists("neo4j")) {
+        log("4", TOTAL, "Neo4j already installed.");
+        return;
+    }
+    log("4", TOTAL, "Installing Neo4j Community Edition 5...");
+    if (!isLinux()) {
+        throw new Error("Automatic Neo4j installation is only supported on Linux. Install Neo4j 5.11+ manually.");
+    }
+    console.log("  Installing Java 17...");
+    shell("apt-get", ["install", "-y", "-qq", "openjdk-17-jre-headless"], { sudo: true });
+    spawnSync("bash", ["-c", "curl -fsSL https://debian.neo4j.com/neotechnology.gpg.key | sudo gpg --yes --dearmor -o /usr/share/keyrings/neo4j.gpg 2>/dev/null"], { stdio: "inherit" });
+    spawnSync("bash", ["-c", 'echo "deb [signed-by=/usr/share/keyrings/neo4j.gpg] https://debian.neo4j.com stable 5" | sudo tee /etc/apt/sources.list.d/neo4j.list'], { stdio: "inherit" });
+    shell("apt-get", ["update", "-qq"], { sudo: true });
+    shell("apt-get", ["install", "-y", "-qq", "neo4j"], { sudo: true });
+    shell("sed", ["-i", "s/#server.default_listen_address=0.0.0.0/server.default_listen_address=127.0.0.1/", "/etc/neo4j/neo4j.conf"], { sudo: true });
+    // Generate strong random password — stored in persistent location (~/.maxy/)
+    const password = randomBytes(24).toString("base64url");
+    const persistDir = resolve(process.env.HOME ?? "/root", ".maxy");
+    mkdirSync(persistDir, { recursive: true });
+    writeFileSync(join(persistDir, ".neo4j-password"), password, { mode: 0o600 });
+    // Also write to install dir (will be there when deploy step runs)
+    const configDir = resolve(INSTALL_DIR, "platform/config");
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(join(configDir, ".neo4j-password"), password, { mode: 0o600 });
+    shell("neo4j-admin", ["dbms", "set-initial-password", password], { sudo: true });
+    shell("systemctl", ["enable", "neo4j"], { sudo: true });
+    shell("systemctl", ["start", "neo4j"], { sudo: true });
+    console.log("  Neo4j started. Password stored securely.");
+}
+function installOllama() {
+    if (!commandExists("ollama")) {
+        log("5", TOTAL, "Installing Ollama...");
+        spawnSync("bash", ["-c", "curl -fsSL https://ollama.ai/install.sh | sh"], { stdio: "inherit" });
+    }
+    else {
+        log("5", TOTAL, "Ollama already installed.");
+    }
+    console.log("  Pulling nomic-embed-text model (~300MB)...");
+    shell("ollama", ["pull", "nomic-embed-text"]);
+}
+function installCloudflared() {
+    if (commandExists("cloudflared")) {
+        log("6", TOTAL, "Cloudflared already installed.");
+        return;
+    }
+    log("6", TOTAL, "Installing cloudflared...");
+    if (!isLinux()) {
+        console.log("  Skipping — install manually for your platform.");
+        return;
+    }
+    const arch = isArm64() ? "arm64" : "amd64";
+    const debPath = "/tmp/cloudflared.deb";
+    spawnSync("curl", ["-fsSL", `https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-${arch}.deb`, "-o", debPath], { stdio: "inherit" });
+    shell("dpkg", ["-i", debPath], { sudo: true });
+    spawnSync("rm", ["-f", debPath]);
+}
+function deployPayload() {
+    log("7", TOTAL, "Deploying Maxy...");
+    if (!existsSync(PAYLOAD_DIR)) {
+        throw new Error(`Payload not found at ${PAYLOAD_DIR}. Package may be corrupted.`);
+    }
+    // Persistent config lives at ~/.maxy/ — survives rm -rf ~/maxy
+    const persistentDir = resolve(process.env.HOME ?? "/root", ".maxy");
+    const persistentPasswordFile = join(persistentDir, ".neo4j-password");
+    const persistentAccountsDir = join(persistentDir, "accounts");
+    // Migrate: if password is in old location, move to persistent
+    const oldPasswordFile = join(INSTALL_DIR, "platform/config/.neo4j-password");
+    if (existsSync(oldPasswordFile) && !existsSync(persistentPasswordFile)) {
+        mkdirSync(persistentDir, { recursive: true });
+        cpSync(oldPasswordFile, persistentPasswordFile);
+    }
+    const oldAccountsDir = join(INSTALL_DIR, "platform/config/accounts");
+    if (existsSync(oldAccountsDir) && !existsSync(persistentAccountsDir)) {
+        mkdirSync(persistentDir, { recursive: true });
+        cpSync(oldAccountsDir, persistentAccountsDir, { recursive: true });
+    }
+    // Wipe old platform/maxy to prevent stale files
+    for (const dir of ["platform", "maxy", "docs", ".claude"]) {
+        const target = join(INSTALL_DIR, dir);
+        if (existsSync(target)) {
+            rmSync(target, { recursive: true });
+        }
+    }
+    mkdirSync(INSTALL_DIR, { recursive: true });
+    // Deploy payload
+    cpSync(PAYLOAD_DIR, INSTALL_DIR, {
+        recursive: true,
+        force: true,
+    });
+    // Link persistent config into install directory
+    const configDir = join(INSTALL_DIR, "platform/config");
+    mkdirSync(configDir, { recursive: true });
+    if (existsSync(persistentPasswordFile)) {
+        cpSync(persistentPasswordFile, join(configDir, ".neo4j-password"));
+        console.log("  Restored Neo4j password.");
+    }
+    if (existsSync(persistentAccountsDir)) {
+        cpSync(persistentAccountsDir, join(configDir, "accounts"), { recursive: true, force: true });
+        console.log("  Restored account data.");
+    }
+    console.log(`  Deployed to ${INSTALL_DIR}`);
+}
+function buildPlatform() {
+    log("8", TOTAL, "Installing dependencies and building...");
+    // Stop the running service before rebuilding (upgrade path)
+    spawnSync("systemctl", ["--user", "stop", "maxy"], { stdio: "pipe" });
+    shell("npm", ["install", "--quiet"], { cwd: join(INSTALL_DIR, "platform") });
+    shell("npm", ["run", "build"], { cwd: join(INSTALL_DIR, "platform") });
+    shell("npm", ["install", "--quiet"], { cwd: join(INSTALL_DIR, "maxy") });
+    shell("npm", ["run", "build"], { cwd: join(INSTALL_DIR, "maxy") });
+}
+function setupVncViewer() {
+    if (!isLinux())
+        return;
+    const novncSrc = "/usr/share/novnc";
+    const novncDest = join(INSTALL_DIR, "maxy/public/novnc");
+    if (!existsSync(join(novncSrc, "core"))) {
+        console.log("  noVNC not found — skipping VNC viewer setup.");
+        return;
+    }
+    console.log("  Installing VNC viewer...");
+    // Copy core/ and vendor/ (pako compression library) — both required by rfb.js
+    cpSync(join(novncSrc, "core"), join(novncDest, "core"), { recursive: true, force: true });
+    const vendorSrc = join(novncSrc, "vendor");
+    if (existsSync(vendorSrc)) {
+        cpSync(vendorSrc, join(novncDest, "vendor"), { recursive: true, force: true });
+    }
+    // Custom viewer: no toolbar, scales to fit, auto-connects
+    const html = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0">
+  <title>Connect Claude</title>
+  <style>
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+    html, body { width: 100%; height: 100%; background: #111; overflow: hidden; }
+    #screen { position: relative; width: 100%; height: 100%; }
+  </style>
+</head>
+<body>
+  <div id="screen"></div>
+  <script type="module">
+    import RFB from '/novnc/core/rfb.js';
+    const p = new URLSearchParams(location.search);
+    const host = p.get('host') || location.hostname;
+    const port = p.get('port') || '6080';
+    const screen = document.getElementById('screen');
+    const rfb = new RFB(screen, 'ws://' + host + ':' + port + '/websockify');
+    rfb.scaleViewport = true;
+    rfb.clipViewport = true;
+    rfb.resizeSession = false;
+    new ResizeObserver(() => { rfb._updateSize(); }).observe(screen);
+    rfb.addEventListener('disconnect', () => { setTimeout(() => location.reload(), 2000); });
+  </script>
+</body>
+</html>`;
+    writeFileSync(join(INSTALL_DIR, "maxy/public/vnc-viewer.html"), html);
+    console.log("  VNC viewer ready at /vnc-viewer.html");
+}
+function setupAccount() {
+    log("9", TOTAL, "Setting up...");
+    const seedScript = join(INSTALL_DIR, "platform/scripts/seed-neo4j.sh");
+    if (existsSync(seedScript)) {
+        shell("bash", [seedScript], { cwd: INSTALL_DIR });
+    }
+}
+function installService() {
+    log("10", TOTAL, "Starting Maxy...");
+    if (!isLinux()) {
+        console.log("  Skipping systemd service (not Linux). Start manually with:");
+        console.log(`  cd ${INSTALL_DIR}/maxy && npm start`);
+        return;
+    }
+    // Create systemd user service
+    const serviceDir = resolve(process.env.HOME ?? "/root", ".config/systemd/user");
+    mkdirSync(serviceDir, { recursive: true });
+    const persistDir = resolve(process.env.HOME ?? "/root", ".maxy");
+    const serviceFile = `[Unit]
+Description=Maxy AI Assistant
+After=neo4j.service
+
+[Service]
+Type=simple
+WorkingDirectory=${INSTALL_DIR}/maxy
+ExecStart=/usr/bin/npm start
+Restart=on-failure
+RestartSec=5
+Environment=NODE_ENV=production
+EnvironmentFile=-${persistDir}/.env
+
+[Install]
+WantedBy=default.target
+`;
+    writeFileSync(join(serviceDir, "maxy.service"), serviceFile);
+    // Enable lingering so user services run without login
+    try {
+        const user = execFileSync("whoami", [], { encoding: "utf-8" }).trim();
+        spawnSync("sudo", ["loginctl", "enable-linger", user], { stdio: "inherit" });
+    }
+    catch { /* not critical */ }
+    // Reload and (re)start
+    spawnSync("systemctl", ["--user", "daemon-reload"], { stdio: "inherit" });
+    spawnSync("systemctl", ["--user", "enable", "maxy"], { stdio: "inherit" });
+    spawnSync("systemctl", ["--user", "restart", "maxy"], { stdio: "inherit" });
+    // Wait for the server to come up
+    console.log("  Waiting for web server...");
+    for (let i = 0; i < 20; i++) {
+        try {
+            execFileSync("curl", ["-sf", "http://localhost:19200", "-o", "/dev/null"], { timeout: 3000 });
+            return; // Server is up
+        }
+        catch {
+            spawnSync("sleep", ["2"]);
+        }
+    }
+    console.log("  Server may still be starting. Check http://maxy.local:19200 in a moment.");
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+const PKG_VERSION = JSON.parse(readFileSync(resolve(import.meta.dirname, "../package.json"), "utf-8")).version;
+console.log("================================================================");
+console.log(`  Maxy — AI for Productive People.  (create-maxy v${PKG_VERSION})`);
+console.log("================================================================");
+console.log("");
+try {
+    installSystemDeps();
+    installNodejs();
+    installClaudeCode();
+    installNeo4j();
+    installOllama();
+    installCloudflared();
+    deployPayload(); // Must happen before ensureNeo4jPassword — restores config backup
+    ensureNeo4jPassword(); // Now config/.neo4j-password is available if it existed before
+    buildPlatform();
+    setupVncViewer();
+    setupAccount();
+    installService();
+    console.log("");
+    console.log("================================================================");
+    console.log("");
+    console.log("  Open in your browser: http://maxy.local:19200");
+    console.log("");
+    console.log("================================================================");
+}
+catch (err) {
+    console.error("");
+    console.error(`Setup failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@rubytech/create-maxy",
+  "version": "1.0.0",
+  "description": "Install Maxy — your personal AI assistant",
+  "bin": {
+    "create-maxy": "./dist/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "bundle": "node scripts/bundle.js",
+    "prepublishOnly": "npm run build && npm run bundle"
+  },
+  "files": [
+    "dist",
+    "payload"
+  ],
+  "keywords": [
+    "maxy",
+    "ai",
+    "assistant",
+    "raspberry-pi",
+    "claude"
+  ],
+  "author": "Rubytech LLC",
+  "license": "UNLICENSED",
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "@types/node": "^22.0.0"
+  }
+}

package/payload/maxy/.env.example

@@ -0,0 +1,12 @@
+# Admin access PIN (required — admin chat is disabled without this)
+ADMIN_PIN=
+
+# Telegram public bot (optional — get token from @BotFather)
+TELEGRAM_PUBLIC_BOT_TOKEN=
+
+# Neo4j and Ollama run locally with defaults set during installation.
+# Override only if you've changed the defaults:
+# NEO4J_URI=bolt://localhost:7687
+# NEO4J_USER=neo4j
+# NEO4J_PASSWORD is read from platform/config/.neo4j-password (generated during setup)
+# OLLAMA_URL=http://localhost:11434