vexp-cli 2.0.11 → 2.0.13

package/dist/autostart.js

@@ -0,0 +1,375 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { execFileSync, spawnSync } from "child_process";
+const LABEL = "io.vexp.serve";
+const BEGIN_MARKER = "# vexp-autostart-begin";
+const END_MARKER = "# vexp-autostart-end";
+const INSTALL_MARKER_FILE = "autostart-installed";
+function homedir() {
+    return os.homedir();
+}
+function installMarkerPath() {
+    return path.join(homedir(), ".vexp", INSTALL_MARKER_FILE);
+}
+/** Resolve the launcher the OS should execute. Prefers the `vexp` bin in
+ *  PATH; falls back to node+dist/cli.cjs if invoked from a dev checkout. */
+function resolveLauncher() {
+    if (process.env.VEXP_AUTOSTART_LAUNCHER) {
+        const parts = process.env.VEXP_AUTOSTART_LAUNCHER.split(" ");
+        return { bin: parts[0], args: [...parts.slice(1), "serve"] };
+    }
+    // `vexp` launches the commander CLI with argv-dispatch; argv[2] = "serve".
+    const hint = process.execPath && process.argv[1]
+        ? { bin: process.execPath, args: [process.argv[1], "serve"] }
+        : { bin: "vexp", args: ["serve"] };
+    // On Windows, prefer the global shim when available so the user's PATH
+    // can be used without baking in an absolute node path.
+    if (process.platform === "win32")
+        return { bin: "vexp.cmd", args: ["serve"] };
+    // Everywhere else default to node + resolved script path for reliability.
+    return hint;
+}
+// ───── macOS LaunchAgent ────────────────────────────────────────────────
+function macPlistPath() {
+    return path.join(homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+}
+function macPlist(launcher, logPath) {
+    const args = [launcher.bin, ...launcher.args]
+        .map((a) => `    <string>${a.replace(/&/g, "&amp;").replace(/</g, "&lt;")}</string>`)
+        .join("\n");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${logPath}</string>
+  <key>StandardErrorPath</key><string>${logPath}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key><string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin</string>
+  </dict>
+</dict>
+</plist>
+`;
+}
+function installLaunchd() {
+    const launcher = resolveLauncher();
+    const logPath = path.join(homedir(), ".vexp", "autostart.log");
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    const plistPath = macPlistPath();
+    fs.mkdirSync(path.dirname(plistPath), { recursive: true });
+    fs.writeFileSync(plistPath, macPlist(launcher, logPath));
+    // Reload if already loaded.
+    try {
+        execFileSync("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}/${LABEL}`], { stdio: "ignore" });
+    }
+    catch { /* not loaded */ }
+    try {
+        execFileSync("launchctl", ["bootstrap", `gui/${process.getuid?.() ?? 501}`, plistPath], { stdio: "ignore" });
+    }
+    catch {
+        // Fallback for older macOS
+        try {
+            execFileSync("launchctl", ["load", "-w", plistPath], { stdio: "ignore" });
+        }
+        catch { /* best effort */ }
+    }
+    return { installed: true, mechanism: "launchd", path: plistPath };
+}
+function uninstallLaunchd() {
+    const plistPath = macPlistPath();
+    try {
+        execFileSync("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}/${LABEL}`], { stdio: "ignore" });
+    }
+    catch { /* not loaded */ }
+    try {
+        execFileSync("launchctl", ["unload", plistPath], { stdio: "ignore" });
+    }
+    catch { /* ok */ }
+    if (fs.existsSync(plistPath))
+        fs.unlinkSync(plistPath);
+    return true;
+}
+// ───── Linux: systemd --user > XDG autostart > shell profile ─────────────
+function systemdUnitPath() {
+    return path.join(homedir(), ".config", "systemd", "user", "vexp.service");
+}
+function hasSystemdUser() {
+    const r = spawnSync("systemctl", ["--user", "is-system-running"], { encoding: "utf-8" });
+    // `is-system-running` returns various states; exit 0, 1, or 3 all mean the
+    // user bus is reachable. "offline" / "Failed to connect" → fallback.
+    if (r.error)
+        return false;
+    if ((r.stdout || "").includes("Failed to connect"))
+        return false;
+    if ((r.stderr || "").includes("Failed to connect"))
+        return false;
+    return r.status !== null && (r.status === 0 || r.status === 1 || r.status === 3);
+}
+function installSystemdUser() {
+    const launcher = resolveLauncher();
+    const unit = systemdUnitPath();
+    fs.mkdirSync(path.dirname(unit), { recursive: true });
+    const cmd = [launcher.bin, ...launcher.args].map((a) => /\s/.test(a) ? `"${a}"` : a).join(" ");
+    fs.writeFileSync(unit, `[Unit]
+Description=vexp login supervisor
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${cmd}
+Restart=on-failure
+RestartSec=5
+StandardOutput=append:${path.join(homedir(), ".vexp", "autostart.log")}
+StandardError=append:${path.join(homedir(), ".vexp", "autostart.log")}
+
+[Install]
+WantedBy=default.target
+`);
+    try {
+        execFileSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+    }
+    catch { /* best effort */ }
+    try {
+        execFileSync("systemctl", ["--user", "enable", "--now", "vexp.service"], { stdio: "ignore" });
+    }
+    catch { /* best effort */ }
+    return { installed: true, mechanism: "systemd-user", path: unit };
+}
+function uninstallSystemdUser() {
+    try {
+        execFileSync("systemctl", ["--user", "disable", "--now", "vexp.service"], { stdio: "ignore" });
+    }
+    catch { /* ok */ }
+    const unit = systemdUnitPath();
+    if (fs.existsSync(unit))
+        fs.unlinkSync(unit);
+    try {
+        execFileSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+    }
+    catch { /* ok */ }
+    return true;
+}
+function xdgAutostartPath() {
+    return path.join(homedir(), ".config", "autostart", "vexp.desktop");
+}
+function hasXdgDesktop() {
+    // If $XDG_CURRENT_DESKTOP or $DESKTOP_SESSION is set, a graphical session
+    // manager will honor ~/.config/autostart.
+    return !!(process.env.XDG_CURRENT_DESKTOP || process.env.DESKTOP_SESSION);
+}
+function installXdgAutostart() {
+    const launcher = resolveLauncher();
+    const file = xdgAutostartPath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const cmd = [launcher.bin, ...launcher.args].map((a) => /\s/.test(a) ? `"${a}"` : a).join(" ");
+    fs.writeFileSync(file, `[Desktop Entry]
+Type=Application
+Name=vexp
+Comment=vexp login supervisor
+Exec=${cmd}
+X-GNOME-Autostart-enabled=true
+Terminal=false
+Hidden=false
+`);
+    return { installed: true, mechanism: "xdg-autostart", path: file };
+}
+function uninstallXdgAutostart() {
+    const file = xdgAutostartPath();
+    if (fs.existsSync(file))
+        fs.unlinkSync(file);
+    return true;
+}
+function shellProfilePaths() {
+    return [".bashrc", ".zshrc", ".profile"].map((f) => path.join(homedir(), f));
+}
+function installShellProfile() {
+    const launcher = resolveLauncher();
+    const cmd = [launcher.bin, ...launcher.args].map((a) => /\s/.test(a) ? `"${a}"` : a).join(" ");
+    const block = `${BEGIN_MARKER}
+pgrep -f "vexp serve" >/dev/null 2>&1 || (nohup ${cmd} >> "${path.join(homedir(), ".vexp", "autostart.log")}" 2>&1 &)
+${END_MARKER}
+`;
+    let wrote = "";
+    for (const p of shellProfilePaths()) {
+        let content = "";
+        try {
+            content = fs.readFileSync(p, "utf-8");
+        }
+        catch { /* new file */ }
+        if (content.includes(BEGIN_MARKER)) {
+            // Replace existing block
+            content = content.replace(new RegExp(`${BEGIN_MARKER}[\\s\\S]*?${END_MARKER}\\n?`), block);
+        }
+        else {
+            content = content + (content.endsWith("\n") || content === "" ? "" : "\n") + block;
+        }
+        try {
+            fs.writeFileSync(p, content);
+            wrote = p;
+        }
+        catch { /* permission denied, try next */ }
+    }
+    return { installed: !!wrote, mechanism: "shell-profile", path: wrote || undefined };
+}
+function uninstallShellProfile() {
+    let changed = false;
+    for (const p of shellProfilePaths()) {
+        let content = "";
+        try {
+            content = fs.readFileSync(p, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        if (!content.includes(BEGIN_MARKER))
+            continue;
+        const cleaned = content.replace(new RegExp(`${BEGIN_MARKER}[\\s\\S]*?${END_MARKER}\\n?`), "");
+        try {
+            fs.writeFileSync(p, cleaned);
+            changed = true;
+        }
+        catch { /* ok */ }
+    }
+    return changed;
+}
+// ───── Windows: Startup folder VBScript ──────────────────────────────────
+function windowsStartupPath() {
+    const appData = process.env.APPDATA || path.join(homedir(), "AppData", "Roaming");
+    return path.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "vexp-serve.vbs");
+}
+function installWindowsStartup() {
+    const launcher = resolveLauncher();
+    const p = windowsStartupPath();
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    const logPath = path.join(homedir(), ".vexp", "autostart.log");
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    const cmdParts = [launcher.bin, ...launcher.args]
+        .map((a) => `""${a.replace(/"/g, '\\"')}""`)
+        .join(" ");
+    const script = `' vexp autostart — launches \`vexp serve\` hidden at login.\n` +
+        `Set sh = CreateObject("WScript.Shell")\n` +
+        `sh.Run "cmd /c " & ${JSON.stringify(cmdParts)} & " >> ""${logPath.replace(/\\/g, "\\\\")}"" 2>&1", 0, False\n`;
+    fs.writeFileSync(p, script);
+    return { installed: true, mechanism: "windows-startup", path: p };
+}
+function uninstallWindowsStartup() {
+    const p = windowsStartupPath();
+    if (fs.existsSync(p))
+        fs.unlinkSync(p);
+    return true;
+}
+// ───── Public API ────────────────────────────────────────────────────────
+/**
+ * Install per-user autostart so `vexp serve` runs at login without admin.
+ * Chooses the best available mechanism per OS; returns what was written.
+ */
+export function installAutostart() {
+    if (process.platform === "darwin")
+        return installLaunchd();
+    if (process.platform === "win32")
+        return installWindowsStartup();
+    if (process.platform === "linux") {
+        if (hasSystemdUser())
+            return installSystemdUser();
+        if (hasXdgDesktop())
+            return installXdgAutostart();
+        return installShellProfile();
+    }
+    return { installed: false, mechanism: "none" };
+}
+/** Remove every autostart variant, including legacy ones from prior versions. */
+export function uninstallAutostart() {
+    if (process.platform === "darwin") {
+        uninstallLaunchd();
+        return;
+    }
+    if (process.platform === "win32") {
+        uninstallWindowsStartup();
+        return;
+    }
+    if (process.platform === "linux") {
+        uninstallSystemdUser();
+        uninstallXdgAutostart();
+        uninstallShellProfile();
+    }
+    try {
+        fs.unlinkSync(installMarkerPath());
+    }
+    catch { /* absent */ }
+}
+/**
+ * Idempotent install guard used by `vexp` preAction / REPL / plugin activate.
+ *
+ * First invocation after an upgrade installs autostart + writes a marker.
+ * Subsequent invocations (including `vexp setup`, any subcommand, multiple
+ * VS Code windows) short-circuit on the marker → zero extra work, zero
+ * process duplication.
+ *
+ * Respects `VEXP_NO_AUTOSTART_INSTALL=1` as opt-out.
+ */
+export function installAutostartIfNeeded() {
+    if (process.env.VEXP_NO_AUTOSTART_INSTALL === "1")
+        return;
+    const marker = installMarkerPath();
+    if (fs.existsSync(marker))
+        return;
+    // Previous install by a different path (e.g. user ran older `vexp setup`
+    // that called installAutostart directly). Record the marker so we don't
+    // probe the filesystem again on every invocation.
+    if (autostartStatus().installed) {
+        try {
+            fs.mkdirSync(path.dirname(marker), { recursive: true });
+            fs.writeFileSync(marker, new Date().toISOString());
+        }
+        catch { /* non-fatal */ }
+        return;
+    }
+    try {
+        const r = installAutostart();
+        if (r.installed) {
+            try {
+                fs.mkdirSync(path.dirname(marker), { recursive: true });
+                fs.writeFileSync(marker, new Date().toISOString());
+            }
+            catch { /* non-fatal */ }
+        }
+    }
+    catch { /* non-fatal — opt-in best effort */ }
+}
+export function autostartStatus() {
+    if (process.platform === "darwin") {
+        const p = macPlistPath();
+        if (fs.existsSync(p))
+            return { installed: true, mechanism: "launchd", path: p };
+        return { installed: false, mechanism: "none" };
+    }
+    if (process.platform === "win32") {
+        const p = windowsStartupPath();
+        if (fs.existsSync(p))
+            return { installed: true, mechanism: "windows-startup", path: p };
+        return { installed: false, mechanism: "none" };
+    }
+    if (process.platform === "linux") {
+        if (fs.existsSync(systemdUnitPath()))
+            return { installed: true, mechanism: "systemd-user", path: systemdUnitPath() };
+        if (fs.existsSync(xdgAutostartPath()))
+            return { installed: true, mechanism: "xdg-autostart", path: xdgAutostartPath() };
+        for (const p of shellProfilePaths()) {
+            try {
+                if (fs.readFileSync(p, "utf-8").includes(BEGIN_MARKER)) {
+                    return { installed: true, mechanism: "shell-profile", path: p };
+                }
+            }
+            catch { /* missing */ }
+        }
+    }
+    return { installed: false, mechanism: "none" };
+}

package/dist/binary.js

@@ -88,6 +88,69 @@ function ensureDevSonames(releaseDir) {
             // Non-fatal: user will get a clearer error from the binary itself.
         }
     }
+    // Copy ggml backend plugins (cpu/metal/blas) and default.metallib from
+    // the build output into releaseDir, so `ggml_backend_load_all()` can
+    // dlopen them. CI packaging does this for production bundles; in dev
+    // the files live in `target/release/build/.../out/bin/` and need a
+    // flat-copy here. Metal additionally needs default.metallib as a
+    // runtime resource.
+    copyDevBackendPlugins(releaseDir, ext);
+}
+/** Flat-copy backend .dylib/.so and Metal shader resources next to the
+ *  binary so the runtime dynamic loader finds them. No-op if the files
+ *  are already present. */
+function copyDevBackendPlugins(releaseDir, ext) {
+    const buildDir = path.join(releaseDir, "build");
+    if (!fs.existsSync(buildDir))
+        return;
+    const backendNames = ["libggml-cpu", "libggml-blas"];
+    if (process.platform === "darwin")
+        backendNames.push("libggml-metal");
+    const scanRoots = [];
+    try {
+        for (const entry of fs.readdirSync(buildDir)) {
+            if (!entry.startsWith("llama-cpp-sys-"))
+                continue;
+            for (const sub of ["bin", "lib", "lib64"]) {
+                const d = path.join(buildDir, entry, "out", sub);
+                if (fs.existsSync(d))
+                    scanRoots.push(d);
+            }
+        }
+    }
+    catch {
+        return;
+    }
+    const tryCopy = (src, dest) => {
+        if (fs.existsSync(dest))
+            return;
+        try {
+            fs.copyFileSync(src, dest);
+        }
+        catch { /* non-fatal */ }
+    };
+    for (const root of scanRoots) {
+        let entries = [];
+        try {
+            entries = fs.readdirSync(root);
+        }
+        catch {
+            continue;
+        }
+        for (const f of entries) {
+            // Backend plugin: libggml-cpu.dylib / libggml-metal.dylib / etc.
+            for (const name of backendNames) {
+                if (f === `${name}${ext}`) {
+                    tryCopy(path.join(root, f), path.join(releaseDir, f));
+                }
+            }
+            // Metal shader library — exact filename, both platforms' build
+            // layouts may place it in bin/ or lib/.
+            if (process.platform === "darwin" && f === "default.metallib") {
+                tryCopy(path.join(root, f), path.join(releaseDir, "default.metallib"));
+            }
+        }
+    }
 }
 function isSymlink(p) {
     try {