@fett/synology-api 0.0.1-beta.3 → 0.0.1-beta.6

package/lib/cjs/index.js

@@ -0,0 +1,732 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AudioStationApi: () => AudioStationApi,
+  FileStationApi: () => FileStationApi,
+  SynologyApi: () => SynologyApi,
+  SynologyApiInfo: () => SynologyApiInfo,
+  default: () => index_default,
+  loadCli: () => loadCli
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core.ts
+var import_axios4 = __toESM(require("axios"));
+
+// src/types/apiInfo.ts
+var SynologyApiInfo = /* @__PURE__ */ ((SynologyApiInfo2) => {
+  SynologyApiInfo2["Auth"] = "SYNO.API.Auth";
+  SynologyApiInfo2["Info"] = "SYNO.API.Info";
+  SynologyApiInfo2["OTP"] = "SYNO.API.OTP";
+  return SynologyApiInfo2;
+})(SynologyApiInfo || {});
+var AudioStationApi = /* @__PURE__ */ ((AudioStationApi2) => {
+  AudioStationApi2["Song"] = "SYNO.AudioStation.Song";
+  AudioStationApi2["Album"] = "SYNO.AudioStation.Album";
+  AudioStationApi2["Artist"] = "SYNO.AudioStation.Artist";
+  AudioStationApi2["Genre"] = "SYNO.AudioStation.Genre";
+  AudioStationApi2["Playlist"] = "SYNO.AudioStation.Playlist";
+  AudioStationApi2["Folder"] = "SYNO.AudioStation.Folder";
+  AudioStationApi2["Cover"] = "SYNO.AudioStation.Cover";
+  AudioStationApi2["Download"] = "SYNO.AudioStation.Download";
+  AudioStationApi2["Info"] = "SYNO.AudioStation.Info";
+  AudioStationApi2["Lyrics"] = "SYNO.AudioStation.Lyrics";
+  AudioStationApi2["LyricsSearch"] = "SYNO.AudioStation.LyricsSearch";
+  AudioStationApi2["Radio"] = "SYNO.AudioStation.Radio";
+  AudioStationApi2["Stream"] = "SYNO.AudioStation.Stream";
+  AudioStationApi2["Tag"] = "SYNO.AudioStation.Tag";
+  return AudioStationApi2;
+})(AudioStationApi || {});
+var FileStationApi = /* @__PURE__ */ ((FileStationApi2) => {
+  FileStationApi2["File"] = "SYNO.FileStation.File";
+  FileStationApi2["Info"] = "SYNO.FileStation.Info";
+  FileStationApi2["List"] = "SYNO.FileStation.List";
+  FileStationApi2["Quota"] = "SYNO.FileStation.Quota";
+  FileStationApi2["Share"] = "SYNO.FileStation.Share";
+  FileStationApi2["Thumb"] = "SYNO.FileStation.Thumb";
+  FileStationApi2["Upload"] = "SYNO.FileStation.Upload";
+  return FileStationApi2;
+})(FileStationApi || {});
+
+// src/modules/AudioStation/Song.ts
+function getSongList(params) {
+  return __async(this, null, function* () {
+    const res = yield this.run("SYNO.AudioStation.Song" /* Song */, {
+      params: __spreadValues({
+        method: "list",
+        library: "all"
+      }, params)
+    });
+    return res.data;
+  });
+}
+
+// src/modules/AudioStation/index.ts
+var METHODS = {
+  getSongList
+};
+var SPELLING_KEY = "AudioStation";
+var SIMPLIFY_KEY = "as";
+
+// src/modules/FileStation/Info.ts
+function getInfo() {
+  return __async(this, null, function* () {
+    const res = yield this.run("SYNO.FileStation.Info" /* Info */, {
+      params: {
+        method: "get"
+      }
+    });
+    return res.data;
+  });
+}
+
+// src/utils.ts
+function isHttpUrl(url) {
+  return /^https?:\/\//.test(url);
+}
+function isUndfined(value) {
+  return value === void 0;
+}
+function getApiKey(apiName) {
+  return apiName.split(".")[1];
+}
+
+// src/modules/FileStation/List.ts
+function getFileList() {
+  return __async(this, arguments, function* (params = {}) {
+    const { additional = ["real_path", "size", "owner", "time"], filetype = "all" } = params;
+    if (isUndfined(params.folder_path)) {
+      throw new Error("folder_path is required");
+    }
+    const res = yield this.run("SYNO.FileStation.List" /* List */, {
+      params: __spreadValues({
+        method: "list",
+        additional: JSON.stringify(additional),
+        filetype,
+        folder_path: params.folder_path
+      }, params)
+    });
+    return res.data;
+  });
+}
+function getFileListShare() {
+  return __async(this, arguments, function* (params = {}) {
+    const { additional = ["real_path", "size", "owner", "time"], onlywritable = false } = params;
+    const res = yield this.run("SYNO.FileStation.List" /* List */, {
+      params: __spreadValues({
+        method: "list_share",
+        additional: JSON.stringify(additional),
+        onlywritable
+      }, params)
+    });
+    return res.data;
+  });
+}
+
+// src/modules/FileStation/index.ts
+var METHODS2 = {
+  getInfo,
+  getFileList,
+  getFileListShare
+};
+var SPELLING_KEY2 = "FileStation";
+var SIMPLIFY_KEY2 = "fs";
+
+// src/modules/index.ts
+var SynologyApiKeys = {
+  FileStation: SPELLING_KEY2,
+  fs: SIMPLIFY_KEY2,
+  AudioStation: SPELLING_KEY,
+  as: SIMPLIFY_KEY
+};
+SPELLING_KEY, SIMPLIFY_KEY, SPELLING_KEY2, SIMPLIFY_KEY2;
+var BaseSynologyApi = class {
+  constructor() {
+  }
+};
+function methodsBundler(instance, methods) {
+  const output = {};
+  for (const key in methods) {
+    output[key] = methods[key].bind(instance);
+  }
+  return output;
+}
+Object.defineProperties(BaseSynologyApi.prototype, {
+  // FileStation
+  [SynologyApiKeys.FileStation]: {
+    get() {
+      return methodsBundler(this, METHODS2);
+    }
+  },
+  [SynologyApiKeys.fs]: {
+    get() {
+      return methodsBundler(this, METHODS2);
+    }
+  },
+  // AudioStation
+  [SynologyApiKeys.AudioStation]: {
+    get() {
+      return methodsBundler(this, METHODS);
+    }
+  },
+  [SynologyApiKeys.as]: {
+    get() {
+      return methodsBundler(this, METHODS);
+    }
+  }
+});
+
+// src/helpers.ts
+var import_axios = __toESM(require("axios"));
+
+// src/constants.ts
+var GLOBAL_QUICK_CONNECT_URL = "https://global.quickconnect.cn/Serv.php";
+var QUICK_CONNECT_PINGPANG_API = "/webman/pingpong.cgi?action=cors&quickconnect=true";
+
+// src/helpers.ts
+var getServersFromServerInfo = (serverInfo) => __async(null, null, function* () {
+  var _a, _b, _c, _d, _e, _f;
+  if ((_a = serverInfo == null ? void 0 : serverInfo.service) == null ? void 0 : _a.relay_ip) {
+    const server = `http://${serverInfo.service.relay_ip}:${serverInfo.service.relay_port}`;
+    const res = yield pingpang(server);
+    if (res) {
+      return server;
+    }
+  }
+  if ((_c = (_b = serverInfo == null ? void 0 : serverInfo.server) == null ? void 0 : _b.external) == null ? void 0 : _c.ip) {
+    const server = `http://${serverInfo.server.external.ip}:${serverInfo.service.port}`;
+    if (yield pingpang(server)) {
+      return server;
+    }
+  }
+  if ((_e = (_d = serverInfo == null ? void 0 : serverInfo.server) == null ? void 0 : _d.interface) == null ? void 0 : _e[0]) {
+    const server = `http://${(_f = serverInfo.server.interface) == null ? void 0 : _f[0].ip}:${serverInfo.service.port}`;
+    if (yield pingpang(server)) {
+      return server;
+    }
+  }
+});
+var getServerInfo = (quickConnectId) => __async(null, null, function* () {
+  var _a, _b, _c, _d;
+  const params = {
+    version: 1,
+    id: "dsm",
+    serverID: quickConnectId,
+    get_ca_fingerprints: true,
+    command: "get_server_info"
+  };
+  const serverInfo = yield import_axios.default.post(GLOBAL_QUICK_CONNECT_URL, params);
+  if (!((_b = (_a = serverInfo.data) == null ? void 0 : _a.service) == null ? void 0 : _b.relay_ip) && !((_d = (_c = serverInfo.data) == null ? void 0 : _c.service) == null ? void 0 : _d.relay_port)) {
+    const relayRequestParams = {
+      version: 1,
+      id: "dsm",
+      serverID: quickConnectId,
+      platform: "web",
+      command: "request_tunnel"
+    };
+    const result = yield import_axios.default.post(
+      `https://${serverInfo.data.env.control_host}/Serv.php`,
+      relayRequestParams
+    );
+    return getServersFromServerInfo(result.data);
+  } else {
+    return getServersFromServerInfo(serverInfo.data);
+  }
+});
+var pingpang = (server) => __async(null, null, function* () {
+  try {
+    const result = yield import_axios.default.get(`${server}/${QUICK_CONNECT_PINGPANG_API}`, {
+      timeout: 3e3
+    });
+    if (result.data.success) {
+      return true;
+    } else {
+      return false;
+    }
+  } catch (_err) {
+    return false;
+  }
+});
+
+// src/modules/Api/Auth.ts
+var import_axios2 = __toESM(require("axios"));
+function login(core) {
+  return __async(this, null, function* () {
+    const params = {
+      api: "SYNO.API.Auth" /* Auth */,
+      version: 6,
+      method: "login",
+      account: core.username,
+      passwd: core.password,
+      format: "sid"
+    };
+    const url = `${core.baseUrl}entry.cgi`;
+    const result = yield import_axios2.default.get(url, { params });
+    if (!result.data.success) {
+      throw new Error(result.data.error.message);
+    }
+    return result.data;
+  });
+}
+function logout(core) {
+  return __async(this, null, function* () {
+    const params = {
+      api: "SYNO.API.Auth" /* Auth */,
+      version: 6,
+      method: "logout"
+    };
+    const url = `${core.baseUrl}entry.cgi`;
+    const result = yield import_axios2.default.get(url, { params });
+    if (!result.data.success) {
+      throw new Error(result.data.error.message);
+    }
+  });
+}
+
+// src/modules/Api/Info.ts
+var import_axios3 = __toESM(require("axios"));
+function getApiInfo(core) {
+  return __async(this, null, function* () {
+    const params = {
+      api: "SYNO.API.Info" /* Info */,
+      version: 1,
+      method: "query"
+    };
+    const url = `${core.baseUrl}entry.cgi`;
+    const result = yield import_axios3.default.get(url, { params });
+    if (!result.data.success) {
+      throw new Error(result.data.error.message);
+    }
+    return result.data;
+  });
+}
+
+// src/errorcodes.ts
+var CODE_SUCCESS = 0;
+var CODE_UNKNOWN = 9999;
+var SYNOLOGY_ERROR_CODES = {
+  [SynologyApiKeys.FileStation]: {
+    400: "Invalid parameter of file operation",
+    401: "Unknown error of file operation",
+    402: "System is too busy",
+    403: "Invalid user does this file operation",
+    404: "Invalid group does this file operation",
+    405: "Invalid user and group does this file operation",
+    406: "Can't get user/group information from the account server",
+    407: "Operation not permitted",
+    408: "No such file or directory",
+    409: "Non-supported file system",
+    410: "Failed to connect internet-based file system (e.g., CIFS)",
+    411: "Read-only file system",
+    412: "Filename too long in the non-encrypted file system",
+    413: "Filename too long in the encrypted file system",
+    414: "File already exists",
+    415: "Disk quota exceeded",
+    416: "No space left on device",
+    417: "Input/output error",
+    418: "Illegal name or path",
+    419: "Illegal file name",
+    420: "Illegal file name on FAT file system",
+    421: "Device or resource busy",
+    599: "No such task of the file operation"
+  },
+  [SynologyApiKeys.AudioStation]: {},
+  COMMON_CODES: {
+    [CODE_SUCCESS]: "Success",
+    100: "Unknown error",
+    101: "No parameter of API, method or version",
+    102: "The requested API does not exist",
+    103: "The requested method does not exist",
+    104: "The requested version does not support the functionality",
+    105: "The logged in session does not have permission",
+    106: "Session timeout",
+    107: "Session interrupted by duplicated login",
+    108: "Failed to upload the file",
+    109: "The network connection is unstable or the system is busy",
+    110: "The network connection is unstable or the system is busy",
+    111: "The network connection is unstable or the system is busy",
+    112: "Preserve for other purpose",
+    113: "Preserve for other purpose",
+    114: "Lost parameters for this API",
+    115: "Not allowed to upload a file",
+    116: "Not allowed to perform for a demo site",
+    117: "The network connection is unstable or the system is busy",
+    118: "The network connection is unstable or the system is busy",
+    119: "Invalid session / SID not found.",
+    // # 120-149 Preserve for other purpose
+    120: "Preserve for other purpose",
+    121: "Preserve for other purpose",
+    122: "Preserve for other purpose",
+    123: "Preserve for other purpose",
+    124: "Preserve for other purpose",
+    125: "Preserve for other purpose",
+    126: "Preserve for other purpose",
+    127: "Preserve for other purpose",
+    128: "Preserve for other purpose",
+    129: "Preserve for other purpose",
+    130: "Preserve for other purpose",
+    131: "Preserve for other purpose",
+    132: "Preserve for other purpose",
+    133: "Preserve for other purpose",
+    134: "Preserve for other purpose",
+    135: "Preserve for other purpose",
+    136: "Preserve for other purpose",
+    137: "Preserve for other purpose",
+    138: "Preserve for other purpose",
+    139: "Preserve for other purpose",
+    140: "Preserve for other purpose",
+    141: "Preserve for other purpose",
+    142: "Preserve for other purpose",
+    143: "Preserve for other purpose",
+    144: "Preserve for other purpose",
+    145: "Preserve for other purpose",
+    146: "Preserve for other purpose",
+    147: "Preserve for other purpose",
+    148: "Preserve for other purpose",
+    149: "Preserve for other purpose",
+    150: "Request source IP does not match the login IP",
+    160: "Insufficient application privilege",
+    [CODE_UNKNOWN]: "Unknown error"
+  }
+};
+var resWithErrorCode = (apiKey, res) => {
+  var _a, _b;
+  const errorCodes = SYNOLOGY_ERROR_CODES[apiKey];
+  const code = (_a = res == null ? void 0 : res.error) == null ? void 0 : _a.code;
+  if (isUndfined(code)) return res;
+  return __spreadProps(__spreadValues({}, res), {
+    error: __spreadProps(__spreadValues({}, res.error), {
+      message: ((_b = res == null ? void 0 : res.error) == null ? void 0 : _b.message) || (errorCodes == null ? void 0 : errorCodes[code]) || "Unknown error"
+    })
+  });
+};
+
+// src/core.ts
+var SynologyApi = class extends BaseSynologyApi {
+  constructor(options) {
+    super();
+    this.isConnecting = false;
+    this.authInfo = null;
+    this.apiInfo = {};
+    this.server = options.server;
+    this.username = options.username;
+    this.password = options.password;
+    this.baseUrl = `${this.server}/webapi/`;
+  }
+  connect() {
+    return __async(this, null, function* () {
+      if (!isHttpUrl(this.server)) {
+        this.server = yield getServerInfo(this.server);
+        this.baseUrl = `${this.server}/webapi/`;
+      }
+      try {
+        const result = yield login(this);
+        this.authInfo = result.data;
+        this.isConnecting = true;
+        yield this._getApiInfo();
+        return true;
+      } catch (err) {
+        console.error(err);
+        return false;
+      }
+    });
+  }
+  disconnect() {
+    return __async(this, null, function* () {
+      try {
+        yield logout(this);
+        this.authInfo = null;
+        this.apiInfo = {};
+        this.isConnecting = false;
+        return true;
+      } catch (err) {
+        console.error(err);
+        return false;
+      }
+    });
+  }
+  _getApiInfo() {
+    return __async(this, null, function* () {
+      try {
+        const result = yield getApiInfo(this);
+        this.apiInfo = result.data;
+      } catch (err) {
+        console.error(err);
+      }
+    });
+  }
+  hasApi(apiName) {
+    if (!this.isConnecting) {
+      throw new Error("Not connected");
+    }
+    return Object.prototype.hasOwnProperty.call(this.apiInfo, apiName);
+  }
+  run(apiName, options) {
+    return __async(this, null, function* () {
+      if (!this.isConnecting) {
+        const res = yield this.connect();
+        if (!res) {
+          throw new Error("Not connected");
+        }
+      }
+      if (!this.hasApi(apiName)) {
+        throw new Error(`${apiName} not found`);
+      }
+      const { method = "get", params, data, headers } = options;
+      const api = this.apiInfo[apiName];
+      const url = `${this.baseUrl}${api.path}`;
+      const externalParams = __spreadValues({
+        api: apiName,
+        version: api.maxVersion,
+        _sid: this.authInfo.sid
+      }, params);
+      let result = null;
+      if (method === "get") {
+        result = yield import_axios4.default.get(url, { params: externalParams, data, headers });
+      }
+      if (method === "post") {
+        result = yield import_axios4.default.post(url, { params: externalParams, data, headers });
+      }
+      const apiKey = getApiKey(apiName);
+      if (!isUndfined(apiKey)) {
+        result.data = resWithErrorCode(apiKey, result.data);
+      }
+      return result;
+    });
+  }
+};
+
+// src/cli/index.ts
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var import_path2 = __toESM(require("path"));
+var import_commander3 = require("commander");
+
+// src/cli/config.ts
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+var import_commander = require("commander");
+var import_chalk2 = __toESM(require("chalk"));
+
+// src/cli/helper.ts
+var import_chalk = __toESM(require("chalk"));
+function printMessages(messages) {
+  console.log(messages.join("\n"));
+}
+function isLowerCaseEqual(str1, str2) {
+  if (str1 && str2) {
+    return str1.toLowerCase() === str2.toLowerCase();
+  }
+  return !str1 && !str2;
+}
+function padding(message = "", before = 1, after = 1) {
+  return new Array(before).fill(" ").join("") + message + new Array(after).fill(" ").join("");
+}
+function geneDashLine(message, length) {
+  const finalMessage = new Array(Math.max(2, length - message.length + 2)).join(
+    "-"
+  );
+  return padding(import_chalk.default.dim(finalMessage));
+}
+
+// src/cli/config.ts
+var CONFIG_FILE_PATH = import_path.default.join(import_os.default.homedir(), "./.synology-api.json");
+var loadConfig = () => __async(null, null, function* () {
+  if (!(yield import_fs_extra.default.pathExists(CONFIG_FILE_PATH))) {
+    yield import_fs_extra.default.writeJSON(CONFIG_FILE_PATH, {
+      used: "",
+      connections: {}
+    });
+  }
+  const config = yield import_fs_extra.default.readJSON(CONFIG_FILE_PATH);
+  return config;
+});
+var updateConfig = (config) => __async(null, null, function* () {
+  yield import_fs_extra.default.writeJSON(CONFIG_FILE_PATH, config);
+});
+var configCmdRegister = () => {
+  const configCmd = import_commander.program.command("config").description("synology api config management");
+  configCmd.command("ls").description("List all the connection config").action(() => __async(null, null, function* () {
+    const config = yield loadConfig();
+    const keys = Object.keys(config.connections);
+    const dashLineLength = Math.max(...keys.map((key) => key.length)) + 3;
+    const messages = keys.map((key) => {
+      const connection = config.connections[key];
+      const prefix = isLowerCaseEqual(key, config.used) ? import_chalk2.default.green.bold("* ") : ":";
+      return prefix + key + geneDashLine(key, dashLineLength) + connection.server + ":" + connection.username + ":" + connection.password;
+    });
+    printMessages(messages);
+  }));
+  configCmd.command("add [name]").description("Add connection config").requiredOption("-s, --server <server>", "Synology server domain  or QuickConnect ID ").requiredOption("-u, --username <username>", "username").requiredOption("-p,  --password <password>", "password").action((name, options) => __async(null, null, function* () {
+    if (!name.trim()) throw new Error("Plaease input connection name");
+    const config = yield loadConfig();
+    const newConfig = __spreadProps(__spreadValues({}, config), {
+      connections: __spreadProps(__spreadValues({}, config.connections), {
+        [name]: {
+          server: options.server,
+          username: options.username,
+          password: options.password
+        }
+      })
+    });
+    yield updateConfig(newConfig);
+  }));
+  configCmd.command("use [name]").description("Change current connection").action((name) => __async(null, null, function* () {
+    const config = yield loadConfig();
+    if (config.used === name) return;
+    if (!config.connections[name]) {
+      console.log("Connection not found");
+      return;
+    }
+    config.used = name;
+    yield updateConfig(config);
+  }));
+  configCmd.command("del [name]").description("Remove a connection").action((name) => __async(null, null, function* () {
+    console.log("Remove a connection", name);
+    const config = yield loadConfig();
+    if (!config.connections[name]) {
+      console.log("Connection not found");
+      return;
+    }
+    delete config.connections[name];
+    if (config.used === name) {
+      config.used = "";
+    }
+    yield updateConfig(config);
+  }));
+  configCmd.command("rename <name> <newName>").description("Change connection name").action((name, newName) => __async(null, null, function* () {
+    const config = yield loadConfig();
+    if (!config.connections[name]) {
+      console.log("Connection not found");
+      return;
+    }
+    config.connections[newName] = config.connections[name];
+    delete config.connections[name];
+    if (config.used === name) {
+      config.used = newName;
+    }
+    yield updateConfig(config);
+  }));
+};
+
+// src/cli/apis.ts
+var import_commander2 = require("commander");
+var onMethodsCall = (module2) => (method, options) => __async(null, null, function* () {
+  var _a, _b;
+  const config = yield loadConfig();
+  const params = JSON.parse(options.params || "{}");
+  const pretty = options.pretty;
+  const synologyApi = new SynologyApi(config.connections[config.used]);
+  if ((_a = synologyApi[module2]) == null ? void 0 : _a[method]) {
+    const result = yield (_b = synologyApi[module2]) == null ? void 0 : _b[method](params);
+    if (pretty) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(JSON.stringify(result));
+    }
+  }
+  synologyApi.disconnect();
+  process.exit(0);
+});
+var apisCmdRegisterInfo = [
+  {
+    cmd: SynologyApiKeys.FileStation,
+    alias: SynologyApiKeys.fs
+  },
+  {
+    cmd: SynologyApiKeys.AudioStation,
+    alias: SynologyApiKeys.as
+  }
+];
+var apiCmdRegister = () => {
+  apisCmdRegisterInfo.forEach((info) => {
+    import_commander2.program.command(`${info.cmd} [methods]`).alias(info.alias).option("-p,--params <params>", `${info.cmd} methods params`).option("--pretty", "Prettyprint JSON Output").description(`Synology ${info.cmd} method call`).action(onMethodsCall(info.cmd));
+  });
+};
+
+// src/cli/index.ts
+function loadCli() {
+  return __async(this, null, function* () {
+    const pkg = yield import_fs_extra2.default.readJSON(import_path2.default.join(__dirname, "../../package.json"));
+    import_commander3.program.name("synology").usage("<command> [options]").description("synology api cli tool").version(pkg.version);
+    configCmdRegister();
+    apiCmdRegister();
+    import_commander3.program.parse(process.argv);
+  });
+}
+
+// src/index.ts
+var index_default = SynologyApi;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AudioStationApi,
+  FileStationApi,
+  SynologyApi,
+  SynologyApiInfo,
+  loadCli
+});