dxfl 0.1.3 → 0.1.5

package/README.md

@@ -4,18 +4,10 @@ A CLI tool to manage your Deuxfleurs account.
 
 ## Install
 
-From NPM:
-
 ```
 npm install -g dxfl
 ```
 
-From git:
-
-```
-npm install -g git+https://git.deuxfleurs.fr/Deuxfleurs/dxfl
-```
-
 ## Usage
 
 *Not ready*
@@ -44,7 +36,24 @@ dxfl deploy example.com _public
 git clone https://git.deuxfleurs.fr/Deuxfleurs/dxfl
 cd dxfl
 npm install
-node bootstrap.js
+npm link
+dxfl
+```
+
+## Release
+
+First you need an account on npmjs.com and be a maintainer of the `dxfl` package (ask quentin).
+Do not forget also to run `npm login` to bind your account with the CLI.
+
+Then to publish a release:
+
+```bash
+vim package.json # update the version in this file
+git commit -a -m 'set version 0.1.5' # commit your change
+git push # send update
+git tag -m 'v0.1.5' v0.1.5 # create associated tag
+git push --tags # push tag
+npm publish # build and push the package
 ```
 
 ## License

package/dist/auth.js

@@ -0,0 +1,81 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Configuration, WebsiteApi } from "guichet-sdk-ts";
+import { read } from 'read';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+function configPath() {
+    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;
+}
+export function openApiConf() {
+    return __awaiter(this, void 0, void 0, function* () {
+        let strConf;
+        let dictConf;
+        const configFile = configPath();
+        try {
+            strConf = yield 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 function login(username) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const password = yield read({
+            prompt: "password: ",
+            silent: true,
+            replace: "*"
+        });
+        // check config
+        const testConf = new Configuration({
+            username: username,
+            password: password,
+        });
+        const web = new WebsiteApi(testConf);
+        try {
+            yield 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);
+        yield fs.mkdir(parent, { recursive: true });
+        // create, serialize, save config data
+        const configData = { username, password };
+        const serializedConfig = JSON.stringify(configData);
+        yield 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/dist/deploy.js

@@ -0,0 +1,236 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+import mime from "mime";
+import { WebsiteApi } from "guichet-sdk-ts";
+import { S3Client, ListObjectsV2Command, DeleteObjectsCommand, HeadObjectCommand, } from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+import { PromisePool } from "@supercharge/promise-pool";
+import { openApiConf } from "./auth.js";
+const MD5METAFIELD = "dfl-md5sum";
+// 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 "").
+function getLocalFiles(dir, s3Prefix) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const entries = yield fs.promises.readdir(dir, { withFileTypes: true });
+        const files = yield 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();
+    });
+}
+function getFileMd5(file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, e_1, _b, _c;
+        const hash = crypto.createHash('md5');
+        try {
+            for (var _d = true, _e = __asyncValues(fs.createReadStream(file)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const chunk = _c;
+                hash.update(chunk);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return hash.digest('hex');
+    });
+}
+function getBucketFiles(client, Bucket) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const files = new Map();
+        let done = false;
+        let cmd = new ListObjectsV2Command({ Bucket });
+        while (!done) {
+            const resp = yield client.send(cmd);
+            if (resp.$metadata.httpStatusCode != 200) {
+                // TODO: better error handling?
+                console.error(resp);
+                process.exit(1);
+            }
+            if (resp.Contents) {
+                for (const item of resp.Contents) {
+                    if (item.Key) {
+                        files.set(item.Key, { size: item.Size });
+                    }
+                }
+            }
+            if (resp.NextContinuationToken) {
+                cmd = new ListObjectsV2Command({
+                    Bucket,
+                    ContinuationToken: resp.NextContinuationToken
+                });
+            }
+            else {
+                done = true;
+            }
+        }
+        return files;
+    });
+}
+function uploadFile(client, Bucket, Key, Body, md5) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        // use `path.posix` because `Key` is a path in a bucket that uses `/` as separator.
+        let ContentType = (_a = mime.getType(path.posix.extname(Key))) !== null && _a !== void 0 ? _a : 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";
+        }
+        // store the md5 checksum in the object metadata; it will be used to skip
+        // subsequent uploads if the file has not changed.
+        const Metadata = { [MD5METAFIELD]: md5 };
+        const params = { Bucket, Key, Body, ContentType, Metadata };
+        const parallelUpload = new Upload({ client, params });
+        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");
+        });
+        yield parallelUpload.done();
+    });
+}
+function deleteFiles(client, Bucket, files) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (files.length == 0) {
+            return null;
+        }
+        return yield client.send(new DeleteObjectsCommand({
+            Bucket,
+            Delete: {
+                Objects: files.map(f => { return { Key: f }; }),
+            },
+        }));
+    });
+}
+// Checks whether a remote file needs to be updated by its local copy.
+//
+// We first check whether files differ, and if not compare the md5 checksum we
+// previously stored in the object metadata (if it exists) with the local file's
+// md5 checksum.
+function needsUpdate(client, localFile, localMd5, Bucket, Key, remoteSize) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (remoteSize) {
+            const localSize = (yield fs.promises.stat(localFile)).size;
+            if (localSize == 0 /* stat can return 0 in case of error */
+                || localSize != remoteSize) {
+                return true;
+            }
+        }
+        // fetch metadata for the object and see if we previously stored its md5
+        const resp = yield client.send(new HeadObjectCommand({ Bucket, Key }));
+        if (resp.$metadata.httpStatusCode != 200) {
+            // TODO: better error handling?
+            throw resp;
+        }
+        const remoteMd5 = resp.Metadata ? resp.Metadata[MD5METAFIELD] : null;
+        if (!remoteMd5) {
+            return true;
+        }
+        // we have a remote md5, compare it with the local one
+        return (localMd5 != remoteMd5);
+    });
+}
+export function deploy(vhost, localFolder) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const conf = yield openApiConf();
+        // Get paths of the local files to deploy
+        const localFiles = yield 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 = yield 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 = yield 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 = yield deleteFiles(s3client, Bucket, [...remoteFiles]
+            .filter(([name, _]) => !localFiles.find(({ s3Path }) => s3Path == name))
+            .map(([name, _]) => name));
+        if (resp && resp.$metadata.httpStatusCode != 200) {
+            // TODO: better error handling?
+            console.error(resp);
+            process.exit(1);
+        }
+        // Uploads a local file unless the remote copy is the same
+        function processFile(localPath, s3Path) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const localMd5 = yield getFileMd5(localPath);
+                const remoteFile = remoteFiles.get(s3Path);
+                if (!remoteFile ||
+                    (yield needsUpdate(s3client, localPath, localMd5, Bucket, s3Path, remoteFile.size))) {
+                    uploadFile(s3client, Bucket, s3Path, fs.createReadStream(localPath), localMd5);
+                }
+            });
+        }
+        ;
+        // Control concurrency while uploading
+        yield PromisePool
+            .for(localFiles)
+            .withConcurrency(6)
+            .process(({ localPath, s3Path }) => processFile(localPath, s3Path));
+    });
+}

package/dist/vhosts.js

@@ -0,0 +1,20 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { WebsiteApi } from "guichet-sdk-ts";
+import { openApiConf } from "./auth.js";
+export function vhostsList() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const conf = yield openApiConf();
+        const web = new WebsiteApi(conf);
+        const wlist = yield web.listWebsites();
+        (_a = wlist.vhosts) === null || _a === void 0 ? void 0 : _a.forEach(v => console.log(v.name));
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dxfl",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "",
   "license": "EUPL-1.2",
   "author": "Deuxfleurs Team <coucou@deuxfleurs.fr>",

package/auth.ts

@@ -1,81 +0,0 @@
-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/deploy.ts

@@ -1,152 +0,0 @@
-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 { PromisePool } from "@supercharge/promise-pool";
-import { openApiConf } from "./auth.js";
-
-// 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 PromisePool
-   .for(localFiles)
-   .withConcurrency(6)
-   .process(({ localPath, s3Path }) => uploadFile(s3client, Bucket, s3Path,fs.createReadStream(localPath)));
-}

package/dist/auth.d.ts

@@ -1,3 +0,0 @@
-import { Configuration } from "guichet-sdk-ts";
-export declare function openApiConf(): Promise<Configuration>;
-export declare function login(username: string): Promise<void>;

package/dist/deploy.d.ts

@@ -1 +0,0 @@
-export declare function deploy(vhost: string, localFolder: string): Promise<void>;

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/vhosts.d.ts

@@ -1 +0,0 @@
-export declare function vhostsList(): Promise<void>;

package/index.ts

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-import { program } from "commander";
-import { login } from "./auth.js";
-import { deploy } from "./deploy.js";
-import { vhostsList } from "./vhosts.js";
-
-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/vhosts.ts

@@ -1,9 +0,0 @@
-import { Configuration, WebsiteApi } from "guichet-sdk-ts";
-import { openApiConf } from "./auth.js";
-
-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));
-}