@itwin/workspace-editor 3.3.0-dev.4 → 3.3.0-dev.42

package/lib/WorkspaceEditor.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
@@ -11,69 +12,152 @@ const readline = require("readline");
 const Yargs = require("yargs");
 const core_backend_1 = require("@itwin/core-backend");
 const core_bentley_1 = require("@itwin/core-bentley");
+const core_common_1 = require("@itwin/core-common");
+// cspell:ignore nodir nocase
+/* eslint-disable id-blacklist,no-console */
+/** Currently executing an "@" script? */
+let inScript = false;
+let logTimer;
+async function askQuestion(query) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => rl.question(query, (ans) => { rl.close(); resolve(ans); }));
+}
+function flushLog() {
+    core_backend_1.IModelHost.platform.flushLog();
+}
+/** show a message, potentially flushing log messages first */
+function showMessage(msg) {
+    if (logTimer)
+        flushLog();
+    console.log(msg);
+}
+/** perform a vacuum on a database, with a message while it's happening */
+function doVacuum(fileName, cloudContainer) {
+    process.stdout.write(`Vacuuming ${fileName} ... `);
+    core_backend_1.IModelHost.platform.DgnDb.vacuum(fileName, cloudContainer);
+    process.stdout.write("done");
+    showMessage("");
+}
+/** Convert a file size byte value to a friendly string, rounding to nearest integer for K, M, G, T */
+function friendlyFileSize(size) {
+    if (size < 1024)
+        return `${size}`; // less than 1K, just show number of bytes with no units
+    const units = Math.floor(Math.log(size) / Math.log(1024));
+    return `${Math.round(size / Math.pow(1024, units))}${["", "K", "M", "G", "T"][units]}`;
+}
 /** Create a new empty WorkspaceDb  */
 async function createWorkspaceDb(args) {
-    const wsFile = new core_backend_1.EditableWorkspaceDb(args.dbName, core_backend_1.IModelHost.appWorkspace.getContainer(args));
-    wsFile.create();
-    console.log(`created WorkspaceDb ${wsFile.sqliteDb.nativeDb.getFilePath()}`);
-    wsFile.close();
+    args.writeable = true;
+    const wsFile = new core_backend_1.EditableWorkspaceDb(args, core_backend_1.IModelHost.appWorkspace.getContainer(args, args));
+    await wsFile.createDb();
+    showMessage(`created WorkspaceDb ${wsFile.sqliteDb.nativeDb.getFilePath()}`);
+    await wsFile.close();
 }
 /** open, call a function to process, then close a WorkspaceDb */
-function processWorkspace(args, ws, fn) {
+async function processWorkspace(args, ws, fn) {
     ws.open();
-    console.log(`WorkspaceDb [${ws.sqliteDb.nativeDb.getFilePath()}]`);
+    showMessage(`WorkspaceDb [${ws.sqliteDb.nativeDb.getFilePath()}]`);
     try {
-        fn(ws, args);
+        await fn(ws, args);
     }
     finally {
-        ws.close();
+        await ws.close();
     }
 }
+/** get a WorkspaceContainer that may or may not be a cloud container. */
+function getContainer(args) {
+    args.writeable = true;
+    return core_backend_1.IModelHost.appWorkspace.getContainer(args, args);
+}
+/** get a WorkspaceContainer that is expected to be a cloud container, throw otherwise. */
+function getCloudContainer(args) {
+    args.syncOnConnect = true;
+    const container = getContainer(args);
+    const cloudContainer = container.cloudContainer;
+    if (!cloudContainer || !cloudContainer.isConnected)
+        throw new Error("no cloud container");
+    return cloudContainer;
+}
+function fixVersionArg(args) {
+    var _a;
+    const dbParts = core_backend_1.ITwinWorkspaceContainer.parseDbFileName(args.dbName);
+    args.dbName = dbParts.dbName;
+    args.version = (_a = args.version) !== null && _a !== void 0 ? _a : dbParts.version;
+    args.dbFileName = core_backend_1.ITwinWorkspaceContainer.makeDbFileName(dbParts.dbName, dbParts.version);
+}
 /** Open for write, call a function to process, then close a WorkspaceDb */
-function editWorkspace(args, fn) {
-    processWorkspace(args, new core_backend_1.EditableWorkspaceDb(args.dbName, core_backend_1.IModelHost.appWorkspace.getContainer(args)), fn);
+async function editWorkspace(args, fn) {
+    var _a;
+    fixVersionArg(args);
+    const ws = new core_backend_1.EditableWorkspaceDb(args, getContainer(args));
+    const cloudContainer = ws.container.cloudContainer;
+    if (cloudContainer && ((_a = cloudContainer.queryDatabase(ws.dbFileName)) === null || _a === void 0 ? void 0 : _a.state) !== "copied")
+        throw new Error(`${args.dbFileName} is not editable. Create a new version first`);
+    await processWorkspace(args, ws, fn);
 }
 /** Open for read, call a function to process, then close a WorkspaceDb */
-function readWorkspace(args, fn) {
-    processWorkspace(args, new core_backend_1.ITwinWorkspaceDb(args.dbName, core_backend_1.IModelHost.appWorkspace.getContainer(args)), fn);
+async function readWorkspace(args, fn) {
+    fixVersionArg(args);
+    return processWorkspace(args, new core_backend_1.ITwinWorkspaceDb(args, getContainer(args)), fn);
 }
 /** List the contents of a WorkspaceDb */
 async function listWorkspaceDb(args) {
-    readWorkspace(args, (file, args) => {
+    await readWorkspace(args, async (file, args) => {
+        const cloudContainer = file.container.cloudContainer;
+        const timer = new core_bentley_1.StopWatch("list", true);
+        let prefetch;
+        if (args.prefetch && cloudContainer) {
+            console.log(`start prefetch`);
+            prefetch = file.prefetch({ nRequests: args.nRequests });
+        }
         if (!args.strings && !args.blobs && !args.files)
             args.blobs = args.files = args.strings = true;
+        const nameAndSize = (stmt, size, info) => showMessage(`  name=${stmt.getValueString(0)}, size=${friendlyFileSize(size !== null && size !== void 0 ? size : stmt.getValueInteger(1))}${info !== null && info !== void 0 ? info : ""}`);
         if (args.strings) {
-            console.log(" strings:");
-            file.sqliteDb.withSqliteStatement("SELECT id,value FROM strings", (stmt) => {
+            showMessage(" strings:");
+            file.sqliteDb.withSqliteStatement("SELECT id,LENGTH(value) FROM strings ORDER BY id COLLATE NOCASE", (stmt) => {
                 while (core_bentley_1.DbResult.BE_SQLITE_ROW === stmt.step())
-                    console.log(`  name=[${stmt.getValueString(0)}], size=${stmt.getValueString(1).length}`);
+                    nameAndSize(stmt);
             });
         }
         if (args.blobs) {
-            console.log(" blobs:");
-            file.sqliteDb.withSqliteStatement("SELECT id,value FROM blobs", (stmt) => {
+            showMessage(" blobs:");
+            file.sqliteDb.withSqliteStatement("SELECT id,LENGTH(value) FROM blobs ORDER BY id COLLATE NOCASE", (stmt) => {
                 while (core_bentley_1.DbResult.BE_SQLITE_ROW === stmt.step())
-                    console.log(`  name=[${stmt.getValueString(0)}], size=${stmt.getValueBlob(1).length}`);
+                    nameAndSize(stmt);
             });
         }
         if (args.files) {
-            console.log(" files:");
-            file.sqliteDb.withSqliteStatement("SELECT name FROM be_EmbedFile", (stmt) => {
+            showMessage(" files:");
+            file.sqliteDb.withSqliteStatement("SELECT name FROM be_EmbedFile ORDER BY name COLLATE NOCASE", (stmt) => {
                 while (core_bentley_1.DbResult.BE_SQLITE_ROW === stmt.step()) {
                     const embed = file.queryFileResource(stmt.getValueString(0));
                     if (embed) {
                         const info = embed.info;
                         const date = new Date(info.date);
-                        console.log(`  name=[${stmt.getValueString(0)}], size=${info.size}, ext="${info.fileExt}", date=${date.toString()}`);
+                        nameAndSize(stmt, info.size, `, ext="${info.fileExt}", date=${date.toString()}`);
                     }
                 }
             });
         }
+        if (prefetch) {
+            showMessage(`time = ${timer.elapsedSeconds.toString()}`);
+            // await askQuestion("press any key");
+            // const queryTimer = new StopWatch("list", true);
+            // showMessage(`start query`);
+            // file.sqliteDb.withSqliteStatement("SELECT id,value FROM blobs ORDER BY id COLLATE NOCASE", (stmt) => {
+            //   while (DbResult.BE_SQLITE_ROW === stmt.step()) {
+            //   }
+            // });
+            // showMessage(`done query, time= ${queryTimer.elapsedSeconds.toString()}`);
+            const done = await prefetch.promise;
+            showMessage(`prefetch time = ${timer.elapsedSeconds.toString()}, done=${done}`);
+        }
     });
 }
-/** Add or Update files into a WorkspaceDb. */
+/** Add files into a WorkspaceDb. */
 async function addResource(args) {
-    editWorkspace(args, (wsFile, args) => {
+    return editWorkspace(args, async (wsFile, args) => {
         var _a;
         glob.sync(args.files, { cwd: (_a = args.root) !== null && _a !== void 0 ? _a : process.cwd(), nodir: true }).forEach((filePath) => {
             var _a;
@@ -84,26 +168,56 @@ async function addResource(args) {
             try {
                 if (args.type === "string") {
                     const val = fs.readFileSync(file, "utf-8");
-                    wsFile[args.update ? "updateString" : "addString"](name, val);
+                    wsFile.addString(name, val);
                 }
                 else if (args.type === "blob") {
                     const val = fs.readFileSync(file);
-                    wsFile[args.update ? "updateBlob" : "addBlob"](name, val);
+                    wsFile.addBlob(name, val);
                 }
                 else {
-                    wsFile[args.update ? "updateFile" : "addFile"](name, file);
+                    wsFile.addFile(name, file);
                 }
-                console.log(` ${args.update ? "updated" : "added"} "${file}" as ${args.type} resource [${name}]`);
+                showMessage(` added "${file}" as ${args.type} resource [${name}]`);
             }
             catch (e) {
-                console.error(e.message);
+                console.error(core_common_1.IModelError.getErrorMessage(e));
+            }
+        });
+    });
+}
+/** Replace files in a WorkspaceDb. */
+async function replaceResource(args) {
+    return editWorkspace(args, async (wsFile, args) => {
+        var _a;
+        glob.sync(args.files, { cwd: (_a = args.root) !== null && _a !== void 0 ? _a : process.cwd(), nodir: true }).forEach((filePath) => {
+            var _a;
+            const file = args.root ? (0, path_1.join)(args.root, filePath) : filePath;
+            if (!core_backend_1.IModelJsFs.existsSync(file))
+                throw new Error(`file [${file}] does not exist`);
+            const name = (_a = args.rscName) !== null && _a !== void 0 ? _a : filePath;
+            try {
+                if (args.type === "string") {
+                    const val = fs.readFileSync(file, "utf-8");
+                    wsFile.updateString(name, val);
+                }
+                else if (args.type === "blob") {
+                    const val = fs.readFileSync(file);
+                    wsFile.updateBlob(name, val);
+                }
+                else {
+                    wsFile.updateFile(name, file);
+                }
+                showMessage(` updated "${file}" as ${args.type} resource [${name}]`);
+            }
+            catch (e) {
+                console.error(core_common_1.IModelError.getErrorMessage(e));
             }
         });
     });
 }
 /** Extract a single resource from a WorkspaceDb into a local file */
 async function extractResource(args) {
-    readWorkspace(args, (file, args) => {
+    return readWorkspace(args, async (file, args) => {
         const verify = (val) => {
             if (val === undefined)
                 throw new Error(` ${args.type} resource "${args.rscName}" does not exist`);
@@ -118,35 +232,35 @@ async function extractResource(args) {
         else {
             verify(file.getFile(args.rscName, args.fileName));
         }
-        console.log(` ${args.type} resource [${args.rscName}] extracted to "${args.fileName}"`);
+        showMessage(` ${args.type} resource [${args.rscName}] extracted to "${args.fileName}"`);
     });
 }
 /** Remove a single resource from a WorkspaceDb */
 async function removeResource(args) {
-    editWorkspace(args, (wsFile, args) => {
+    return editWorkspace(args, async (wsFile, args) => {
         if (args.type === "string")
             wsFile.removeString(args.rscName);
         else if (args.type === "blob")
             wsFile.removeBlob(args.rscName);
         else
             wsFile.removeFile(args.rscName);
-        console.log(` removed ${args.type} resource [${args.rscName}]`);
+        showMessage(` removed ${args.type} resource [${args.rscName}]`);
     });
 }
-function getDbFileName(args) {
-    return new core_backend_1.ITwinWorkspaceDb(args.dbName, core_backend_1.IModelHost.appWorkspace.getContainer(args)).localFile;
-}
-/** Vacuum a local WorkspaceDb file, usually immediately prior to uploading. */
+/** Vacuum a WorkspaceDb. */
 async function vacuumWorkspaceDb(args) {
-    const localFile = getDbFileName(args);
-    core_backend_1.IModelHost.platform.DgnDb.vacuum(localFile);
-    console.log(`${localFile} vacuumed`);
+    const container = getContainer(args);
+    fixVersionArg(args);
+    const localFile = new core_backend_1.ITwinWorkspaceDb(args, container).dbFileName;
+    doVacuum(localFile, container.cloudContainer);
 }
-/** Either upload or download a WorkspaceDb to/from a WorkspaceContainer. Shows progress % during transfer */
-async function performTransfer(direction, args) {
-    var _a;
-    const localFile = (_a = args.localFile) !== null && _a !== void 0 ? _a : getDbFileName(args);
-    const info = `${direction} ${localFile}, containerId=${args.containerId}, WorkspaceDbName=${args.dbName} : `;
+/** Either upload or download a WorkspaceDb to/from a cloud WorkspaceContainer. Shows progress % during transfer */
+async function performTransfer(container, direction, args) {
+    fixVersionArg(args);
+    const localFileName = args.localFileName;
+    if (direction === "upload" && !args.noVacuum)
+        doVacuum(localFileName);
+    const info = `${direction === "download" ? "export" : "import"} ${localFileName}, container=${args.containerId}, dbName=${args.dbFileName} : `;
     let last = 0;
     const onProgress = (loaded, total) => {
         if (loaded > last) {
@@ -159,125 +273,352 @@ async function performTransfer(direction, args) {
     };
     process.stdout.write(info);
     const timer = new core_bentley_1.StopWatch(direction, true);
-    await core_backend_1.CloudSqlite.transferDb(direction, { ...args, localFile, onProgress });
+    args.dbName = args.dbFileName;
+    await core_backend_1.CloudSqlite.transferDb(direction, container, { ...args, localFileName, onProgress });
     readline.cursorTo(process.stdout, info.length);
     process.stdout.write(`complete, ${timer.elapsedSeconds.toString()} seconds`);
+    showMessage("");
 }
-/** Upload a WorkspaceDb to a WorkspaceContainer. */
-async function uploadWorkspaceDb(args) {
-    if (args.initialize)
-        await core_backend_1.CloudSqlite.initializeContainer(args);
-    return performTransfer("upload", args);
+/** import a WorkspaceDb to a cloud WorkspaceContainer. */
+async function importWorkspaceDb(args) {
+    var _a;
+    const container = getCloudContainer(args);
+    if ("" === (0, path_1.extname)(args.localFileName))
+        args.localFileName = `${args.localFileName}.${core_backend_1.ITwinWorkspaceDb.fileExt}`;
+    if (!core_backend_1.IModelJsFs.existsSync(args.localFileName))
+        args.localFileName = (0, path_1.join)((_a = args.directory) !== null && _a !== void 0 ? _a : core_backend_1.IModelHost.appWorkspace.containerDir, args.localFileName);
+    await core_backend_1.CloudSqlite.withWriteLock(args.user, container, async () => {
+        await performTransfer(container, "upload", args);
+    });
+    container.checkForChanges(); // so we can see newly imported WorkspaceDb
 }
-/** Download a WorkspaceDb from a WorkspaceContainer. */
-async function downloadWorkspaceDb(args) {
-    return performTransfer("download", args);
+/** export a WorkspaceDb from a cloud WorkspaceContainer. */
+async function exportWorkspaceDb(args) {
+    if (!(0, path_1.extname)(args.localFileName))
+        args.localFileName = `${args.localFileName}.${core_backend_1.ITwinWorkspaceDb.fileExt}`;
+    const dbParts = core_backend_1.ITwinWorkspaceContainer.parseDbFileName(args.dbName);
+    if (!dbParts.version)
+        throw new Error("exportDb requires a version");
+    await performTransfer(getCloudContainer(args), "download", args);
 }
-/** Delete a WorkspaceDb from a WorkspaceContainer. */
+/** Delete a WorkspaceDb from a cloud WorkspaceContainer. */
 async function deleteWorkspaceDb(args) {
-    await core_backend_1.CloudSqlite.deleteDb(args);
-    console.log(`deleted WorkspaceDb [${args.dbName}] from containerId: ${args.containerId}`);
+    const container = getCloudContainer(args);
+    await core_backend_1.CloudSqlite.withWriteLock(args.user, container, async () => {
+        return container.deleteDatabase(args.dbName);
+    });
+    showMessage(`deleted WorkspaceDb [${args.dbName}] from ${sayContainer(args)}`);
+}
+function sayContainer(args) {
+    return `container [${args.containerId}]`;
+}
+/** initialize (empty if it exists) a cloud WorkspaceContainer. */
+async function initializeWorkspace(args) {
+    if (undefined === args.storageType || !args.accessName)
+        throw new Error("No cloud container supplied");
+    if (!args.noPrompt) {
+        const yesNo = await askQuestion(`Are you sure you want to initialize ${sayContainer(args)}"? [y/n]: `);
+        if (yesNo[0].toUpperCase() !== "Y")
+            return;
+    }
+    const container = new core_backend_1.IModelHost.platform.CloudContainer(args);
+    container.initializeContainer({ checksumBlockNames: true });
+    showMessage(`container "${args.containerId} initialized`);
+}
+/** purge unused (garbage) blocks from a WorkspaceContainer. */
+async function purgeWorkspace(args) {
+    const container = getCloudContainer(args);
+    const nGarbage = container.garbageBlocks;
+    await core_backend_1.CloudSqlite.withWriteLock(args.user, container, async () => container.cleanDeletedBlocks());
+    container.checkForChanges(); // re-read manifest to get current garbage count
+    showMessage(`purged ${sayContainer(args)}. ${nGarbage - container.garbageBlocks} garbage blocks cleaned`);
+}
+/** detach a WorkspaceContainer from the local cache. */
+async function detachWorkspace(args) {
+    const container = getCloudContainer(args);
+    container.detach();
+    showMessage(`detached ${sayContainer(args)}.`);
+}
+/** Make a copy of a WorkspaceDb with a new name. */
+async function copyWorkspaceDb(args) {
+    const container = getCloudContainer(args);
+    const oldName = core_backend_1.ITwinWorkspaceContainer.resolveCloudFileName(container, args);
+    const newVersion = core_backend_1.ITwinWorkspaceContainer.parseDbFileName(args.newDbName);
+    core_backend_1.ITwinWorkspaceContainer.validateDbName(newVersion.dbName);
+    const newName = core_backend_1.ITwinWorkspaceContainer.makeDbFileName(newVersion.dbName, core_backend_1.ITwinWorkspaceContainer.validateVersion(newVersion.version));
+    await core_backend_1.CloudSqlite.withWriteLock(args.user, container, async () => container.copyDatabase(oldName, newName));
+    showMessage(`copied WorkspaceDb [${oldName}] to [${newName}] in ${sayContainer(args)}`);
+}
+/** Make a copy of a WorkspaceDb with a new name. */
+async function versionWorkspaceDb(args) {
+    fixVersionArg(args);
+    const container = getCloudContainer(args);
+    const result = await core_backend_1.ITwinWorkspaceContainer.makeNewVersion(container, args, args.versionType);
+    showMessage(`created new version: [${result.newName}] from [${result.oldName}] in ${sayContainer(args)}`);
+}
+/** pin a WorkspaceDb from a WorkspaceContainer. */
+async function preFetchWorkspaceDb(args) {
+    fixVersionArg(args);
+    const container = getCloudContainer(args);
+    const timer = new core_bentley_1.StopWatch("prefetch", true);
+    const prefetch = new core_backend_1.IModelHost.platform.CloudPrefetch(container, args.dbFileName);
+    await prefetch.promise;
+    showMessage(`preFetched WorkspaceDb [${args.dbFileName}] in ${sayContainer(args)}, time=${timer.elapsedSeconds.toString()}`);
+}
+/** acquire the write lock for a WorkspaceContainer. */
+async function acquireLock(args) {
+    const container = getCloudContainer(args);
+    if (container.hasWriteLock)
+        throw new Error(`write lock is already held for ${sayContainer(args)}`);
+    container.acquireWriteLock(args.user);
+    showMessage(`acquired lock for ${sayContainer(args)}`);
+}
+/** release the write lock for a WorkspaceContainer. */
+async function releaseLock(args) {
+    const container = getCloudContainer(args);
+    if (!container.hasWriteLock)
+        throw new Error(`write lock is not held for ${sayContainer(args)}`);
+    container.releaseWriteLock();
+    showMessage(`released lock for ${sayContainer(args)}`);
+}
+/** clear the write lock for a WorkspaceContainer. */
+async function clearWriteLock(args) {
+    const container = getCloudContainer(args);
+    container.clearWriteLock();
+    showMessage(`write lock cleared for ${sayContainer(args)}`);
+}
+/** query the list of WorkspaceDb in a WorkspaceContainer. */
+async function queryWorkspaceDbs(args) {
+    const container = getCloudContainer(args);
+    const writeLockMsg = container.hasWriteLock ? ", writeLocked" : "";
+    const hasLocalMsg = container.hasLocalChanges ? ", has local changes" : "";
+    const nGarbage = container.garbageBlocks;
+    const garbageMsg = nGarbage ? `, ${nGarbage} garbage block${nGarbage > 1 ? "s" : ""}` : "";
+    const blockSize = container.blockSize;
+    showMessage(`WorkspaceDbs in ${sayContainer(args)}${writeLockMsg}${hasLocalMsg}${garbageMsg}`);
+    const dbs = container.queryDatabases(args.glob);
+    for (const dbName of dbs) {
+        const db = container.queryDatabase(dbName);
+        if (db) {
+            const dirty = db.dirtyBlocks ? `, ${db.dirtyBlocks} dirty` : "";
+            const editable = db.state === "copied" ? ", editable" : "";
+            showMessage(` "${dbName}", size=${friendlyFileSize(db.totalBlocks * blockSize)}, ${friendlyFileSize(db.localBlocks * blockSize)} downloaded (${(100 * db.localBlocks / db.totalBlocks).toFixed(0)}%)${editable}${dirty}`);
+        }
+    }
 }
 /** Start `IModelHost`, then run a WorkspaceEditor command. Errors are logged to console. */
 function runCommand(cmd) {
     return async (args) => {
+        var _a;
+        if (inScript)
+            return cmd(args);
         try {
             const config = new core_backend_1.IModelHostConfiguration();
-            if (args.directory)
-                config.workspace = { containerDir: args.directory };
+            config.workspace = {
+                containerDir: args.directory,
+                cloudCacheProps: {
+                    nRequests: args.nRequests,
+                    curlDiagnostics: args.curlDiagnostics,
+                },
+            };
             await core_backend_1.IModelHost.startup(config);
+            if (true === args.logging) {
+                core_bentley_1.Logger.initializeToConsole();
+                core_bentley_1.Logger.setLevel("CloudSqlite", core_bentley_1.LogLevel.Trace);
+                (_a = core_backend_1.IModelHost.appWorkspace.cloudCache) === null || _a === void 0 ? void 0 : _a.setLogMask(0xff);
+                logTimer = setInterval(() => flushLog(), 20); // logging from other threads is buffered. This causes it to appear every 1/4 second.
+            }
             await cmd(args);
         }
         catch (e) {
-            console.error(e.message);
+            if (typeof e.message === "string")
+                console.error(e.message);
+            else
+                console.log(core_bentley_1.BentleyError.getErrorMessage(e));
+        }
+        finally {
+            if (logTimer) {
+                flushLog();
+                clearInterval(logTimer);
+            }
+            await core_backend_1.IModelHost.shutdown();
         }
     };
 }
+const type = { alias: "t", describe: "Type of resource", choices: ["blob", "string", "file"], demandOption: true };
+const addOrReplace = {
+    rscName: { alias: "n", describe: "Resource name for file", string: true },
+    root: { alias: "r", describe: "Root directory. Path parts after this will be saved in resource name", string: true },
+    type,
+};
+Yargs.usage("Edits or lists contents of a WorkspaceDb");
+Yargs.wrap(Math.min(150, Yargs.terminalWidth()));
+Yargs.env("WORKSPACE_EDITOR");
+Yargs.config();
+Yargs.help();
+Yargs.version("V2.0");
+Yargs.options({
+    directory: { alias: "d", describe: "Directory to use for WorkspaceContainers", string: true },
+    nRequests: { describe: "Number of simultaneous http requests for cloud operations", number: true, hidden: true },
+    containerId: { alias: "c", describe: "ContainerId for WorkspaceDb", string: true, demandOption: true },
+    user: { describe: "String shown in cloud container locked message", string: true, default: "workspace-editor" },
+    accessName: { alias: "a", describe: "Cloud storage account name for container", string: true },
+    accessToken: { describe: "Token that grants access to the container (either SAS or account key)", string: true, default: "" },
+    storageType: { describe: "Cloud storage module type", string: true, default: "azure?sas=1" },
+    logging: { describe: "enable log messages", boolean: true, default: false, hidden: true },
+    prefetch: { boolean: true, default: false, hidden: true },
+    curlDiagnostics: { boolean: true, default: false, hidden: true },
+});
+Yargs.command({
+    command: "add <dbName> <files>",
+    describe: "add files into a WorkspaceDb",
+    builder: addOrReplace,
+    handler: runCommand(addResource),
+});
+Yargs.command({
+    command: "replace <dbName> <files>",
+    describe: "replace files in a WorkspaceDb",
+    builder: addOrReplace,
+    handler: runCommand(replaceResource),
+});
+Yargs.command({
+    command: "remove <dbName> <rscName>",
+    describe: "remove a resource from a WorkspaceDb",
+    builder: { type },
+    handler: runCommand(removeResource),
+});
+Yargs.command({
+    command: "extract <dbName> <rscName> <fileName>",
+    describe: "extract a resource from a WorkspaceDb into a local file",
+    builder: { type },
+    handler: runCommand(extractResource),
+});
+Yargs.command({
+    command: "listDb <dbName>",
+    describe: "list the contents of a WorkspaceDb",
+    builder: {
+        strings: { alias: "s", describe: "list string resources", boolean: true, default: false },
+        blobs: { alias: "b", describe: "list blob resources", boolean: true, default: false },
+        files: { alias: "f", describe: "list file resources", boolean: true, default: false },
+    },
+    handler: runCommand(listWorkspaceDb),
+});
+Yargs.command({
+    command: "deleteDb <dbName>",
+    describe: "delete a WorkspaceDb from a cloud container",
+    handler: runCommand(deleteWorkspaceDb),
+});
+Yargs.command({
+    command: "createDb <dbName>",
+    describe: "create a new WorkspaceDb",
+    handler: runCommand(createWorkspaceDb),
+});
+Yargs.command({
+    command: "copyDb <dbName> <newDbName>",
+    describe: "make a copy of a WorkspaceDb in a cloud container with a new name",
+    handler: runCommand(copyWorkspaceDb),
+});
+Yargs.command({
+    command: "versionDb <dbName>",
+    describe: "make a new version of a WorkspaceDb",
+    builder: {
+        versionType: { describe: "the type of version to create", default: "patch", string: true, choices: ["major", "minor", "patch"] },
+    },
+    handler: runCommand(versionWorkspaceDb),
+});
+Yargs.command({
+    command: "prefetchDb <dbName>",
+    describe: false,
+    handler: runCommand(preFetchWorkspaceDb),
+});
+Yargs.command({
+    command: "vacuumDb <dbName>",
+    describe: "vacuum a WorkspaceDb",
+    handler: runCommand(vacuumWorkspaceDb),
+});
+Yargs.command({
+    command: "importDb <dbName> <localFileName>",
+    describe: "import a WorkspaceDb into a cloud container",
+    builder: {
+        noVacuum: { describe: "Don't vacuum source Db before importing", boolean: true },
+    },
+    handler: runCommand(importWorkspaceDb),
+});
+Yargs.command({
+    command: "exportDb <dbName> <localFileName>",
+    describe: "export a WorkspaceDb from a cloud container to a local file",
+    handler: runCommand(exportWorkspaceDb),
+});
+Yargs.command({
+    command: "queryDbs [glob]",
+    describe: "query the list of WorkspaceDbs in a cloud container",
+    handler: runCommand(queryWorkspaceDbs),
+});
+Yargs.command({
+    command: "acquireLock",
+    describe: "acquire the write lock for a cloud container",
+    handler: runCommand(acquireLock),
+});
+Yargs.command({
+    command: "releaseLock",
+    describe: "release the write lock for a cloud container",
+    handler: runCommand(releaseLock),
+});
+Yargs.command({
+    command: "clearWriteLock",
+    describe: "clear the write lock for a cloud container. Note: this can be dangerous!",
+    handler: runCommand(clearWriteLock),
+});
+Yargs.command({
+    command: "purgeWorkspace",
+    describe: "purge deleted blocks from a WorkspaceContainer",
+    handler: runCommand(purgeWorkspace),
+});
+Yargs.command({
+    command: "detachWorkspace",
+    describe: false,
+    handler: runCommand(detachWorkspace),
+});
+Yargs.command({
+    command: "initializeWorkspace",
+    describe: "initialize a WorkspaceContainer (empties if already initialized)",
+    builder: {
+        noPrompt: { describe: "Skip prompt", boolean: true, default: false },
+    },
+    handler: runCommand(initializeWorkspace),
+});
+/** execute an "@" script - a list of WorkspaceEditor commands */
+async function runScript(arg) {
+    inScript = true;
+    const val = fs.readFileSync(arg.scriptName, "utf-8");
+    const lines = val.split(/\r?\n/);
+    let i = 0;
+    for (let line of lines) {
+        i++;
+        line = line.split("#")[0].trim(); // ignore leading/trailing whitespace and comments (anything after a "#")
+        if (line.length === 0)
+            continue; // blank line
+        await Yargs.parseAsync(line, {}, (err, _argv, _output) => {
+            if (err) {
+                console.error(`${arg.scriptName}:${i} [${line}] : ${core_bentley_1.BentleyError.getErrorMessage(err)}`);
+                process.exit(1);
+            }
+        });
+    }
+}
 /** Parse and execute WorkspaceEditor commands */
 async function main() {
-    const type = { alias: "t", describe: "the type of resource", choices: ["blob", "string", "file"], required: true };
-    const update = { alias: "u", describe: "update (i.e. replace) rather than add the files", boolean: true, default: false };
-    Yargs.usage("Edits or lists contents of a WorkspaceDb");
-    Yargs.wrap(Math.min(130, Yargs.terminalWidth()));
-    Yargs.strict();
-    Yargs.config();
-    Yargs.default("config", "workspaceEditor.json");
-    Yargs.help();
-    Yargs.version("V2.0");
-    Yargs.options({
-        directory: { alias: "d", describe: "directory to use for WorkspaceContainers", string: true },
-        containerId: { alias: "c", describe: "WorkspaceContainerId for WorkspaceDb", string: true, required: true },
-        sasToken: { alias: "s", describe: "shared access signature token", string: true, default: "" },
-        accountName: { alias: "a", describe: "cloud storage account name for container", string: true, default: "" },
-        storageType: { describe: "storage module type", string: true, default: "azure?sas=1" },
-    });
-    Yargs.command({
-        command: "create <dbName>",
-        describe: "create a new WorkspaceDb",
-        handler: runCommand(createWorkspaceDb),
-    });
-    Yargs.command({
-        command: "list <dbName>",
-        describe: "list the contents of a WorkspaceDb",
-        builder: {
-            strings: { alias: "s", describe: "list string resources", boolean: true, default: false },
-            blobs: { alias: "b", describe: "list blob resources", boolean: true, default: false },
-            files: { alias: "f", describe: "list file resources", boolean: true, default: false },
-        },
-        handler: runCommand(listWorkspaceDb),
-    });
-    Yargs.command({
-        command: "add <dbName> <files>",
-        describe: "add or update files into a WorkspaceDb",
-        builder: {
-            name: { alias: "n", describe: "resource name for file", string: true },
-            root: { alias: "r", describe: "root directory. Path parts after this will be saved in resource name", string: true },
-            update,
-            type,
-        },
-        handler: runCommand(addResource),
-    });
-    Yargs.command({
-        command: "extract <dbName> <rscName> <fileName>",
-        describe: "extract a resource from a WorkspaceDb into a local file",
-        builder: { type },
-        handler: runCommand(extractResource),
-    });
-    Yargs.command({
-        command: "remove <dbName> <rscName>",
-        describe: "remove a resource from a WorkspaceDb",
-        builder: { type },
-        handler: runCommand(removeResource),
-    });
-    Yargs.command({
-        command: "upload <dbName>",
-        describe: "upload a WorkspaceDb to cloud storage",
-        builder: {
-            initialize: { alias: "i", describe: "initialize container", boolean: true, default: false },
-            localFile: { alias: "l", describe: "name of source local file", string: true, required: false },
-        },
-        handler: runCommand(uploadWorkspaceDb),
-    });
-    Yargs.command({
-        command: "download <dbName>",
-        describe: "download a WorkspaceDb from cloud storage to local file",
-        builder: {
-            localFile: { alias: "l", describe: "name of target local file", string: true, required: false },
-        },
-        handler: runCommand(downloadWorkspaceDb),
-    });
-    Yargs.command({
-        command: "delete <dbName>",
-        describe: "delete a WorkspaceDb from cloud storage",
-        handler: runCommand(deleteWorkspaceDb),
-    });
-    Yargs.command({
-        command: "vacuum <dbName>",
-        describe: "vacuum a WorkspaceDb",
-        handler: runCommand(vacuumWorkspaceDb),
-    });
+    var _a;
+    if (process.argv.length > 1 && ((_a = process.argv[2]) === null || _a === void 0 ? void 0 : _a[0]) === "@") {
+        const parsed = Yargs.parseSync(process.argv.slice(3));
+        if (parsed.config)
+            process.env.WORKSPACE_EDITOR_CONFIG = parsed.config;
+        await runCommand(runScript)({ ...parsed, scriptName: process.argv[2].substring(1) });
+        return;
+    }
+    Yargs.strictCommands();
     Yargs.demandCommand();
-    Yargs.argv;
+    await Yargs.parseAsync();
 }
 void main();
 //# sourceMappingURL=WorkspaceEditor.js.map