@tyevco/homelab-lxc-agent 1.9.1 → 1.9.3

package/dist/lxc.js

@@ -114,6 +114,7 @@ async function getContainerList(endpoint) {
                 isManagedByHomelab: true,
             };
         }
+        console.log(`[lxc] Found ${Object.keys(result).length} container(s)`);
     }
     catch (e) {
         console.error("[lxc] Failed to get container list:", e instanceof Error ? e.message : e);
@@ -125,6 +126,7 @@ async function getContainer(name, endpoint) {
     if (!/^[a-z0-9_.-]+$/.test(name)) {
         throw new Error("Invalid LXC container name");
     }
+    console.log(`[lxc] Getting info for: ${name}`);
     const res = await (0, promisify_child_process_1.spawn)("lxc-info", ["-n", name], { encoding: "utf-8" });
     if (!res.stdout) {
         throw new Error("LXC container not found");
@@ -166,20 +168,25 @@ async function getContainer(name, endpoint) {
 }
 exports.getContainer = getContainer;
 async function startContainer(socket, endpoint, name) {
+    console.log(`[lxc] Starting container: ${name}`);
     const code = await terminal_1.AgentTerminal.exec(socket, getLxcTerminalName(endpoint, name), "lxc-start", ["-n", name], LXC_PATH);
     if (code !== 0) {
         throw new Error("Failed to start LXC container");
     }
+    console.log(`[lxc] Started: ${name}`);
 }
 exports.startContainer = startContainer;
 async function stopContainer(socket, endpoint, name) {
+    console.log(`[lxc] Stopping container: ${name}`);
     const code = await terminal_1.AgentTerminal.exec(socket, getLxcTerminalName(endpoint, name), "lxc-stop", ["-n", name], LXC_PATH);
     if (code !== 0) {
         throw new Error("Failed to stop LXC container");
     }
+    console.log(`[lxc] Stopped: ${name}`);
 }
 exports.stopContainer = stopContainer;
 async function restartContainer(socket, endpoint, name) {
+    console.log(`[lxc] Restarting container: ${name}`);
     const termName = getLxcTerminalName(endpoint, name);
     const stopCode = await terminal_1.AgentTerminal.exec(socket, termName, "lxc-stop", ["-n", name], LXC_PATH);
     if (stopCode !== 0) {
@@ -189,39 +196,49 @@ async function restartContainer(socket, endpoint, name) {
     if (startCode !== 0) {
         throw new Error("Failed to start LXC container for restart");
     }
+    console.log(`[lxc] Restarted: ${name}`);
 }
 exports.restartContainer = restartContainer;
 async function freezeContainer(socket, endpoint, name) {
+    console.log(`[lxc] Freezing container: ${name}`);
     const code = await terminal_1.AgentTerminal.exec(socket, getLxcTerminalName(endpoint, name), "lxc-freeze", ["-n", name], LXC_PATH);
     if (code !== 0) {
         throw new Error("Failed to freeze LXC container");
     }
+    console.log(`[lxc] Frozen: ${name}`);
 }
 exports.freezeContainer = freezeContainer;
 async function unfreezeContainer(socket, endpoint, name) {
+    console.log(`[lxc] Unfreezing container: ${name}`);
     const code = await terminal_1.AgentTerminal.exec(socket, getLxcTerminalName(endpoint, name), "lxc-unfreeze", ["-n", name], LXC_PATH);
     if (code !== 0) {
         throw new Error("Failed to unfreeze LXC container");
     }
+    console.log(`[lxc] Unfrozen: ${name}`);
 }
 exports.unfreezeContainer = unfreezeContainer;
 async function deleteContainer(socket, endpoint, name, status) {
+    console.log(`[lxc] Deleting container: ${name}`);
     const termName = getLxcTerminalName(endpoint, name);
     if (status === exports.RUNNING || status === exports.FROZEN) {
+        console.log(`[lxc] Stopping ${name} before delete`);
         await terminal_1.AgentTerminal.exec(socket, termName, "lxc-stop", ["-n", name], LXC_PATH);
     }
     const code = await terminal_1.AgentTerminal.exec(socket, termName, "lxc-destroy", ["-n", name], LXC_PATH);
     if (code !== 0) {
         throw new Error("Failed to destroy LXC container");
     }
+    console.log(`[lxc] Deleted: ${name}`);
 }
 exports.deleteContainer = deleteContainer;
 async function saveConfig(name, config) {
+    console.log(`[lxc] Saving config for: ${name}`);
     const containerPath = path.join(LXC_PATH, name);
     if (!fs.existsSync(containerPath)) {
         throw new Error("LXC container not found");
     }
     await fs.promises.writeFile(path.join(containerPath, "config"), config);
+    console.log(`[lxc] Config saved for: ${name}`);
 }
 exports.saveConfig = saveConfig;
 async function createContainer(socket, endpoint, name, dist, release, arch) {
@@ -237,10 +254,12 @@ async function createContainer(socket, endpoint, name, dist, release, arch) {
     if (!/^[a-zA-Z0-9_]+$/.test(arch)) {
         throw new Error("Invalid architecture");
     }
+    console.log(`[lxc] Creating container: ${name} (${dist} ${release} ${arch})`);
     const code = await terminal_1.AgentTerminal.exec(socket, getLxcTerminalName(endpoint, name), "lxc-create", ["-n", name, "-t", "download", "--", "--dist", dist, "--release", release, "--arch", arch], LXC_PATH);
     if (code !== 0) {
         throw new Error("Failed to create LXC container");
     }
+    console.log(`[lxc] Created: ${name}`);
 }
 exports.createContainer = createContainer;
 async function getDistributions() {

package/dist/server.js

@@ -54,19 +54,32 @@ function createAgentServer(config) {
     const httpServer = (0, http_1.createServer)();
     const io = new socket_io_1.Server(httpServer);
     let capabilities = { lxcAvailable: false };
-    const authenticatedSockets = new Set();
+    // Maps socket → endpoint so rescan can push per-connection data
+    const authenticatedSockets = new Map();
     const emitInfo = (socket) => {
         socket.emit("info", {
             version: config.version,
             ...capabilities,
         });
     };
+    const pushContainerList = async (socket, endpoint) => {
+        const list = await lxc.getContainerList(endpoint);
+        console.log(`[lxc] Pushing container list to main server (${Object.keys(list).length} container(s))`);
+        socket.emit("agent", "lxcContainerList", { ok: true,
+            lxcContainerList: list,
+            endpoint });
+    };
     const rescan = async () => {
         console.log("[agent] Scanning capabilities...");
         capabilities = await detectCapabilities();
-        for (const socket of authenticatedSockets) {
+        for (const [socket] of authenticatedSockets) {
             emitInfo(socket);
         }
+        if (capabilities.lxcAvailable) {
+            for (const [socket, endpoint] of authenticatedSockets) {
+                pushContainerList(socket, endpoint).catch((e) => console.error("[lxc] Failed to push container list during rescan:", e instanceof Error ? e.message : e));
+            }
+        }
     };
     // Initial scan, then periodic rescan
     rescan().then(() => {
@@ -97,9 +110,13 @@ function createAgentServer(config) {
             const { username, password } = data;
             if (username === config.username && password === config.password) {
                 loggedIn = true;
-                authenticatedSockets.add(socket);
+                authenticatedSockets.set(socket, endpoint);
                 console.log(`[agent] Authenticated as ${username}`);
                 cb?.({ ok: true });
+                // Immediately push the container list so the main server doesn't have to ask
+                if (capabilities.lxcAvailable) {
+                    pushContainerList(socket, endpoint).catch((e) => console.error("[lxc] Failed to push initial container list:", e instanceof Error ? e.message : e));
+                }
             }
             else {
                 console.warn(`[agent] Login failed for ${username}`);
@@ -120,6 +137,7 @@ function createAgentServer(config) {
             if (targetEndpoint !== endpoint && targetEndpoint !== "") {
                 return;
             }
+            console.log(`[agent] Event: ${eventName}`);
             await dispatch(socket, endpoint, eventName, args);
         });
     });
@@ -136,8 +154,11 @@ async function dispatch(socket, endpoint, eventName, args) {
         ...(msg ? { msg,
             msgi18n: true } : {}),
         ...extra });
-    const fail = (e) => callback?.({ ok: false,
-        msg: e instanceof Error ? e.message : String(e) });
+    const fail = (e) => {
+        console.error(`[agent] Error handling ${eventName}:`, e instanceof Error ? e.message : String(e));
+        callback?.({ ok: false,
+            msg: e instanceof Error ? e.message : String(e) });
+    };
     const pushList = async () => {
         const list = await lxc.getContainerList(endpoint);
         socket.emit("agent", "lxcContainerList", { ok: true,

package/dist/terminal.js

@@ -74,6 +74,7 @@ class AgentTerminal {
         if (this._ptyProcess) {
             return;
         }
+        console.log(`[terminal] Starting: ${this.name} (${this.file} ${this.args.join(" ")})`);
         try {
             this._ptyProcess = pty.spawn(this.file, this.args, {
                 name: this.name,
@@ -89,6 +90,7 @@ class AgentTerminal {
                 this.socket.emit("agent", "terminalWrite", this.name, data);
             });
             this._ptyProcess.onExit(({ exitCode }) => {
+                console.log(`[terminal] Exited: ${this.name} (code ${exitCode})`);
                 this.socket.emit("agent", "terminalExit", this.name, exitCode);
                 AgentTerminal.terminalMap.delete(this.name);
                 this.exitCallback?.(exitCode);
@@ -97,6 +99,7 @@ class AgentTerminal {
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
             const exitCode = Number(msg.split(" ").pop()) || 1;
+            console.error(`[terminal] Failed to start: ${this.name}: ${msg}`);
             this.socket.emit("agent", "terminalExit", this.name, exitCode);
             AgentTerminal.terminalMap.delete(this.name);
             this.exitCallback?.(exitCode);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyevco/homelab-lxc-agent",
-  "version": "1.9.1",
+  "version": "1.9.3",
   "description": "Lightweight LXC agent for Homelab",
   "bin": {
     "homelab-lxc-agent": "bin/homelab-lxc-agent.js"