anyterm 0.1.0

package/dist/chunk-S66ZF6IR.js

@@ -0,0 +1,296 @@
+#!/usr/bin/env node
+
+// src/config.ts
+import * as os from "os";
+import Conf from "conf";
+import machineId from "node-machine-id";
+
+// src/secure-store.ts
+import * as fs from "fs";
+var SERVICE = "anyterm";
+function hardenConfigPermissions() {
+  try {
+    if (process.platform !== "win32") {
+      fs.chmodSync(config.path, 384);
+    }
+  } catch {
+  }
+}
+var keytar = null;
+async function getKeytar() {
+  if (keytar) return keytar;
+  try {
+    const mod = await import("keytar");
+    keytar = mod.default;
+    return keytar;
+  } catch {
+    return null;
+  }
+}
+async function getSecret(key, serverUrl) {
+  const keychainKey = serverUrl ? `${key}:${serverUrl}` : key;
+  const kt = await getKeytar();
+  if (kt) {
+    try {
+      const value = await kt.getPassword(SERVICE, keychainKey);
+      if (value) return value;
+    } catch {
+    }
+  }
+  if (serverUrl) {
+    const store = config.store;
+    const servers = store["servers"];
+    const val2 = servers?.[serverUrl]?.[key];
+    return typeof val2 === "string" ? val2 : null;
+  }
+  const stored = config.store;
+  const val = stored[key];
+  return typeof val === "string" ? val : null;
+}
+async function setSecret(key, value, serverUrl) {
+  const keychainKey = serverUrl ? `${key}:${serverUrl}` : key;
+  const kt = await getKeytar();
+  if (kt) {
+    try {
+      await kt.setPassword(SERVICE, keychainKey, value);
+      if (serverUrl) {
+        const store = config.store;
+        const servers = store["servers"];
+        if (servers?.[serverUrl]?.[key]) {
+          delete servers[serverUrl][key];
+          config.set(
+            "servers",
+            servers
+          );
+        }
+      } else {
+        const stored = config.store;
+        if (key in stored) {
+          delete stored[key];
+          config.store = stored;
+        }
+      }
+      return;
+    } catch {
+    }
+  }
+  console.warn(
+    "\x1B[33mWarning: OS keychain unavailable. Credentials stored in plaintext config file.\x1B[0m"
+  );
+  if (serverUrl) {
+    const store = config.store;
+    const servers = store["servers"] ?? {};
+    if (!servers[serverUrl]) servers[serverUrl] = {};
+    servers[serverUrl][key] = value;
+    config.set(
+      "servers",
+      servers
+    );
+  } else {
+    config.set(
+      key,
+      value
+    );
+  }
+  hardenConfigPermissions();
+}
+async function deleteSecret(key, serverUrl) {
+  const keychainKey = serverUrl ? `${key}:${serverUrl}` : key;
+  const kt = await getKeytar();
+  if (kt) {
+    try {
+      await kt.deletePassword(SERVICE, keychainKey);
+    } catch {
+    }
+  }
+  if (serverUrl) {
+    const store = config.store;
+    const servers = store["servers"];
+    if (servers?.[serverUrl]?.[key]) {
+      delete servers[serverUrl][key];
+      config.set(
+        "servers",
+        servers
+      );
+    }
+  } else {
+    const stored = config.store;
+    if (key in stored) {
+      delete stored[key];
+      config.store = stored;
+    }
+  }
+}
+
+// src/config.ts
+var DEFAULT_SERVER_URL = "https://anyterm.dev";
+var CONFIG_VERSION = 2;
+var config = new Conf({
+  projectName: "anyterm"
+});
+function normalizeServerUrl(url) {
+  const parsed = new URL(url);
+  return `${parsed.protocol}//${parsed.host.toLowerCase()}${parsed.pathname.replace(/\/+$/, "")}`;
+}
+function getActiveServer() {
+  return config.get("activeServer");
+}
+function setActiveServer(serverUrl) {
+  config.set(
+    "activeServer",
+    serverUrl
+  );
+}
+function getServerConfig(serverUrl) {
+  const store = config.store;
+  return store.servers?.[serverUrl];
+}
+function setServerConfig(serverUrl, data) {
+  const store = config.store;
+  const servers = store.servers ?? {};
+  servers[serverUrl] = { ...servers[serverUrl], ...data };
+  config.set("servers", servers);
+}
+function deleteServerConfig(serverUrl) {
+  const store = config.store;
+  if (store.servers?.[serverUrl]) {
+    delete store.servers[serverUrl];
+    config.set(
+      "servers",
+      store.servers
+    );
+  }
+}
+async function getConfig() {
+  const { migrateConfigIfNeeded: migrateConfigIfNeeded2 } = await import("./migrate-F4NHB5VX.js");
+  await migrateConfigIfNeeded2();
+  const activeServer = config.get("activeServer");
+  if (!activeServer) {
+    console.error("Not logged in. Run: anyterm login");
+    process.exit(1);
+  }
+  const serverConf = getServerConfig(activeServer);
+  if (!serverConf?.userId) {
+    console.error("Not logged in. Run: anyterm login");
+    process.exit(1);
+  }
+  const authToken = await getSecret("authToken", activeServer);
+  if (!authToken) {
+    console.error("Not logged in. Run: anyterm login");
+    process.exit(1);
+  }
+  const wsUrl = serverConf.wsUrl || activeServer.replace(/^http/, "ws");
+  const masterKey = await getSecret("masterKey", activeServer);
+  return {
+    serverUrl: activeServer,
+    wsUrl,
+    authToken,
+    userId: serverConf.userId,
+    publicKey: serverConf.publicKey,
+    encryptedPrivateKey: serverConf.encryptedPrivateKey,
+    keySalt: serverConf.keySalt,
+    masterKey
+  };
+}
+function getMachineId() {
+  return machineId.machineIdSync().slice(0, 8);
+}
+function getMachineName() {
+  return config.get("machineName") || os.hostname();
+}
+function setMachineName(name) {
+  config.set(
+    "machineName",
+    name
+  );
+}
+
+// src/migrate.ts
+var migrated = false;
+async function migrateConfigIfNeeded() {
+  if (migrated) return;
+  migrated = true;
+  const store = config.store;
+  const version = store["configVersion"];
+  if (version && version >= CONFIG_VERSION) return;
+  const legacyServerUrl = store["serverUrl"];
+  if (!legacyServerUrl) {
+    config.set(
+      "configVersion",
+      CONFIG_VERSION
+    );
+    return;
+  }
+  const serverConfig = {};
+  const perServerKeys = [
+    "wsUrl",
+    "userId",
+    "publicKey",
+    "encryptedPrivateKey",
+    "keySalt"
+  ];
+  for (const k of perServerKeys) {
+    if (k in store) {
+      serverConfig[k] = store[k];
+    }
+  }
+  for (const secretKey of ["authToken", "masterKey"]) {
+    const value = await getSecret(secretKey);
+    if (value) {
+      await setSecret(secretKey, value, legacyServerUrl);
+      await deleteSecret(secretKey);
+    }
+  }
+  const servers = store["servers"] ?? {};
+  servers[legacyServerUrl] = serverConfig;
+  config.set(
+    "servers",
+    servers
+  );
+  config.set(
+    "activeServer",
+    legacyServerUrl
+  );
+  config.set(
+    "configVersion",
+    CONFIG_VERSION
+  );
+  const legacyKeys = [
+    "serverUrl",
+    "wsUrl",
+    "userId",
+    "publicKey",
+    "encryptedPrivateKey",
+    "keySalt",
+    "authToken",
+    "masterKey"
+  ];
+  for (const k of legacyKeys) {
+    if (k in store) {
+      delete store[k];
+    }
+  }
+  config.store = store;
+}
+function _resetMigrationState() {
+  migrated = false;
+}
+
+export {
+  getSecret,
+  setSecret,
+  deleteSecret,
+  migrateConfigIfNeeded,
+  _resetMigrationState,
+  DEFAULT_SERVER_URL,
+  config,
+  normalizeServerUrl,
+  getActiveServer,
+  setActiveServer,
+  setServerConfig,
+  deleteServerConfig,
+  getConfig,
+  getMachineId,
+  getMachineName,
+  setMachineName
+};