appwrite-cli 12.0.1 → 13.0.0-rc.2

package/lib/client.ts

@@ -0,0 +1,292 @@
+import os from "os";
+import { fetch, FormData, Agent } from "undici";
+import JSONbig from "json-bigint";
+import { AppwriteException } from "@appwrite.io/console";
+import { globalConfig } from "./config.js";
+import chalk from "chalk";
+import type {
+  Headers,
+  RequestParams,
+  ResponseType,
+  FileUpload,
+} from "./types.js";
+
+const JSONBigInt = JSONbig({ storeAsString: false });
+
+class Client {
+  private endpoint: string;
+  private headers: Headers;
+  private selfSigned: boolean;
+
+  constructor() {
+    this.endpoint = "https://cloud.appwrite.io/v1";
+    this.selfSigned = false;
+    this.headers = {
+      "content-type": "",
+      "x-sdk-name": "Command Line",
+      "x-sdk-platform": "console",
+      "x-sdk-language": "cli",
+      "x-sdk-version": "13.0.0-rc.2",
+      "user-agent": `AppwriteCLI/13.0.0-rc.2 (${os.type()} ${os.version()}; ${os.arch()})`,
+      "X-Appwrite-Response-Format": "1.8.1",
+    };
+  }
+
+  /**
+   * Set Cookie
+   *
+   * Your cookie
+   *
+   * @param {string} cookie
+   *
+   * @return self
+   */
+  setCookie(cookie: string): this {
+    this.addHeader("cookie", cookie);
+    return this;
+  }
+
+  /**
+   * Set Project
+   *
+   * Your project ID
+   *
+   * @param {string} project
+   *
+   * @return self
+   */
+  setProject(project: string): this {
+    this.addHeader("X-Appwrite-Project", project);
+    return this;
+  }
+
+  /**
+   * Set Key
+   *
+   * Your secret API key
+   *
+   * @param {string} key
+   *
+   * @return self
+   */
+  setKey(key: string): this {
+    this.addHeader("X-Appwrite-Key", key);
+    return this;
+  }
+
+  /**
+   * Set JWT
+   *
+   * Your secret JSON Web Token
+   *
+   * @param {string} jwt
+   *
+   * @return self
+   */
+  setJWT(jwt: string): this {
+    this.addHeader("X-Appwrite-JWT", jwt);
+    return this;
+  }
+
+  /**
+   * Set Locale
+   *
+   * @param {string} locale
+   *
+   * @return self
+   */
+  setLocale(locale: string): this {
+    this.addHeader("X-Appwrite-Locale", locale);
+    return this;
+  }
+
+  /**
+   * Set Mode
+   *
+   * @param {string} mode
+   *
+   * @return self
+   */
+  setMode(mode: string): this {
+    this.addHeader("X-Appwrite-Mode", mode);
+    return this;
+  }
+
+  /**
+   * Set self signed.
+   *
+   * @param {bool} status
+   *
+   * @return this
+   */
+  setSelfSigned(status: boolean): this {
+    this.selfSigned = status;
+    return this;
+  }
+
+  /**
+   * Set endpoint.
+   *
+   * @param {string} endpoint
+   *
+   * @return this
+   */
+  setEndpoint(endpoint: string): this {
+    if (!endpoint.startsWith("http://") && !endpoint.startsWith("https://")) {
+      throw new AppwriteException("Invalid endpoint URL: " + endpoint);
+    }
+
+    this.endpoint = endpoint;
+    return this;
+  }
+
+  /**
+   * @param {string} key
+   * @param {string} value
+   */
+  addHeader(key: string, value: string): this {
+    this.headers[key.toLowerCase()] = value;
+    return this;
+  }
+
+  async call<T = unknown>(
+    method: string,
+    path: string = "",
+    headers: Headers = {},
+    params: RequestParams = {},
+    responseType: ResponseType = "json",
+  ): Promise<T> {
+    const mergedHeaders: Headers = { ...this.headers, ...headers };
+    const url = new URL(this.endpoint + path);
+
+    let body: FormData | string | undefined = undefined;
+
+    if (method.toUpperCase() === "GET") {
+      url.search = new URLSearchParams(
+        Client.flatten(params) as Record<string, string>,
+      ).toString();
+    } else if (
+      mergedHeaders["content-type"]
+        ?.toLowerCase()
+        .startsWith("multipart/form-data")
+    ) {
+      delete mergedHeaders["content-type"];
+      const formData = new FormData();
+
+      const flatParams = Client.flatten(params);
+
+      for (const [key, value] of Object.entries(flatParams)) {
+        if (
+          value &&
+          typeof value === "object" &&
+          "type" in value &&
+          value.type === "file"
+        ) {
+          const fileUpload = value as FileUpload;
+          formData.append(key, fileUpload.file as any, fileUpload.filename);
+        } else {
+          formData.append(key, value as string);
+        }
+      }
+
+      body = formData;
+    } else {
+      body = JSONBigInt.stringify(params);
+    }
+
+    let response: Awaited<ReturnType<typeof fetch>> | undefined = undefined;
+    try {
+      response = await fetch(url.toString(), {
+        method: method.toUpperCase(),
+        headers: mergedHeaders,
+        body,
+        dispatcher: new Agent({
+          connect: {
+            rejectUnauthorized: !this.selfSigned,
+          },
+        }),
+      });
+    } catch (error) {
+      throw new AppwriteException((error as Error).message);
+    }
+
+    if (response.status >= 400) {
+      const text = await response.text();
+      let json: { message?: string; code?: number; type?: string } | undefined =
+        undefined;
+      try {
+        json = JSON.parse(text);
+      } catch (error) {
+        throw new AppwriteException(text, response.status, "", text);
+      }
+
+      if (
+        path !== "/account" &&
+        json.code === 401 &&
+        json.type === "user_more_factors_required"
+      ) {
+        console.log(
+          `${chalk.cyan.bold("ℹ Info")} ${chalk.cyan("Unusable account found, removing...")}`,
+        );
+
+        const current = globalConfig.getCurrentSession();
+        globalConfig.setCurrentSession("");
+        globalConfig.removeSession(current);
+      }
+      throw new AppwriteException(
+        json.message || text,
+        json.code,
+        json.type,
+        text,
+      );
+    }
+
+    if (responseType === "arraybuffer") {
+      const data = await response.arrayBuffer();
+      return data as T;
+    }
+
+    const cookies = response.headers.getSetCookie();
+    if (cookies && cookies.length > 0) {
+      for (const cookie of cookies) {
+        if (cookie.startsWith("a_session_console=")) {
+          globalConfig.setCookie(cookie);
+        }
+      }
+    }
+
+    const text = await response.text();
+    let json: T | undefined = undefined;
+    try {
+      json = JSONBigInt.parse(text);
+    } catch (error) {
+      return text as T;
+    }
+    return json as T;
+  }
+
+  static flatten(
+    data: RequestParams,
+    prefix: string = "",
+  ): Record<string, unknown> {
+    let output: Record<string, unknown> = {};
+
+    for (const key in data) {
+      const value = data[key];
+      const finalKey = prefix ? prefix + "[" + key + "]" : key;
+
+      if (Array.isArray(value)) {
+        output = {
+          ...output,
+          ...Client.flatten(value as unknown as RequestParams, finalKey),
+        };
+      } else {
+        output[finalKey] = value;
+      }
+    }
+
+    return output;
+  }
+}
+
+export default Client;

package/lib/commands/generic.ts

@@ -0,0 +1,440 @@
+import inquirer from "inquirer";
+import { Command } from "commander";
+import { Client } from "@appwrite.io/console";
+import { sdkForConsole } from "../sdks.js";
+import { globalConfig, localConfig } from "../config.js";
+import {
+  actionRunner,
+  success,
+  parseBool,
+  commandDescriptions,
+  error,
+  parse,
+  hint,
+  log,
+  drawTable,
+  cliConfig,
+} from "../parser.js";
+import ID from "../id.js";
+import {
+  questionsLogin,
+  questionsLogout,
+  questionsListFactors,
+  questionsMFAChallenge,
+} from "../questions.js";
+import { Account, Client as ConsoleClient } from "@appwrite.io/console";
+import ClientLegacy from "../client.js";
+
+const DEFAULT_ENDPOINT = "https://cloud.appwrite.io/v1";
+
+interface LoginCommandOptions {
+  email?: string;
+  password?: string;
+  endpoint?: string;
+  mfa?: string;
+  code?: string;
+}
+
+export const loginCommand = async ({
+  email,
+  password,
+  endpoint,
+  mfa,
+  code,
+}: LoginCommandOptions): Promise<void> => {
+  const oldCurrent = globalConfig.getCurrentSession();
+
+  const configEndpoint =
+    (endpoint ?? globalConfig.getEndpoint()) || DEFAULT_ENDPOINT;
+
+  if (globalConfig.getCurrentSession() !== "") {
+    log("You are currently signed in as " + globalConfig.getEmail());
+
+    if (globalConfig.getSessions().length === 1) {
+      hint("You can sign in and manage multiple accounts with Appwrite CLI");
+    }
+  }
+
+  const answers =
+    email && password
+      ? { email, password }
+      : await inquirer.prompt(questionsLogin);
+
+  if (!answers.method) {
+    answers.method = "login";
+  }
+
+  if (answers.method === "select") {
+    const accountId = answers.accountId;
+
+    if (!globalConfig.getSessionIds().includes(accountId)) {
+      throw Error("Session ID not found");
+    }
+
+    globalConfig.setCurrentSession(accountId);
+    success(`Current account is ${accountId}`);
+
+    return;
+  }
+
+  const id = ID.unique();
+
+  globalConfig.addSession(id, { endpoint: configEndpoint });
+  globalConfig.setCurrentSession(id);
+  globalConfig.setEndpoint(configEndpoint);
+  globalConfig.setEmail(answers.email);
+
+  // Use legacy client for login to extract cookies from response
+  const legacyClient = new ClientLegacy();
+  legacyClient.setEndpoint(configEndpoint);
+  legacyClient.setProject("console");
+  if (globalConfig.getSelfSigned()) {
+    legacyClient.setSelfSigned(true);
+  }
+
+  let client = await sdkForConsole(false);
+  let accountClient = new Account(client);
+
+  let account;
+
+  try {
+    await legacyClient.call(
+      "POST",
+      "/account/sessions/email",
+      {
+        "content-type": "application/json",
+      },
+      {
+        email: answers.email,
+        password: answers.password,
+      },
+    );
+
+    const savedCookie = globalConfig.getCookie();
+
+    if (savedCookie) {
+      legacyClient.setCookie(savedCookie);
+      client.setCookie(savedCookie);
+    }
+
+    accountClient = new Account(client);
+    account = await accountClient.get();
+  } catch (err: any) {
+    if (
+      err.type === "user_more_factors_required" ||
+      err.response === "user_more_factors_required"
+    ) {
+      const { factor } = mfa
+        ? { factor: mfa }
+        : await inquirer.prompt(questionsListFactors);
+      const challenge = await accountClient.createMfaChallenge(factor);
+
+      const { otp } = code
+        ? { otp: code }
+        : await inquirer.prompt(questionsMFAChallenge);
+      await legacyClient.call(
+        "PUT",
+        "/account/mfa/challenges",
+        {
+          "content-type": "application/json",
+        },
+        {
+          challengeId: challenge.$id,
+          otp: otp,
+        },
+      );
+
+      const savedCookie = globalConfig.getCookie();
+      if (savedCookie) {
+        client.setCookie(savedCookie);
+      }
+
+      accountClient = new Account(client);
+      account = await accountClient.get();
+    } else {
+      globalConfig.removeSession(id);
+      globalConfig.setCurrentSession(oldCurrent);
+      if (
+        endpoint !== DEFAULT_ENDPOINT &&
+        (err.type === "user_invalid_credentials" ||
+          err.response === "user_invalid_credentials")
+      ) {
+        log("Use the --endpoint option for self-hosted instances");
+      }
+      throw err;
+    }
+  }
+
+  success("Successfully signed in as " + account.email);
+  hint(
+    "Next you can create or link to your project using 'appwrite init project'",
+  );
+};
+
+export const whoami = new Command("whoami")
+  .description(commandDescriptions["whoami"])
+  .action(
+    actionRunner(async () => {
+      if (
+        globalConfig.getEndpoint() === "" ||
+        globalConfig.getCookie() === ""
+      ) {
+        error("No user is signed in. To sign in, run 'appwrite login'");
+        return;
+      }
+
+      let client = await sdkForConsole(false);
+      let accountClient = new Account(client);
+
+      let account;
+
+      try {
+        account = await accountClient.get();
+      } catch (_) {
+        error("No user is signed in. To sign in, run 'appwrite login'");
+        return;
+      }
+
+      const data = [
+        {
+          ID: account.$id,
+          Name: account.name,
+          Email: account.email,
+          "MFA enabled": account.mfa ? "Yes" : "No",
+          Endpoint: globalConfig.getEndpoint(),
+        },
+      ];
+
+      if (cliConfig.json) {
+        console.log(data);
+        return;
+      }
+
+      drawTable(data);
+    }),
+  );
+
+export const register = new Command("register")
+  .description(commandDescriptions["register"])
+  .action(
+    actionRunner(async () => {
+      log("Visit https://cloud.appwrite.io/register to create an account");
+    }),
+  );
+
+export const login = new Command("login")
+  .description(commandDescriptions["login"])
+  .option(`--email [email]`, `User email`)
+  .option(`--password [password]`, `User password`)
+  .option(
+    `--endpoint [endpoint]`,
+    `Appwrite endpoint for self hosted instances`,
+  )
+  .option(
+    `--mfa [factor]`,
+    `Multi-factor authentication login factor: totp, email, phone or recoveryCode`,
+  )
+  .option(`--code [code]`, `Multi-factor code`)
+  .configureHelp({
+    helpWidth: process.stdout.columns || 80,
+  })
+  .action(actionRunner(loginCommand));
+
+const deleteSession = async (accountId: string): Promise<void> => {
+  try {
+    let client = await sdkForConsole();
+    let accountClient = new Account(client);
+
+    await accountClient.deleteSession("current");
+  } catch (e) {
+    error("Unable to log out, removing locally saved session information");
+  } finally {
+    globalConfig.removeSession(accountId);
+  }
+};
+
+export const logout = new Command("logout")
+  .description(commandDescriptions["logout"])
+  .configureHelp({
+    helpWidth: process.stdout.columns || 80,
+  })
+  .action(
+    actionRunner(async () => {
+      const sessions = globalConfig.getSessions();
+      const current = globalConfig.getCurrentSession();
+
+      if (current === "" || !sessions.length) {
+        log("No active sessions found.");
+        return;
+      }
+      if (sessions.length === 1) {
+        await deleteSession(current);
+        globalConfig.setCurrentSession("");
+        success("Logging out");
+
+        return;
+      }
+
+      const answers = await inquirer.prompt(questionsLogout);
+
+      if (answers.accounts) {
+        for (let accountId of answers.accounts) {
+          globalConfig.setCurrentSession(accountId);
+          await deleteSession(accountId);
+        }
+      }
+
+      const remainingSessions = globalConfig.getSessions();
+
+      if (
+        remainingSessions.length > 0 &&
+        remainingSessions.filter((session: any) => session.id === current)
+          .length !== 1
+      ) {
+        const accountId = remainingSessions[0].id;
+        globalConfig.setCurrentSession(accountId);
+
+        success(`Current account is ${accountId}`);
+      } else if (remainingSessions.length === 0) {
+        globalConfig.setCurrentSession("");
+      }
+
+      success("Logging out");
+    }),
+  );
+
+interface ClientCommandOptions {
+  selfSigned?: boolean;
+  endpoint?: string;
+  projectId?: string;
+  key?: string;
+  debug?: boolean;
+  reset?: boolean;
+}
+
+export const client = new Command("client")
+  .description(commandDescriptions["client"])
+  .configureHelp({
+    helpWidth: process.stdout.columns || 80,
+  })
+  .option(
+    "-ss, --self-signed <value>",
+    "Configure the CLI to use a self-signed certificate ( true or false )",
+    parseBool,
+  )
+  .option("-e, --endpoint <endpoint>", "Set your Appwrite server endpoint")
+  .option("-p, --project-id <project-id>", "Set your Appwrite project ID")
+  .option("-k, --key <key>", "Set your Appwrite server's API key")
+  .option("-d, --debug", "Print CLI debug information")
+  .option("-r, --reset", "Reset the CLI configuration")
+  .action(
+    actionRunner(
+      async (
+        {
+          selfSigned,
+          endpoint,
+          projectId,
+          key,
+          debug,
+          reset,
+        }: ClientCommandOptions,
+        command: Command,
+      ) => {
+        if (
+          selfSigned == undefined &&
+          endpoint == undefined &&
+          projectId == undefined &&
+          key == undefined &&
+          debug == undefined &&
+          reset == undefined
+        ) {
+          command.help();
+        }
+
+        if (debug) {
+          let config = {
+            endpoint: globalConfig.getEndpoint(),
+            key: globalConfig.getKey(),
+            cookie: globalConfig.getCookie(),
+            selfSigned: globalConfig.getSelfSigned(),
+            project: localConfig.getProject(),
+          };
+          parse(config);
+        }
+
+        if (endpoint !== undefined) {
+          try {
+            const id = ID.unique();
+            let url = new URL(endpoint);
+            if (url.protocol !== "http:" && url.protocol !== "https:") {
+              throw new Error();
+            }
+
+            let clientInstance = new Client().setEndpoint(endpoint);
+            clientInstance.setProject("console");
+            if (selfSigned || globalConfig.getSelfSigned()) {
+              clientInstance.setSelfSigned(true);
+            }
+            let response = (await clientInstance.call(
+              "GET",
+              new URL(endpoint + "/health/version"),
+            )) as { version?: string };
+            if (!response.version) {
+              throw new Error();
+            }
+            globalConfig.setCurrentSession(id);
+            globalConfig.addSession(id, { endpoint });
+            globalConfig.setEndpoint(endpoint);
+          } catch (_) {
+            throw new Error(
+              "Invalid endpoint or your Appwrite server is not running as expected.",
+            );
+          }
+        }
+
+        if (key !== undefined) {
+          globalConfig.setKey(key);
+        }
+
+        if (projectId !== undefined) {
+          localConfig.setProject(projectId, "");
+        }
+
+        if (selfSigned == true || selfSigned == false) {
+          globalConfig.setSelfSigned(selfSigned);
+        }
+
+        if (reset !== undefined) {
+          const sessions = globalConfig.getSessions();
+
+          for (let accountId of sessions.map((session: any) => session.id)) {
+            globalConfig.setCurrentSession(accountId);
+            await deleteSession(accountId);
+          }
+        }
+
+        success("Setting client");
+      },
+    ),
+  );
+
+export const migrate = async (): Promise<void> => {
+  if (!globalConfig.has("endpoint") || !globalConfig.has("cookie")) {
+    return;
+  }
+
+  const endpoint = globalConfig.get("endpoint") as string;
+  const cookie = globalConfig.get("cookie") as string;
+
+  const id = ID.unique();
+  const data = {
+    endpoint,
+    cookie,
+    email: "legacy",
+  };
+
+  globalConfig.addSession(id, data);
+  globalConfig.setCurrentSession(id);
+  globalConfig.delete("endpoint");
+  globalConfig.delete("cookie");
+};