dxfl 0.1.0

package/LICENSE

@@ -0,0 +1,287 @@
+                      EUROPEAN UNION PUBLIC LICENCE v. 1.2
+                      EUPL © the European Union 2007, 2016
+
+This European Union Public Licence (the ‘EUPL’) applies to the Work (as defined
+below) which is provided under the terms of this Licence. Any use of the Work,
+other than as authorised under this Licence is prohibited (to the extent such
+use is covered by a right of the copyright holder of the Work).
+
+The Work is provided under the terms of this Licence when the Licensor (as
+defined below) has placed the following notice immediately following the
+copyright notice for the Work:
+
+        Licensed under the EUPL
+
+or has expressed by any other means his willingness to license under the EUPL.
+
+1. Definitions
+
+In this Licence, the following terms have the following meaning:
+
+- ‘The Licence’: this Licence.
+
+- ‘The Original Work’: the work or software distributed or communicated by the
+  Licensor under this Licence, available as Source Code and also as Executable
+  Code as the case may be.
+
+- ‘Derivative Works’: the works or software that could be created by the
+  Licensee, based upon the Original Work or modifications thereof. This Licence
+  does not define the extent of modification or dependence on the Original Work
+  required in order to classify a work as a Derivative Work; this extent is
+  determined by copyright law applicable in the country mentioned in Article 15.
+
+- ‘The Work’: the Original Work or its Derivative Works.
+
+- ‘The Source Code’: the human-readable form of the Work which is the most
+  convenient for people to study and modify.
+
+- ‘The Executable Code’: any code which has generally been compiled and which is
+  meant to be interpreted by a computer as a program.
+
+- ‘The Licensor’: the natural or legal person that distributes or communicates
+  the Work under the Licence.
+
+- ‘Contributor(s)’: any natural or legal person who modifies the Work under the
+  Licence, or otherwise contributes to the creation of a Derivative Work.
+
+- ‘The Licensee’ or ‘You’: any natural or legal person who makes any usage of
+  the Work under the terms of the Licence.
+
+- ‘Distribution’ or ‘Communication’: any act of selling, giving, lending,
+  renting, distributing, communicating, transmitting, or otherwise making
+  available, online or offline, copies of the Work or providing access to its
+  essential functionalities at the disposal of any other natural or legal
+  person.
+
+2. Scope of the rights granted by the Licence
+
+The Licensor hereby grants You a worldwide, royalty-free, non-exclusive,
+sublicensable licence to do the following, for the duration of copyright vested
+in the Original Work:
+
+- use the Work in any circumstance and for all usage,
+- reproduce the Work,
+- modify the Work, and make Derivative Works based upon the Work,
+- communicate to the public, including the right to make available or display
+  the Work or copies thereof to the public and perform publicly, as the case may
+  be, the Work,
+- distribute the Work or copies thereof,
+- lend and rent the Work or copies thereof,
+- sublicense rights in the Work or copies thereof.
+
+Those rights can be exercised on any media, supports and formats, whether now
+known or later invented, as far as the applicable law permits so.
+
+In the countries where moral rights apply, the Licensor waives his right to
+exercise his moral right to the extent allowed by law in order to make effective
+the licence of the economic rights here above listed.
+
+The Licensor grants to the Licensee royalty-free, non-exclusive usage rights to
+any patents held by the Licensor, to the extent necessary to make use of the
+rights granted on the Work under this Licence.
+
+3. Communication of the Source Code
+
+The Licensor may provide the Work either in its Source Code form, or as
+Executable Code. If the Work is provided as Executable Code, the Licensor
+provides in addition a machine-readable copy of the Source Code of the Work
+along with each copy of the Work that the Licensor distributes or indicates, in
+a notice following the copyright notice attached to the Work, a repository where
+the Source Code is easily and freely accessible for as long as the Licensor
+continues to distribute or communicate the Work.
+
+4. Limitations on copyright
+
+Nothing in this Licence is intended to deprive the Licensee of the benefits from
+any exception or limitation to the exclusive rights of the rights owners in the
+Work, of the exhaustion of those rights or of other applicable limitations
+thereto.
+
+5. Obligations of the Licensee
+
+The grant of the rights mentioned above is subject to some restrictions and
+obligations imposed on the Licensee. Those obligations are the following:
+
+Attribution right: The Licensee shall keep intact all copyright, patent or
+trademarks notices and all notices that refer to the Licence and to the
+disclaimer of warranties. The Licensee must include a copy of such notices and a
+copy of the Licence with every copy of the Work he/she distributes or
+communicates. The Licensee must cause any Derivative Work to carry prominent
+notices stating that the Work has been modified and the date of modification.
+
+Copyleft clause: If the Licensee distributes or communicates copies of the
+Original Works or Derivative Works, this Distribution or Communication will be
+done under the terms of this Licence or of a later version of this Licence
+unless the Original Work is expressly distributed only under this version of the
+Licence — for example by communicating ‘EUPL v. 1.2 only’. The Licensee
+(becoming Licensor) cannot offer or impose any additional terms or conditions on
+the Work or Derivative Work that alter or restrict the terms of the Licence.
+
+Compatibility clause: If the Licensee Distributes or Communicates Derivative
+Works or copies thereof based upon both the Work and another work licensed under
+a Compatible Licence, this Distribution or Communication can be done under the
+terms of this Compatible Licence. For the sake of this clause, ‘Compatible
+Licence’ refers to the licences listed in the appendix attached to this Licence.
+Should the Licensee's obligations under the Compatible Licence conflict with
+his/her obligations under this Licence, the obligations of the Compatible
+Licence shall prevail.
+
+Provision of Source Code: When distributing or communicating copies of the Work,
+the Licensee will provide a machine-readable copy of the Source Code or indicate
+a repository where this Source will be easily and freely available for as long
+as the Licensee continues to distribute or communicate the Work.
+
+Legal Protection: This Licence does not grant permission to use the trade names,
+trademarks, service marks, or names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the copyright notice.
+
+6. Chain of Authorship
+
+The original Licensor warrants that the copyright in the Original Work granted
+hereunder is owned by him/her or licensed to him/her and that he/she has the
+power and authority to grant the Licence.
+
+Each Contributor warrants that the copyright in the modifications he/she brings
+to the Work are owned by him/her or licensed to him/her and that he/she has the
+power and authority to grant the Licence.
+
+Each time You accept the Licence, the original Licensor and subsequent
+Contributors grant You a licence to their contributions to the Work, under the
+terms of this Licence.
+
+7. Disclaimer of Warranty
+
+The Work is a work in progress, which is continuously improved by numerous
+Contributors. It is not a finished work and may therefore contain defects or
+‘bugs’ inherent to this type of development.
+
+For the above reason, the Work is provided under the Licence on an ‘as is’ basis
+and without warranties of any kind concerning the Work, including without
+limitation merchantability, fitness for a particular purpose, absence of defects
+or errors, accuracy, non-infringement of intellectual property rights other than
+copyright as stated in Article 6 of this Licence.
+
+This disclaimer of warranty is an essential part of the Licence and a condition
+for the grant of any rights to the Work.
+
+8. Disclaimer of Liability
+
+Except in the cases of wilful misconduct or damages directly caused to natural
+persons, the Licensor will in no event be liable for any direct or indirect,
+material or moral, damages of any kind, arising out of the Licence or of the use
+of the Work, including without limitation, damages for loss of goodwill, work
+stoppage, computer failure or malfunction, loss of data or any commercial
+damage, even if the Licensor has been advised of the possibility of such damage.
+However, the Licensor will be liable under statutory product liability laws as
+far such laws apply to the Work.
+
+9. Additional agreements
+
+While distributing the Work, You may choose to conclude an additional agreement,
+defining obligations or services consistent with this Licence. However, if
+accepting obligations, You may act only on your own behalf and on your sole
+responsibility, not on behalf of the original Licensor or any other Contributor,
+and only if You agree to indemnify, defend, and hold each Contributor harmless
+for any liability incurred by, or claims asserted against such Contributor by
+the fact You have accepted any warranty or additional liability.
+
+10. Acceptance of the Licence
+
+The provisions of this Licence can be accepted by clicking on an icon ‘I agree’
+placed under the bottom of a window displaying the text of this Licence or by
+affirming consent in any other similar way, in accordance with the rules of
+applicable law. Clicking on that icon indicates your clear and irrevocable
+acceptance of this Licence and all of its terms and conditions.
+
+Similarly, you irrevocably accept this Licence and all of its terms and
+conditions by exercising any rights granted to You by Article 2 of this Licence,
+such as the use of the Work, the creation by You of a Derivative Work or the
+Distribution or Communication by You of the Work or copies thereof.
+
+11. Information to the public
+
+In case of any Distribution or Communication of the Work by means of electronic
+communication by You (for example, by offering to download the Work from a
+remote location) the distribution channel or media (for example, a website) must
+at least provide to the public the information requested by the applicable law
+regarding the Licensor, the Licence and the way it may be accessible, concluded,
+stored and reproduced by the Licensee.
+
+12. Termination of the Licence
+
+The Licence and the rights granted hereunder will terminate automatically upon
+any breach by the Licensee of the terms of the Licence.
+
+Such a termination will not terminate the licences of any person who has
+received the Work from the Licensee under the Licence, provided such persons
+remain in full compliance with the Licence.
+
+13. Miscellaneous
+
+Without prejudice of Article 9 above, the Licence represents the complete
+agreement between the Parties as to the Work.
+
+If any provision of the Licence is invalid or unenforceable under applicable
+law, this will not affect the validity or enforceability of the Licence as a
+whole. Such provision will be construed or reformed so as necessary to make it
+valid and enforceable.
+
+The European Commission may publish other linguistic versions or new versions of
+this Licence or updated versions of the Appendix, so far this is required and
+reasonable, without reducing the scope of the rights granted by the Licence. New
+versions of the Licence will be published with a unique version number.
+
+All linguistic versions of this Licence, approved by the European Commission,
+have identical value. Parties can take advantage of the linguistic version of
+their choice.
+
+14. Jurisdiction
+
+Without prejudice to specific agreement between parties,
+
+- any litigation resulting from the interpretation of this License, arising
+  between the European Union institutions, bodies, offices or agencies, as a
+  Licensor, and any Licensee, will be subject to the jurisdiction of the Court
+  of Justice of the European Union, as laid down in article 272 of the Treaty on
+  the Functioning of the European Union,
+
+- any litigation arising between other parties and resulting from the
+  interpretation of this License, will be subject to the exclusive jurisdiction
+  of the competent court where the Licensor resides or conducts its primary
+  business.
+
+15. Applicable Law
+
+Without prejudice to specific agreement between parties,
+
+- this Licence shall be governed by the law of the European Union Member State
+  where the Licensor has his seat, resides or has his registered office,
+
+- this licence shall be governed by Belgian law if the Licensor has no seat,
+  residence or registered office inside a European Union Member State.
+
+Appendix
+
+‘Compatible Licences’ according to Article 5 EUPL are:
+
+- GNU General Public License (GPL) v. 2, v. 3
+- GNU Affero General Public License (AGPL) v. 3
+- Open Software License (OSL) v. 2.1, v. 3.0
+- Eclipse Public License (EPL) v. 1.0
+- CeCILL v. 2.0, v. 2.1
+- Mozilla Public Licence (MPL) v. 2
+- GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3
+- Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) for
+  works other than software
+- European Union Public Licence (EUPL) v. 1.1, v. 1.2
+- Québec Free and Open-Source Licence — Reciprocity (LiLiQ-R) or Strong
+  Reciprocity (LiLiQ-R+).
+
+The European Commission may update this Appendix to later versions of the above
+licences without producing a new version of the EUPL, as long as they provide
+the rights granted in Article 2 of this Licence and protect the covered Source
+Code from exclusive appropriation.
+
+All other changes or additions to this Appendix require the production of a new
+EUPL version.

package/README.md

@@ -0,0 +1,45 @@
+# dfl
+
+A CLI tool to manage your Deuxfleurs account.
+
+## Install
+
+```
+npm install -g git+https://git.deuxfleurs.fr/Deuxfleurs/dfl
+```
+
+## Usage
+
+*Not ready*
+
+Start by login with your username, for example for `john`:
+
+```
+dfl login john
+```
+
+Then you can list your websites:
+
+```
+dfl list
+```
+
+And then to deploy your `_public` folder on `example.com`:
+
+```
+dfl deploy example.com _public
+```
+
+## Development
+
+```
+git clone https://git.deuxfleurs.fr/Deuxfleurs/dfl
+cd dfl
+npm install
+tsc
+node index.js
+```
+
+## License
+
+This software is distributed under the EUPL-1.2 license.

package/auth.ts

@@ -0,0 +1,81 @@
+import { Configuration, WebsiteApi } from "guichet-sdk-ts";
+import { read } from 'read';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
+function configPath(): string {
+  let path = ".dfl/config.json";
+  if (process.env.XDG_CONFIG_HOME) {
+    path = process.env.XDG_CONFIG_HOME + "/dfl/config.json";
+  } else if (process.env.HOME) {
+    path = process.env.HOME + "/.config/dfl/config.json";
+  }
+  return path
+}
+
+interface PersistedConfig {
+  username: string,
+  password: string,
+}
+
+export async function openApiConf() {
+  let strConf: string;
+  let dictConf: PersistedConfig;
+
+  const configFile = configPath();
+
+  try {
+    strConf = await fs.readFile(configFile, { encoding: 'utf8' });
+  } catch (err) {
+    console.error(err, `\n\nUnable to read ${configFile}, run 'dfl login' first.`);
+    process.exit(1);
+  }
+
+  try {
+    dictConf = JSON.parse(strConf);
+  } catch (err) {
+    console.error(err, `\n\nUnable to parse ${configFile} as JSON, check your syntax. Did you manually edit this file?`);
+    process.exit(1);
+  }
+
+  // @FIXME: we do not validate that the dictConf object really contains a username or password field...
+
+  return new Configuration({
+    username: dictConf.username,
+    password: dictConf.password,
+  });
+}
+
+export async function login(username: string) {
+  const password = await read({
+    prompt: "password: ",
+    silent: true,
+    replace: "*"
+  });
+
+  // check config
+  const testConf = new Configuration({
+    username: username,
+    password: password,
+  });
+  const web = new WebsiteApi(testConf);
+  try {
+      await web.listWebsites();
+  } catch (err) {
+      console.error(err, `\n\nLogin failed. Is your username and password correct?`);
+      process.exit(1);
+  }
+
+  // create config folder if needed
+  const configFile = configPath();
+  const parent = path.dirname(configFile);
+  await fs.mkdir(parent, { recursive: true });
+
+  // create, serialize, save config data
+  const configData: PersistedConfig = { username, password };
+  const serializedConfig = JSON.stringify(configData);
+  await fs.writeFile(configFile, serializedConfig, { mode: 0o600 });
+  // @FIXME: we would like to avoid storing the password in clear text in the future.
+
+  console.log('ok')
+}

package/bootstrap.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+require('tsx/cjs')
+require('./index.ts')

package/deploy.ts

@@ -0,0 +1,152 @@
+import fs from "fs";
+import path from "path";
+import mime from "mime";
+import { WebsiteApi } from "guichet-sdk-ts";
+import {
+  S3Client,
+  ListObjectsV2Command,
+  DeleteObjectsCommand,
+  DeleteObjectsCommandOutput,
+} from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+import { openApiConf } from "./auth";
+import Pool from "@supercharge/promise-pool";
+
+// Walks through the local directory at path `dir`, and for each file it contains, returns :
+// - `localPath`: its path on the local filesystem (includes `dir`). On windows, this path
+//    will typically use `\` as separator.
+// - `s3Path`: an equivalent path as we would store it in an S3 bucket, using '/' as separator.
+//   This path includes `s3Prefix` as a prefix if provided. If `s3Prefix` is null, `s3Path`
+//    is relative to the root (of the form "a/b/c", instead of "/a/b/c" if `s3Prefix` is "").
+async function getLocalFiles(dir: string, s3Prefix: string | null): Promise<{ localPath: string, s3Path: string}[]> {
+  const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+  const files = await Promise.all(entries.map(entry => {
+    const localPath = path.join(dir, entry.name);
+    const s3Path = s3Prefix ? s3Prefix + "/" + entry.name : entry.name;
+    if (entry.isDirectory()) {
+      return getLocalFiles(localPath, s3Path)
+    } else {
+      return Promise.resolve([{ localPath, s3Path }])
+    }
+  }));
+  return files.flat()
+}
+
+async function getBucketFiles(client: S3Client, Bucket: string): Promise<string[]> {
+  const files = [];
+  let done = false;
+  let cmd = new ListObjectsV2Command({ Bucket });
+  while (!done) {
+    const resp = await client.send(cmd);
+    if (resp.$metadata.httpStatusCode != 200) {
+      // TODO: better error handling?
+      console.error(resp);
+      process.exit(1)
+    }
+
+    for (var item of resp.Contents!) {
+      files.push(item.Key!)
+    }
+
+    if (resp.NextContinuationToken) {
+      cmd = new ListObjectsV2Command({
+        Bucket,
+        ContinuationToken: resp.NextContinuationToken
+      })
+    } else {
+      done = true
+    }
+  }
+  return files
+}
+
+async function uploadFile(client: S3Client, Bucket: string, Key: string, Body: any) {
+  // use `path.posix` because `Key` is a path in a bucket that uses `/` as separator.
+  let ContentType = mime.getType(path.posix.extname(Key)) ?? undefined;
+  // add charset=utf-8 by default on text files (TODO: allow the user to override this)
+  if (ContentType && ContentType.startsWith("text/")) {
+    ContentType = ContentType + "; charset=utf-8";
+  }
+  const parallelUpload = new Upload({ client, params: { Bucket, Key, Body, ContentType } });
+  parallelUpload.on("httpUploadProgress", progress => {
+    process.stdout.moveCursor(0, -1)
+    process.stdout.clearLine(1)
+    process.stdout.write("Sending " + progress.Key);
+    if (! (progress.loaded == progress.total && progress.part == 1)) {
+      process.stdout.write(" (" + progress.loaded + "/" + progress.total + ")");
+    }
+    process.stdout.write("\n");
+  });
+  await parallelUpload.done();
+}
+
+async function deleteFiles(client: S3Client, Bucket: string, files: string[]): Promise<DeleteObjectsCommandOutput | null> {
+  if (files.length == 0) {
+    return null
+  }
+  return await client.send(new DeleteObjectsCommand({
+    Bucket,
+    Delete: {
+      Objects: files.map(f => { return { Key: f }}),
+    },
+  }));
+}
+
+export async function deploy(vhost: string, localFolder: string) {
+  const conf = await openApiConf();
+
+  // Get paths of the local files to deploy
+  const localFiles = await getLocalFiles(localFolder, "").catch(err => {
+    if (err.errno = -2) {
+      console.error(`Error: directory '${localFolder}' does not exist`);
+    } else {
+      console.error(err);
+    }
+    process.exit(1)
+  });
+
+  // Get website info from guichet (bucket name and keys)
+  const api = new WebsiteApi(conf);
+  let vhostInfo = await api.getWebsite({ vhost }).catch(err => {
+    if (err.response.status == 404) {
+      console.error(`Error: website '${vhost}' does not exist`);
+    } else {
+      console.error(err);
+    }
+    process.exit(1)
+  });
+
+  // List the files currently stored in the bucket
+  // @FIXME this info could be returned by the guichet API
+  const s3client = new S3Client({
+    endpoint: "https://garage.deuxfleurs.fr",
+    region: "garage",
+    forcePathStyle: true,
+    credentials: {
+      accessKeyId: vhostInfo.accessKeyId!,
+      secretAccessKey: vhostInfo.secretAccessKey!,
+    },
+  });
+  const Bucket = vhostInfo.vhost!.name!;
+  const remoteFiles = await getBucketFiles(s3client, Bucket);
+
+  // Delete files that are present in the bucket but not locally.
+  // Do this before sending the new files to avoid hitting the size quota
+  // unnecessarily.
+  const resp = await deleteFiles(
+    s3client,
+    Bucket,
+    remoteFiles.filter(f => !localFiles.find(({ s3Path }) => s3Path == f))
+  );
+  if (resp && resp!.$metadata.httpStatusCode != 200) {
+    // TODO: better error handling?
+      console.error(resp);
+      process.exit(1)
+  }
+
+  // Control concurrence while uploading
+  await Pool
+   .for(localFiles)
+   .withConcurrency(6)
+   .process(({ localPath, s3Path }) => uploadFile(s3client, Bucket, s3Path,fs.createReadStream(localPath)));
+}

package/index.ts

@@ -0,0 +1,26 @@
+import { program } from "commander";
+import { login } from "./auth";
+import { deploy } from "./deploy";
+import { vhostsList } from "./vhosts";
+
+program
+  .name('dxfl')
+  .description('Deuxfleurs CLI tool')
+  .version('0.1.0');
+
+program.command('login')
+  .description('Link your Deuxfleurs account with this tool.')
+  .argument('<username>', 'your account username')
+  .action(login);
+
+program.command('list')
+  .description('List all your websites')
+  .action(vhostsList);
+
+program.command('deploy')
+  .description('Deploy your website')
+  .argument('<vhost>', 'selected vhost')
+  .argument('<local_folder>', 'your local folder')
+  .action(deploy)
+
+program.parse();

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "dxfl",
+  "version": "0.1.0",
+  "description": "",
+  "license": "EUPL-1.2",
+  "author": "Deuxfleurs Team <coucou@deuxfleurs.fr>",
+  "type": "commonjs",
+  "main": "bootstrap.js",
+  "bin": {
+    "dfl": "./bootstrap.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.750.0",
+    "@aws-sdk/lib-storage": "^3.750.0",
+    "@supercharge/promise-pool": "^3.2.0",
+    "@types/node": "^22.13.5",
+    "commander": "^13.1.0",
+    "guichet-sdk-ts": "git+https://git.deuxfleurs.fr/Deuxfleurs/guichet-sdk-ts",
+    "mime": "^4.0.6",
+    "read": "^4.1.0",
+    "tsx": "^4.19.3"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,111 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "rewriteRelativeImportExtensions": true,          /* Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "noUncheckedSideEffectImports": true,             /* Check side effect imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    // "outDir": "./",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "strictBuiltinIteratorReturn": true,              /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}

package/vhosts.ts

@@ -0,0 +1,9 @@
+import { Configuration, WebsiteApi } from "guichet-sdk-ts";
+import { openApiConf } from "./auth";
+
+export async function vhostsList() {
+  const conf = await openApiConf();
+  const web = new WebsiteApi(conf);
+  const wlist = await web.listWebsites();
+  wlist.vhosts?.forEach(v => console.log(v.name));
+}