@babylen/legion 0.1.1 → 0.1.3

package/dist/index.js

@@ -23,11 +23,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/index.ts
+var import_child_process = require("child_process");
+
+// package.json
+var version = "0.1.3";
+
 // src/index.ts
 var import_socket = require("socket.io-client");
-var os3 = __toESM(require("os"));
-var import_fs2 = require("fs");
-var import_path4 = require("path");
+var os4 = __toESM(require("os"));
 
 // src/core/config.ts
 var import_os = __toESM(require("os"));
@@ -44,6 +48,14 @@ var ConfigSchema = import_zod.z.object({
 var HOME_DIR = import_os.default.homedir();
 var CONFIG_DIR = import_path.default.join(HOME_DIR, ".tanuki");
 var CONFIG_FILE = import_path.default.join(CONFIG_DIR, "config.json");
+async function ensureConfigDir() {
+  try {
+    await import_promises.default.access(CONFIG_DIR);
+  } catch {
+    await import_promises.default.mkdir(CONFIG_DIR, { recursive: true });
+  }
+  return CONFIG_FILE;
+}
 async function loadConfig() {
   try {
     const content = await import_promises.default.readFile(CONFIG_FILE, "utf-8");
@@ -53,6 +65,14 @@ async function loadConfig() {
     return null;
   }
 }
+async function saveConfig(config2) {
+  await ensureConfigDir();
+  await import_promises.default.writeFile(CONFIG_FILE, JSON.stringify(config2, null, 2), "utf-8");
+  try {
+    await import_promises.default.chmod(CONFIG_FILE, 384);
+  } catch {
+  }
+}
 async function getConfig() {
   const fileConfig = await loadConfig();
   const id = fileConfig?.id || process.env.LEGION_TOKEN_ID || void 0;
@@ -72,6 +92,18 @@ async function getConfig() {
   }
   return config2;
 }
+async function updateConfig(updates) {
+  const currentConfig = await loadConfig();
+  if (!currentConfig) {
+    throw new Error("Cannot update config: config file does not exist");
+  }
+  const updatedConfig = {
+    ...currentConfig,
+    ...updates
+  };
+  ConfigSchema.parse(updatedConfig);
+  await saveConfig(updatedConfig);
+}
 
 // src/util/log.ts
 var import_path3 = __toESM(require("path"));
@@ -260,104 +292,320 @@ var Log;
   Log2.create = create;
 })(Log || (Log = {}));
 
+// src/util/fingerprint.ts
+var os3 = __toESM(require("os"));
+var cachedFingerprint = null;
+async function getSystemFingerprint() {
+  if (cachedFingerprint) return cachedFingerprint;
+  const hostname3 = os3.hostname();
+  const platform3 = os3.platform();
+  const arch2 = os3.arch();
+  const cpuModel = os3.cpus()[0]?.model || "unknown";
+  const interfaces = os3.networkInterfaces();
+  let macAddress = "";
+  for (const iface of Object.values(interfaces || {})) {
+    for (const addr of iface || []) {
+      if (!addr.internal && addr.mac && addr.mac !== "00:00:00:00:00:00") {
+        macAddress = addr.mac;
+        break;
+      }
+    }
+    if (macAddress) break;
+  }
+  const data2 = JSON.stringify({ hostname: hostname3, platform: platform3, arch: arch2, cpuModel, macAddress });
+  const encoder = new TextEncoder();
+  const dataBuffer = encoder.encode(data2);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", dataBuffer);
+  cachedFingerprint = Buffer.from(hashBuffer).toString("hex");
+  return cachedFingerprint;
+}
+
 // src/index.ts
-var packageJsonPath = (0, import_path4.join)(__dirname, "..", "package.json");
-var version = "0.0.0";
-try {
-  const packageJson = JSON.parse((0, import_fs2.readFileSync)(packageJsonPath, "utf-8"));
-  version = packageJson.version;
-} catch {
-  version = "0.0.0";
+if (process.argv.includes("--version") || process.argv.includes("-v")) {
+  console.log(version);
+  process.exit(0);
 }
-async function main() {
-  if (process.argv.includes("--version") || process.argv.includes("-v")) {
-    console.log(version);
-    process.exit(0);
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const parsed = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--token" && args[i + 1]) {
+      parsed.token = args[i + 1];
+      i++;
+    } else if (args[i] === "auth" && args[i + 1] === "--token" && args[i + 2]) {
+      parsed.command = "auth";
+      parsed.token = args[i + 2];
+      i += 2;
+    } else if (args[i] === "login") {
+      parsed.command = "login";
+    } else if (args[i] === "--version" || args[i] === "-v") {
+      parsed.version = true;
+    }
   }
-  try {
-    const log2 = Log.create({ service: "legion" });
-    await Global.init();
-    log2.info(`\u{1F6E1}\uFE0F  Legion v${version} starting...`);
-    const config2 = await getConfig();
-    log2.info("\u{1F517} Connecting to server", { serverUrl: config2.serverUrl });
-    const socket = (0, import_socket.io)(config2.serverUrl, {
-      auth: {
-        id: config2.id,
-        // Token ID for faster lookup (optional)
-        token: config2.token,
-        // Secret token for authentication
-        type: "legion"
-      },
-      transports: ["websocket"],
-      reconnection: true,
-      reconnectionDelay: 1e3,
-      reconnectionDelayMax: 5e3,
-      reconnectionAttempts: Infinity
+  return parsed;
+}
+async function handleDeviceLogin(log, serverUrl = "https://tanuki.sabw.ru") {
+  const codeEndpoint = `${serverUrl}/api/v1/legion/device/code`;
+  const tokenEndpoint = `${serverUrl}/api/v1/legion/device/token`;
+  const codeResponse = await fetch(codeEndpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" }
+  });
+  if (!codeResponse.ok) {
+    throw new Error(`Failed to get device code: ${codeResponse.statusText}`);
+  }
+  const { code, activation_url } = await codeResponse.json();
+  console.log(`\u{1F449} Go to: ${activation_url || "https://tanuki.sabw.ru/activate"}`);
+  console.log(`\u{1F511} Enter code: ${code}`);
+  const pollInterval = 3e3;
+  const maxAttempts = 60;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    const tokenResponse = await fetch(tokenEndpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ code })
+    });
+    if (tokenResponse.ok) {
+      const { token, token_id } = await tokenResponse.json();
+      const existingConfig = await loadConfig();
+      await saveConfig({
+        token,
+        id: token_id,
+        serverUrl: existingConfig?.serverUrl || "wss://tanuki.sabw.ru"
+      });
+      log.info("\u2705 Device activated successfully");
+      return;
+    } else if (tokenResponse.status === 202) {
+      continue;
+    } else {
+      throw new Error(`Failed to get token: ${tokenResponse.statusText}`);
+    }
+  }
+  throw new Error("Device activation timed out");
+}
+function checkForUpdates() {
+  setTimeout(async () => {
+    try {
+      const packageName = "@babylen/legion";
+      const command = `npm view ${packageName} version`;
+      const timeout = 3e3;
+      const latestVersion = (0, import_child_process.execSync)(command, {
+        encoding: "utf-8",
+        timeout,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+      if (latestVersion !== version) {
+        console.warn(`
+\u26A0\uFE0F  Update available: ${version} \u2192 ${latestVersion}`);
+        console.warn(`   Run: npm install -g ${packageName}@latest
+`);
+      }
+    } catch (error) {
+    }
+  }, 100);
+}
+async function enterHibernationMode(log, configFile, onConfigChanged) {
+  log.warn("\u26D4 Auth failed. Entering hibernation mode. Waiting for config update...");
+  const fs4 = await import("fs");
+  return new Promise((resolve) => {
+    const watchHandle = fs4.watch(configFile, async (eventType) => {
+      if (eventType === "change") {
+        log.info("\u{1F4DD} Config file changed. Attempting reconnection...");
+        try {
+          await new Promise((resolve2) => setTimeout(resolve2, 100));
+          await onConfigChanged();
+          watchHandle.close();
+          resolve();
+        } catch (error) {
+          log.error("\u274C Reconnection failed", { error });
+        }
+      }
     });
-    socket.on("connect", () => {
-      log2.info("\u2705 Connected to server", { socketId: socket.id });
-      const handshakeData = {
-        hostname: os3.hostname(),
-        platform: os3.platform(),
-        release: os3.release(),
-        cwd: process.cwd()
-      };
-      socket.emit("legion:handshake", handshakeData);
-      log2.debug("\u{1F4E4} Sent handshake", handshakeData);
+  });
+}
+function createSocket(config2) {
+  return (0, import_socket.io)(config2.serverUrl, {
+    auth: {
+      id: config2.id,
+      // Token ID for faster lookup (optional)
+      token: config2.token,
+      // Secret token for authentication
+      type: "legion"
+    },
+    transports: ["websocket"],
+    reconnection: true,
+    reconnectionDelay: 1e3,
+    reconnectionDelayMax: 5e3,
+    reconnectionAttempts: Infinity
+  });
+}
+function setupSocketHandlers(socket, log, fingerprint, version2, onTokenRotation, onReconnect) {
+  socket.on("connect", () => {
+    log.info("\u2705 Connected to server", { socketId: socket.id });
+    const handshakeData = {
+      fingerprint,
+      version: version2,
+      hostname: os4.hostname(),
+      platform: os4.platform(),
+      release: os4.release(),
+      cwd: process.cwd()
+    };
+    socket.emit("legion:handshake", handshakeData);
+    log.debug("\u{1F4E4} Sent handshake", handshakeData);
+  });
+  socket.on("connect_error", (err) => {
+    log.error("\u274C Connection error", {
+      message: err.message,
+      type: err.type
     });
-    socket.on("connect_error", (err) => {
-      log2.error("\u274C Connection error", {
-        message: err.message,
-        type: err.type
+    if (err.message.includes("auth") || err.message.includes("token")) {
+      log.error("\u{1F510} Authentication failed. Please check your token.");
+      log.error("\u{1F4A1} Re-authenticate by updating ~/.tanuki/config.json or LEGION_TOKEN env var");
+      enterHibernationMode(log, CONFIG_FILE, onReconnect).catch((error) => {
+        log.error("\u274C Hibernation mode failed", { error });
+        process.exit(1);
+      });
+    }
+  });
+  socket.on("disconnect", (reason) => {
+    log.warn("\u26A0\uFE0F  Disconnected from server", { reason });
+    if (reason === "io server disconnect") {
+      log.error("\u{1F6AB} Server disconnected this client. Please check your token.");
+      enterHibernationMode(log, CONFIG_FILE, onReconnect).catch((error) => {
+        log.error("\u274C Hibernation mode failed", { error });
+        process.exit(1);
       });
-      if (err.message.includes("auth") || err.message.includes("token")) {
-        log2.error("\u{1F510} Authentication failed. Please check your token.");
-        log2.error("\u{1F4A1} Re-authenticate by updating ~/.tanuki/config.json or LEGION_TOKEN env var");
+    }
+  });
+  socket.on("legion:update_token", async (data2) => {
+    try {
+      log.info("\u{1F504} Received permanent credentials. Persisting...");
+      await updateConfig({
+        token: data2.secret,
+        // secret -> token
+        id: data2.token_id
+        // token_id -> id
+      });
+      log.info("\u2705 Config updated successfully. Reconnecting with new token...");
+      await onTokenRotation();
+    } catch (error) {
+      log.error("\u274C Failed to update config", { error });
+    }
+  });
+  socket.on("server:ping", (data2) => {
+    log.debug("\u{1F4E9} Ping from server", data2);
+    socket.emit("legion:pong", { ts: Date.now() });
+  });
+  socket.on("reconnect", (attemptNumber) => {
+    log.info("\u{1F504} Reconnected to server", { attempt: attemptNumber });
+  });
+  socket.on("reconnect_attempt", (attemptNumber) => {
+    log.debug("\u{1F504} Reconnection attempt", { attempt: attemptNumber });
+  });
+  socket.on("reconnect_error", (error) => {
+    log.error("\u{1F504} Reconnection error", { message: error.message });
+  });
+  socket.on("reconnect_failed", () => {
+    log.error("\u{1F504} Reconnection failed after all attempts");
+    process.exit(1);
+  });
+}
+async function main() {
+  let log = null;
+  const safeLog = {
+    info: (message, extra) => {
+      if (log) log.info(message, extra);
+      else console.log(message, extra);
+    },
+    error: (message, extra) => {
+      if (log) log.error(message, extra);
+      else console.error(message, extra);
+    },
+    warn: (message, extra) => {
+      if (log) log.warn(message, extra);
+      else console.warn(message, extra);
+    },
+    debug: (message, extra) => {
+      if (log) log.debug(message, extra);
+    }
+  };
+  try {
+    log = Log.create({ service: "legion" });
+    const args = parseArgs();
+    if (args.command === "login") {
+      try {
+        await handleDeviceLogin(log);
+        process.exit(0);
+      } catch (error) {
+        log.error("\u274C Device login failed", { error });
         process.exit(1);
       }
-    });
-    socket.on("disconnect", (reason) => {
-      log2.warn("\u26A0\uFE0F  Disconnected from server", { reason });
-      if (reason === "io server disconnect") {
-        log2.error("\u{1F6AB} Server disconnected this client. Please check your token.");
+    }
+    if (args.token) {
+      log.info("\u{1F511} Saving token from command line...");
+      try {
+        const defaultServerUrl = process.env.TANUKI_SERVER_URL || "wss://tanuki.sabw.ru";
+        const existingConfig = await loadConfig();
+        await saveConfig({
+          token: args.token,
+          serverUrl: existingConfig?.serverUrl || defaultServerUrl,
+          ...existingConfig?.id ? { id: existingConfig.id } : {}
+        });
+        log.info("\u2705 Token saved successfully");
+      } catch (error) {
+        log.error("\u274C Failed to save token", { error });
         process.exit(1);
       }
-    });
-    socket.on("server:ping", (data2) => {
-      log2.debug("\u{1F4E9} Ping from server", data2);
-      socket.emit("legion:pong", { ts: Date.now() });
-    });
-    socket.on("reconnect", (attemptNumber) => {
-      log2.info("\u{1F504} Reconnected to server", { attempt: attemptNumber });
-    });
-    socket.on("reconnect_attempt", (attemptNumber) => {
-      log2.debug("\u{1F504} Reconnection attempt", { attempt: attemptNumber });
-    });
-    socket.on("reconnect_error", (error) => {
-      log2.error("\u{1F504} Reconnection error", { message: error.message });
-    });
-    socket.on("reconnect_failed", () => {
-      log2.error("\u{1F504} Reconnection failed after all attempts");
-      process.exit(1);
-    });
+    }
+    checkForUpdates();
+    await Global.init();
+    const fingerprint = await getSystemFingerprint();
+    log.info(`\u{1F6E1}\uFE0F  Legion v${version} starting...`);
+    let config2 = await getConfig();
+    log.info("\u{1F517} Connecting to server", { serverUrl: config2.serverUrl });
+    let currentSocket;
+    let isTokenRotation = false;
+    let handleTokenRotation;
+    let handleReconnect;
+    handleReconnect = async () => {
+      if (currentSocket) {
+        currentSocket.io.opts.reconnection = false;
+        currentSocket.disconnect();
+        currentSocket.removeAllListeners();
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      }
+      const newConfig = await getConfig();
+      log.info("\u{1F504} Reconnecting...");
+      currentSocket = createSocket(newConfig);
+      setupSocketHandlers(currentSocket, log, fingerprint, version, handleTokenRotation, handleReconnect);
+      config2 = newConfig;
+    };
+    handleTokenRotation = async () => {
+      isTokenRotation = true;
+      await handleReconnect();
+      isTokenRotation = false;
+    };
+    currentSocket = createSocket(config2);
+    setupSocketHandlers(currentSocket, log, fingerprint, version, handleTokenRotation, handleReconnect);
     process.stdin.resume();
     const shutdown = () => {
-      log2.info("\u{1F6D1} Shutting down...");
-      socket.disconnect();
+      log.info("\u{1F6D1} Shutting down...");
+      currentSocket.disconnect();
       process.exit(0);
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
     process.on("unhandledRejection", (reason) => {
-      log2.error("Unhandled rejection", { reason });
+      log.error("Unhandled rejection", { reason });
     });
     process.on("uncaughtException", (error) => {
-      log2.error("Uncaught exception", { error: error.message, stack: error.stack });
+      log.error("Uncaught exception", { error: error.message, stack: error.stack });
       shutdown();
     });
   } catch (error) {
     if (error instanceof Error) {
-      log.error("Failed to start Legion", {
+      safeLog.error("Failed to start Legion", {
         message: error.message,
         stack: error.stack
       });
@@ -366,7 +614,7 @@ async function main() {
       console.error("   - Set LEGION_TOKEN environment variable, or");
       console.error("   - Create ~/.tanuki/config.json with your token");
     } else {
-      log.error("Failed to start Legion", { error });
+      safeLog.error("Failed to start Legion", { error });
       console.error("\n\u274C Unknown error occurred");
     }
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babylen/legion",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Legion agent for connecting devices to Tanuki Cloud",
   "main": "./dist/index.js",
   "keywords": [