dxfl 0.1.7 → 0.1.8

package/dist/empty.js

@@ -0,0 +1,73 @@
+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";
+import { getBucket, getBucketFiles, deleteBucketFiles } from "./bucket.js";
+import { confirmationPrompt, formatBytesHuman, formatCount, sum, } from "./utils.js";
+function emptyMain(website, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (options.dryRun && options.yes) {
+            console.error("Error: options --yes and --dry-run cannot be passed at the same time");
+        }
+        process.stdout.write("Fetching the website configuration and metadata...\n");
+        const guichet = yield openApiConf();
+        const api = new WebsiteApi(guichet);
+        const bucket = yield getBucket(api, website);
+        const filesToDelete = [...(yield getBucketFiles(bucket))].map(([name, { size }]) => ({
+            name,
+            size,
+        }));
+        const sizeDeleted = sum(filesToDelete.map(f => { var _a; return (_a = f.size) !== null && _a !== void 0 ? _a : 0; }));
+        function formatFile(file) {
+            `${file.name} (${file.size ? formatBytesHuman(file.size) : "?B"})`;
+        }
+        // If --dry-run: display the changes list and summary and return
+        if (options.dryRun) {
+            for (const file of filesToDelete) {
+                process.stdout.write(`Delete ${formatFile(file)}\n`);
+            }
+            process.stdout.write("\nSummary:\n");
+            process.stdout.write(`${formatCount(filesToDelete.length, "file")} deleted (${formatBytesHuman(sizeDeleted)})\n`);
+            return;
+        }
+        // If not --yes: display the summary, ask for confirmation before proceeding
+        if (!options.yes) {
+            process.stdout.write(`${formatCount(filesToDelete.length, "file")} (${formatBytesHuman(sizeDeleted)}) are going to be deleted:\n`);
+            const ok = yield confirmationPrompt(() => {
+                process.stdout.write("Files to delete:\n");
+                for (const file of filesToDelete) {
+                    process.stdout.write(`  ${formatFile(file)}\n`);
+                }
+            });
+            if (!ok) {
+                return;
+            }
+        }
+        // If confirmed
+        yield deleteBucketFiles(bucket, filesToDelete);
+    });
+}
+export function empty(website, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield emptyMain(website, options);
+        }
+        catch (err) {
+            if (typeof err == "string" || (err === null || err === void 0 ? void 0 : err.name) === "AbortError") {
+                console.error(`Error: ${err}`);
+            }
+            else {
+                console.error("Error:");
+                console.error(err);
+            }
+            process.exit(1);
+        }
+    });
+}

package/dist/index.js

@@ -1,23 +1,32 @@
 #!/usr/bin/env node
-import { program } from "commander";
+import { program } from "@commander-js/extra-typings";
 import { login } from "./auth.js";
 import { deploy } from "./deploy.js";
+import { empty } from "./empty.js";
 import { vhostsList } from "./vhosts.js";
+program.name("dxfl").description("Deuxfleurs CLI tool").version("0.1.8");
 program
-    .name('dxfl')
-    .description('Deuxfleurs CLI tool')
-    .version('0.1.7');
-program.command('login')
-    .description('Link your Deuxfleurs account with this tool.')
-    .argument('<username>', 'your account username')
+    .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')
+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')
-    .option('-n, --dry-run', 'do a trial run without making actual changes')
+program
+    .command("deploy")
+    .description("Deploy your website")
+    .argument("<website>", "selected website")
+    .argument("<local_folder>", "your local folder")
+    .option("-n, --dry-run", "do a trial run without making actual changes")
+    .option("-y, --yes", "apply the changes without asking for confirmation")
     .action(deploy);
+program
+    .command("empty")
+    .description("Empty your website from its contents")
+    .argument("<website>", "selected website")
+    .option("-n, --dry-run", "do a trial run without making actual changes")
+    .option("-y, --yes", "apply the changes without asking for confirmation")
+    .action(empty);
 program.parse();

package/dist/utils.js

@@ -0,0 +1,113 @@
+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 crypto from "crypto";
+import { stdin, stdout } from "process";
+import readline from "readline/promises";
+export 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");
+    });
+}
+export function formatBytesHuman(bytes) {
+    if (bytes < 1000) {
+        return `${bytes}B`;
+    }
+    bytes /= 1000;
+    if (bytes < 1000) {
+        return `${bytes.toFixed(2)}KB`;
+    }
+    bytes /= 1000;
+    if (bytes < 1000) {
+        return `${bytes.toFixed(2)}MB`;
+    }
+    bytes /= 1000;
+    return `${bytes.toFixed(2)}GB`;
+}
+export function toChunks(a, chunkSize) {
+    let chunks = [];
+    let i = 0;
+    while (i < a.length) {
+        chunks.push(a.slice(i, i + chunkSize));
+        i = i + chunkSize;
+    }
+    return chunks;
+}
+export function sum(a) {
+    return a.reduce((x, y) => x + y, 0);
+}
+export function formatCount(nb, thing) {
+    if (nb == 1) {
+        return `${nb} ${thing}`;
+    }
+    else {
+        return `${nb} ${thing}s`;
+    }
+}
+export function parseEtag(s) {
+    if (s.startsWith('"') && s.endsWith('"')) {
+        return s.slice(1, s.length - 1);
+    }
+    else {
+        return undefined;
+    }
+}
+export function confirmationPrompt(details) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const rl = readline.createInterface({ input: stdin, output: stdout });
+        let ok = true;
+        while (true) {
+            const a = yield rl.question(`Proceed? y (yes), n (no), d (details): `);
+            if (a == "y" || a == "yes") {
+                break;
+            }
+            else if (a == "n" || a == "no") {
+                ok = false;
+                break;
+            }
+            else if (a == "d" || a == "details") {
+                details();
+                process.stdout.write("\n");
+            }
+        }
+        rl.close();
+        return ok;
+    });
+}
+export function filterMap(a, f) {
+    return a.flatMap(x => {
+        let y = f(x);
+        return y ? [y] : [];
+    });
+}

package/dist/website_config.js

@@ -0,0 +1,410 @@
+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 TOML from "smol-toml";
+import URI from "fast-uri";
+import { z as zod } from "zod";
+import { fromError as zodError } from "zod-validation-error";
+import { GetBucketWebsiteCommand, PutBucketWebsiteCommand, } from "@aws-sdk/client-s3";
+import { getBucketFilesDetails } from "./bucket.js";
+////////////// Utilities
+export function equalBucketRedirect(b1, b2) {
+    function equalTo(x, y) {
+        if (x.kind == "replace_prefix" && y.kind == "replace_prefix") {
+            return x.prefix === y.prefix;
+        }
+        else if (x.kind == "replace" && y.kind == "replace") {
+            return x.target === y.target;
+        }
+        else {
+            return false;
+        }
+    }
+    return (b1.prefix === b2.prefix &&
+        b1.if_error === b2.if_error &&
+        b1.hostname === b2.hostname &&
+        b1.status === b2.status &&
+        b1.protocol === b2.protocol &&
+        equalTo(b1.to, b2.to));
+}
+////////////// Parsing from a TOML config file
+// Parsing: TOML -> untyped object
+function readConfigFileObject(filename) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!fs.existsSync(filename)) {
+            return {};
+        }
+        let strConf;
+        let dictConf;
+        try {
+            strConf = yield fs.promises.readFile(filename, { encoding: "utf8" });
+        }
+        catch (err) {
+            console.error(err, `\n\nUnable to read ${filename}`);
+            process.exit(1);
+        }
+        try {
+            dictConf = TOML.parse(strConf);
+        }
+        catch (err) {
+            console.error(err, `\n\nUnable to parse ${filename} as TOML, please check it for syntax errors.`);
+            process.exit(1);
+        }
+        return dictConf;
+    });
+}
+// Parsing: untyped object -> RawConfig
+const RawRedirectSchema = zod.object({
+    from: zod.string(),
+    to: zod.string(),
+    if_error: zod.number().int().optional(),
+    status: zod.number().int().positive().optional(),
+});
+const RawConfigSchema = zod.object({
+    index_page: zod.string().optional(),
+    error_page: zod.string().optional(),
+    redirects: zod.array(RawRedirectSchema).optional(),
+});
+function interpRawConfig(cfg) {
+    try {
+        return RawConfigSchema.parse(cfg);
+    }
+    catch (err) {
+        const validationError = zodError(err);
+        throw validationError.toString();
+    }
+}
+// Parsing: RawConfig -> WebsiteConfig
+// Parses the escaping scheme used for 'from' and 'to' paths
+// in redirects. These fields may specify a '*' at the end
+// (in that case they indicate a prefix) or not (then they are
+// absolute URLs.
+// Occurences of '*' that are part of the path itself must be
+// doubled as '**' in order to avoid any ambiguity.
+function unescape(s) {
+    let out = "";
+    const iter = s[Symbol.iterator]();
+    while (true) {
+        const elt = iter.next();
+        if (elt.done == true) {
+            return { s: out, is_prefix: false };
+        }
+        if (elt.value == "*") {
+            const next = iter.next();
+            if (next.done == true) {
+                return { s: out, is_prefix: true };
+            }
+            else if (next.value == "*") {
+                out += "*";
+            }
+            else {
+                throw `a single '*' is only allowed at the end for wildcards; please use '**' instead`;
+            }
+        }
+        else {
+            out += elt.value;
+        }
+    }
+}
+function interpConfig(rawcfg) {
+    var _a, _b;
+    function interpPath(name, str) {
+        try {
+            return unescape(str);
+        }
+        catch (err) {
+            throw `${name}: ${err}`;
+        }
+    }
+    function interpRedirect(i, r) {
+        var _a;
+        const rfrom = interpPath(`Redirect ${i}, from`, r.from);
+        const rto = interpPath(`Redirect ${i}, to`, r.to);
+        let redirect;
+        if (rfrom.is_prefix) {
+            // This is a bucket redirect
+            const toURI = URI.parse(rto.s);
+            if (toURI.error) {
+                throw `Redirect ${i}, 'to': ${toURI.error}`;
+            }
+            if (toURI.scheme && toURI.scheme != "http" && toURI.scheme != "https") {
+                throw `Redirect ${i}, 'to': unsupported URI scheme ${toURI.scheme}; http or https required`;
+            }
+            if (toURI.port) {
+                throw `Redirect ${i}, 'to': specifying a port is not supported`;
+            }
+            if (toURI.query) {
+                throw `Redirect ${i}, 'to': specifying a query is not supported`;
+            }
+            if (toURI.fragment) {
+                throw `Redirect ${i}, 'to': specifying a fragment is not supported`;
+            }
+            let path = (_a = toURI.path) !== null && _a !== void 0 ? _a : "";
+            // - In case of an absolute URL e.g. `https://foo.net/abc`, toURI.path will
+            // be equal to `/abc`, leading to redirect URLs with a double slash e.g.
+            // `https://foo.net//abc`. This works but removing the extra / in nicer.
+            // - In case of a "relative" URL e.g. `/abc`, setting this as redirect
+            // will result in garage sending `//abc` as redirect, which does not
+            // result in a working relative path. So we remove the extra / in this
+            // case as well.
+            if (path.startsWith("/")) {
+                path = path.substring(1);
+            }
+            // Similarly, if the user used `from = "/a*"` they likely meant to ask for
+            // `from = "a*"`, so we remove a level of `/` here as well. Otherwise,
+            // the redirect would only match for queries with double slashes, e.g.
+            // `https://foo.net//a`.
+            let prefix = rfrom.s;
+            if (prefix.startsWith("/")) {
+                prefix = prefix.substring(1);
+            }
+            let bredirect = {
+                prefix,
+                if_error: undefined,
+                hostname: toURI.host,
+                protocol: toURI.scheme,
+                // Unless specified, set the status to 302.
+                // Garage returns status=302 when reading back a bucket redirection
+                // that was written with status=undefined, and we want to be able to
+                // read back the same redirect as we wrote to be able to properly
+                // detect changes.
+                status: 302,
+                to: rto.is_prefix
+                    ? { kind: "replace_prefix", prefix: path }
+                    : { kind: "replace", target: path },
+            };
+            if (r.if_error) {
+                if (r.if_error != 404) {
+                    throw `Redirect ${i}: the only currently supported value for 'if_error' is 404`;
+                }
+                bredirect.if_error = 404;
+            }
+            if (r.status) {
+                if ([301, 302, 303, 307, 308].includes(r.status)) {
+                    bredirect.status = r.status;
+                }
+                else if ([200, 404].includes(r.status)) {
+                    if (toURI.host || toURI.scheme) {
+                        throw `Redirect ${i}: a status of 200 or 404 is not accepted while specifying a protocol and hostname in the destination`;
+                    }
+                    bredirect.status = r.status;
+                }
+                else {
+                    throw `Redirect ${i}: unsupported status code ${r.status}`;
+                }
+            }
+            redirect = { kind: "bucket", r: bredirect };
+        }
+        else {
+            // This is an object redirect
+            if (r.if_error) {
+                throw `Redirect ${i}: 'if_error' is not supported for single redirections`;
+            }
+            if (r.status) {
+                throw (`Redirect ${i}: 'status' is not supported for single redirections.\n` +
+                    "All single redirections have status code 301.");
+            }
+            if (rto.is_prefix) {
+                throw `Redirect ${i}: cannot use a prefix target in 'to' when 'from' is a single address`;
+            }
+            // if 'from' starts with a /, consider that the user meant to refer to an object
+            // at the root of the bucket and not an object with "/" in its name. Thus we should
+            // remove the /.
+            let from = rfrom.s;
+            if (from.startsWith("/")) {
+                from = from.substring(1);
+            }
+            // for the 'to' field, garage expects a target that starts with 'http://', 'https://'
+            // or '/'. So if the 'to' field does not start with '/', add one...
+            let to = rto.s;
+            if (!(to.startsWith("http://") ||
+                to.startsWith("https://") ||
+                to.startsWith("/"))) {
+                to = "/".concat(to);
+            }
+            redirect = { kind: "object", from, to };
+        }
+        return redirect;
+    }
+    let cfg = {
+        // use index.html as default index if not specified explicitly
+        index_page: (_a = rawcfg.index_page) !== null && _a !== void 0 ? _a : "index.html",
+        error_page: rawcfg.error_page,
+        bucket_redirects: [],
+        object_redirects: new Map(),
+    };
+    for (const [i, raw] of ((_b = rawcfg.redirects) !== null && _b !== void 0 ? _b : []).entries()) {
+        // `i+1` is only used for display: start counting redirects from 1 instead of 0
+        const r = interpRedirect(i + 1, raw);
+        if (r.kind == "bucket") {
+            cfg.bucket_redirects.push(r.r);
+        }
+        else {
+            if (cfg.object_redirects.has(r.from)) {
+                throw `Cannot have two redirects from the same path ${r.from}`;
+            }
+            cfg.object_redirects.set(r.from, r.to);
+        }
+    }
+    return cfg;
+}
+export function readConfigFile(filename) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return interpConfig(interpRawConfig(yield readConfigFileObject(filename)));
+    });
+}
+////////////// Reading from a S3 bucket
+export function getBucketConfig(bucket, files) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // This function performs the following S3 requests:
+        // - GetBucketWebsite to get bucket-level redirects;
+        // - A Head command for each file in the bucket to collect object redirects.
+        //   (This can become relatively slow for buckets with thousands of files,
+        //    but I don't know of a better way.)
+        var _a, _b;
+        const [response, details] = yield Promise.all([
+            bucket.client.send(new GetBucketWebsiteCommand({ Bucket: bucket.name })),
+            getBucketFilesDetails(bucket, files),
+        ]);
+        if (response && response.$metadata.httpStatusCode != 200) {
+            throw `Error sending GetBucketWebsite: ${response}`;
+        }
+        // Collect object redirects
+        const object_redirects = new Map();
+        for (const [file, { redirect }] of details) {
+            if (redirect) {
+                object_redirects.set(file, redirect);
+            }
+        }
+        // Interpret bucket redirects
+        if (response.RedirectAllRequestsTo) {
+            // NB: garage does not currently support RedirectAllRequestsTo so this should never happen
+            throw (`remote website configuration: RedirectAllRequestsTo is specified; ` +
+                `this is currently unsupported by dxfl`);
+        }
+        const index_page = (_a = response.IndexDocument) === null || _a === void 0 ? void 0 : _a.Suffix;
+        const error_page = (_b = response.ErrorDocument) === null || _b === void 0 ? void 0 : _b.Key;
+        let bucket_redirects = [];
+        if (response.RoutingRules) {
+            for (const rule of response.RoutingRules) {
+                // If no Condition is specified, then the redirect always applies, which is equivalent
+                // to matching on an empty prefix
+                let prefix = "";
+                let if_error = undefined;
+                if (rule.Condition) {
+                    if (rule.Condition.HttpErrorCodeReturnedEquals) {
+                        if (rule.Condition.HttpErrorCodeReturnedEquals == "404") {
+                            if_error = 404;
+                        }
+                        else {
+                            // currently not supported by garage
+                            throw (`remote website configuration: 'if_error' specified with a different ` +
+                                `status code than 404; this is currently unsupported by dxfl`);
+                        }
+                    }
+                    if (rule.Condition.KeyPrefixEquals) {
+                        prefix = rule.Condition.KeyPrefixEquals;
+                    }
+                }
+                const hostname = rule.Redirect.HostName;
+                const status = rule.Redirect.HttpRedirectCode
+                    ? parseInt(rule.Redirect.HttpRedirectCode)
+                    : undefined;
+                let protocol = undefined;
+                if (rule.Redirect.Protocol) {
+                    if (rule.Redirect.Protocol == "http" ||
+                        rule.Redirect.Protocol == "https") {
+                        protocol = rule.Redirect.Protocol;
+                    }
+                    else {
+                        // currently not supported by garage
+                        throw (`remote website configuration: 'protocol' is neither http or https; ` +
+                            `this is currently unsupported by dxfl`);
+                    }
+                }
+                let to;
+                if (rule.Redirect.ReplaceKeyPrefixWith) {
+                    to = {
+                        kind: "replace_prefix",
+                        prefix: rule.Redirect.ReplaceKeyPrefixWith,
+                    };
+                }
+                else if (rule.Redirect.ReplaceKeyWith) {
+                    to = { kind: "replace", target: rule.Redirect.ReplaceKeyWith };
+                }
+                else {
+                    // not completely sure whether this is the correct behavior, but it should
+                    // match garage's implementation
+                    to = { kind: "replace", target: "" };
+                }
+                bucket_redirects.push({
+                    prefix,
+                    if_error,
+                    hostname,
+                    status,
+                    protocol,
+                    to,
+                });
+            }
+        }
+        return { index_page, error_page, bucket_redirects, object_redirects };
+    });
+}
+////////////// Applying a configuration to S3
+// applies the bucket-wide part of the website configuration
+export function putBucketWebsiteConfig(bucket, index_page, error_page, bucket_redirects) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // TODO: printing to show what changes are being applied?
+        const WebsiteConfiguration = {};
+        if (error_page) {
+            WebsiteConfiguration.ErrorDocument = { Key: error_page };
+        }
+        if (index_page) {
+            WebsiteConfiguration.IndexDocument = { Suffix: index_page };
+        }
+        if (bucket_redirects.length > 0) {
+            WebsiteConfiguration.RoutingRules = [];
+            for (const r of bucket_redirects) {
+                const rule = {
+                    Condition: {
+                        KeyPrefixEquals: r.prefix,
+                    },
+                    Redirect: {},
+                };
+                if (r.if_error) {
+                    rule.Condition.HttpErrorCodeReturnedEquals = r.if_error.toString();
+                }
+                if (r.hostname) {
+                    rule.Redirect.HostName = r.hostname;
+                }
+                if (r.status) {
+                    rule.Redirect.HttpRedirectCode = r.status;
+                }
+                if (r.protocol) {
+                    rule.Redirect.Protocol = r.protocol;
+                }
+                if (r.to.kind == "replace_prefix") {
+                    rule.Redirect.ReplaceKeyPrefixWith = r.to.prefix;
+                }
+                else if (r.to.kind == "replace") {
+                    rule.Redirect.ReplaceKeyWith = r.to.target;
+                }
+                WebsiteConfiguration.RoutingRules.push(rule);
+            }
+        }
+        const resp = yield bucket.client.send(new PutBucketWebsiteCommand({
+            Bucket: bucket.name,
+            WebsiteConfiguration,
+        }));
+        if (resp && resp.$metadata.httpStatusCode != 200) {
+            throw resp;
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dxfl",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "",
   "license": "EUPL-1.2",
   "author": "Deuxfleurs Team <coucou@deuxfleurs.fr>",
@@ -10,17 +10,28 @@
     "dxfl": "dist/index.js"
   },
   "scripts": {
-    "prepare": "npx tsc"
+    "prepare": "npx tsc",
+    "prettier": "npx prettier . --write",
+    "prettier-watch": "npx -y onchange \"**/*\" -- npx prettier --write --ignore-unknown {{changed}}",
+    "prettier-check": "npx prettier . --check"
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.750.0",
-    "@aws-sdk/lib-storage": "^3.750.0",
+    "@commander-js/extra-typings": "^13.1.0",
     "@supercharge/promise-pool": "^3.2.0",
     "@types/node": "^22.13.5",
     "commander": "^13.1.0",
+    "fast-uri": "^3.0.6",
     "guichet-sdk-ts": "^0.1.0",
     "mime": "^4.0.6",
     "read": "^4.1.0",
-    "typescript": "^5.7.3"
+    "smol-toml": "^1.3.4",
+    "typescript": "^5.7.3",
+    "zod": "^3.24.4",
+    "zod-validation-error": "^3.4.1"
+  },
+  "devDependencies": {
+    "onchange": "^7.1.0",
+    "prettier": "3.5.3"
   }
 }