dxfl 0.1.2 → 0.1.4

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,155 @@
+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 fs from "fs";
+import path from "path";
+import mime from "mime";
+import { WebsiteApi } from "guichet-sdk-ts";
+import { S3Client, ListObjectsV2Command, DeleteObjectsCommand, } 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 "").
+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 getBucketFiles(client, Bucket) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const files = [];
+        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);
+            }
+            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;
+    });
+}
+function uploadFile(client, Bucket, Key, Body) {
+    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";
+        }
+        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");
+        });
+        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 }; }),
+            },
+        }));
+    });
+}
+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(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
+        yield PromisePool
+            .for(localFiles)
+            .withConcurrency(6)
+            .process(({ localPath, s3Path }) => uploadFile(s3client, Bucket, s3Path, fs.createReadStream(localPath)));
+    });
+}

package/dist/index.js

@@ -0,0 +1,22 @@
+#!/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/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,16 +1,16 @@
 {
   "name": "dxfl",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "",
   "license": "EUPL-1.2",
   "author": "Deuxfleurs Team <coucou@deuxfleurs.fr>",
-  "type": "commonjs",
-  "main": "bootstrap.js",
+  "type": "module",
+  "main": "dist/main.js",
   "bin": {
-    "dxfl": "./bootstrap.js"
+    "dxfl": "./dist/index.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "prepare": "npx tsc"
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.750.0",
@@ -18,9 +18,9 @@
     "@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",
+    "guichet-sdk-ts": "^0.1.0",
     "mime": "^4.0.6",
     "read": "^4.1.0",
-    "tsx": "^4.19.3"
+    "typescript": "^5.7.3"
   }
 }

package/tsconfig.json

@@ -12,7 +12,7 @@
 
     /* 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. */
+    "lib": [ "es6" ],                                        /* 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. */
@@ -25,13 +25,15 @@
     // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
 
     /* Modules */
-    "module": "commonjs",                                /* Specify what module code is generated. */
+    "module": "nodenext",                                /* 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. */
+    //"moduleResolution": "node",                               /* 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'. */
+    "typeRoots": [
+      "node_modules/@types"
+    ],                                  /* 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. */
@@ -51,14 +53,14 @@
     // "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. */
+    "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. */
+    "outDir": "dist",                                      /* 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. */
@@ -107,5 +109,9 @@
     /* Completeness */
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
     "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
-  }
+  },
+  "exclude": [
+    "dist",
+    "node_modules"
+  ]
 }

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/bootstrap.js

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

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 { 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

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

@@ -1,9 +0,0 @@
-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));
-}