@cyberxon/xon 0.2.2 → 0.3.1

package/dist/cli.js

@@ -1,15 +1,17 @@
 #!/usr/bin/env node
 import { readFileSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { Command, CommanderError } from "commander";
 import { ApiClient, ApiError } from "./api-client.js";
-import { createProject, readProject } from "./project.js";
+import { createProject, readProject, tryReadProject, updateProjectConfig } from "./project.js";
 import { updateCli } from "./update.js";
-import { cancelDeploy, previewDeploy, quickDeploy, reportDeploy, resumeDeploy, startDeploy } from "./deploy.js";
+import { cancelDeploy, COVERAGE_FORMATTERS, previewDeploy, quickDeploy, reportDeploy, resumeDeploy, startDeploy, TEST_LEVELS, } from "./deploy.js";
 import { previewRetrieve, resumeRetrieve, startRetrieve } from "./retrieve.js";
 import { collectSourceFiles, writeSourceFiles } from "./source.js";
-import { displayOrg, loginAccessToken, loginJwt, loginSfdxUrl, loginWeb, logoutOrg, openInBrowser, openOrg } from "./org.js";
-import { clearOrgs, listOrgs } from "./org-store.js";
+import { displayOrg, loginAccessToken, loginCredentials, loginJwt, loginSfdxUrl, loginWeb, logoutOrg, openInBrowser, openOrg } from "./org.js";
+import { clearOrgs, listOrgs, tryGetOrg } from "./org-store.js";
+import { applyFlagsDir } from "./flags-dir.js";
 const cliVersion = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
 const program = new Command();
 function output(value) {
@@ -22,12 +24,18 @@ async function readStdin() {
     }
     return Buffer.concat(chunks).toString("utf8").trim();
 }
-function apiClient(options) {
-    const baseUrl = options.baseUrl ?? process.env.XON_BASE_URL;
+async function apiClient(options) {
+    const project = await tryReadProject(".");
+    const baseUrl = options.baseUrl ?? process.env.XON_BASE_URL ?? project?.baseUrl;
     if (!baseUrl) {
-        throw new Error("An API base URL is required. Set XON_BASE_URL or pass --base-url.");
+        throw new Error("An API base URL is required. Set XON_BASE_URL, pass --base-url, or run 'xon org login' inside a project to save one.");
     }
-    return new ApiClient({ baseUrl, token: options.token ?? process.env.XON_TOKEN });
+    let token = options.token ?? process.env.XON_TOKEN;
+    if (!token) {
+        const org = await tryGetOrg(options.targetOrg ?? project?.defaultOrg);
+        token = org?.token;
+    }
+    return new ApiClient({ baseUrl, token });
 }
 async function requireProjectRoot() {
     try {
@@ -37,6 +45,21 @@ async function requireProjectRoot() {
         throw new Error("Not in a xon project directory (missing .xon/project.json). Run this inside a project created with 'xon project create'.");
     }
 }
+async function resolveTargetOrg(explicit) {
+    if (explicit) {
+        return explicit;
+    }
+    const project = await tryReadProject(".");
+    return project?.defaultOrg;
+}
+async function saveProjectLoginDefaults(baseUrl, orgAlias) {
+    const project = await tryReadProject(".");
+    if (!project) {
+        return;
+    }
+    await updateProjectConfig(".", { baseUrl, defaultOrg: orgAlias });
+    console.log(`Saved base-url and default org to .xon/project.json`);
+}
 async function waitForDeploy(client, status, waitSeconds) {
     if (waitSeconds > 0 && !status.done) {
         return resumeDeploy(client, status.id, waitSeconds);
@@ -50,6 +73,68 @@ const parseWait = (value) => {
     }
     return parsed;
 };
+const DEFAULT_DEPLOY_WAIT_SECONDS = 33 * 60;
+const collect = (value, previous) => previous.concat([value]);
+function parseEnum(name, allowed) {
+    return (value) => {
+        if (!allowed.includes(value)) {
+            throw new Error(`${name} must be one of: ${allowed.join(", ")}`);
+        }
+        return value;
+    };
+}
+const parseTestLevel = parseEnum("--test-level", TEST_LEVELS);
+const parseCoverageFormatter = (value, previous) => {
+    if (!COVERAGE_FORMATTERS.includes(value)) {
+        throw new Error(`--coverage-formatters must be one of: ${COVERAGE_FORMATTERS.join(", ")}`);
+    }
+    return previous.concat([value]);
+};
+async function writeDeployResults(resultsDir, status) {
+    if (!resultsDir) {
+        return;
+    }
+    const dir = path.resolve(resultsDir, status.id);
+    await mkdir(dir, { recursive: true });
+    await writeFile(path.join(dir, "deploy-result.json"), `${JSON.stringify(status, null, 2)}\n`);
+    console.log(`Wrote results to ${dir}`);
+}
+function printDeployResult(status, options) {
+    if (options.concise && !options.json) {
+        const { id, status: state, success, numberComponentsDeployed, numberComponentsTotal } = status;
+        console.log(`${id} ${state}${success === undefined ? "" : ` success=${success}`}${numberComponentsDeployed === undefined ? "" : ` (${numberComponentsDeployed}/${numberComponentsTotal})`}`);
+        return;
+    }
+    output(status);
+}
+function addDeployStartFlags(cmd) {
+    return cmd
+        .option("-a, --api-version <version>", "Target API version for the deploy")
+        .option("--concise", "Display simplified deployment results output", false)
+        .option("--coverage-formatters <formatter>", "Format of the code coverage results (repeatable)", parseCoverageFormatter, [])
+        .option("--flags-dir <path>", "Import flag values from a directory")
+        .option("-c, --ignore-conflicts", "Ignore conflicts and deploy local files, even if they overwrite changes in the org", false)
+        .option("-r, --ignore-errors", "Ignore any errors and don't roll back deployment", false)
+        .option("-g, --ignore-warnings", "Ignore warnings and allow a deployment to complete successfully", false)
+        .option("--json", "Format output as JSON", false)
+        .option("--junit", "Output JUnit test results", false)
+        .option("-x, --manifest <path>", "Full file path for manifest (package.xml) of components to deploy")
+        .option("-m, --metadata <name>", "Metadata component names to deploy (repeatable)", collect, [])
+        .option("--metadata-dir <path>", "Root of directory of metadata formatted files to deploy")
+        .option("--post-destructive-changes <path>", "File path for a manifest of components to delete after the deploy")
+        .option("--pre-destructive-changes <path>", "File path for a manifest of components to delete before the deploy")
+        .option("--purge-on-delete", "Immediately eligible for deletion rather than stored in the Recycle Bin", false)
+        .option("--results-dir <path>", "Output directory for code coverage and JUnit results")
+        .option("--single-package", "Indicates that the metadata zip file points to a directory structure for a single package", false)
+        .option("-d, --source-dir <path>", "Path to the local source files to deploy (repeatable)", collect, [])
+        .option("-o, --target-org <org>", "Username or alias of the target org")
+        .option("-l, --test-level <level>", `Deployment Apex testing level (${TEST_LEVELS.join(", ")})`, parseTestLevel)
+        .option("-t, --tests <name>", "Apex tests to run when --test-level is RunSpecifiedTests (repeatable)", collect, [])
+        .option("--verbose", "Show detailed deployment results output", false)
+        .option("-w, --wait <seconds>", "Seconds to wait for the deploy to finish (0 = don't wait)", parseWait, DEFAULT_DEPLOY_WAIT_SECONDS)
+        .option("--base-url <url>", "API base URL")
+        .option("--token <token>", "Bearer token");
+}
 program
     .name("xon")
     .description("Manage Xon projects and deployments")
@@ -65,40 +150,72 @@ project
     console.log(`Created project ${name} in ${root}`);
 });
 const projectDeploy = project.command("deploy").description("Deploy metadata between your project and an org");
-projectDeploy
-    .command("start")
-    .description("Deploy metadata to an org from your local project")
-    .option("-d, --source-dir <dir>", "Directory of source to deploy", "src")
-    .option("-o, --target-org <org>", "Org to deploy to")
-    .option("-c, --dry-run", "Validate the deploy without applying it", false)
-    .option("-w, --wait <seconds>", "Seconds to wait for the deploy to finish (0 = don't wait)", parseWait, 0)
-    .option("-b, --base-url <url>", "API base URL")
-    .option("-t, --token <token>", "Bearer token")
-    .action(async (options) => {
+addDeployStartFlags(projectDeploy.command("start").description("Deploy metadata to an org from your local project"))
+    .option("--async", "Run the command asynchronously and return the job ID immediately", false)
+    .option("--dry-run", "Validate deploy and run Apex tests but don't save to the org", false)
+    .action(async (options, command) => {
     await requireProjectRoot();
-    const client = apiClient(options);
-    const status = await startDeploy(client, path.resolve(options.sourceDir), {
-        targetOrg: options.targetOrg,
+    if (options.flagsDir) {
+        await applyFlagsDir(command, options.flagsDir);
+        options = command.opts();
+    }
+    const client = await apiClient(options);
+    const sourceDirs = (options.sourceDir.length > 0 ? options.sourceDir : ["src"]).map((dir) => path.resolve(dir));
+    const status = await startDeploy(client, sourceDirs, {
+        targetOrg: await resolveTargetOrg(options.targetOrg),
         checkOnly: options.dryRun,
+        apiVersion: options.apiVersion,
+        manifest: options.manifest,
+        metadata: options.metadata && options.metadata.length > 0 ? options.metadata : undefined,
+        metadataDir: options.metadataDir,
+        singlePackage: options.singlePackage,
+        testLevel: options.testLevel,
+        tests: options.tests && options.tests.length > 0 ? options.tests : undefined,
+        ignoreErrors: options.ignoreErrors,
+        ignoreWarnings: options.ignoreWarnings,
+        ignoreConflicts: options.ignoreConflicts,
+        purgeOnDelete: options.purgeOnDelete,
+        preDestructiveChanges: options.preDestructiveChanges,
+        postDestructiveChanges: options.postDestructiveChanges,
+        coverageFormatters: options.coverageFormatters && options.coverageFormatters.length > 0 ? options.coverageFormatters : undefined,
+        junit: options.junit,
     });
-    output(await waitForDeploy(client, status, options.wait));
+    const waitSeconds = options.async ? 0 : options.wait;
+    const final = await waitForDeploy(client, status, waitSeconds);
+    await writeDeployResults(options.resultsDir, final);
+    printDeployResult(final, options);
 });
-projectDeploy
-    .command("validate")
-    .description("Validate a metadata deployment without actually executing it")
-    .option("-d, --source-dir <dir>", "Directory of source to validate", "src")
-    .option("-o, --target-org <org>", "Org to validate against")
-    .option("-w, --wait <seconds>", "Seconds to wait for validation to finish (0 = don't wait)", parseWait, 0)
-    .option("-b, --base-url <url>", "API base URL")
-    .option("-t, --token <token>", "Bearer token")
-    .action(async (options) => {
+addDeployStartFlags(projectDeploy.command("validate").description("Validate a metadata deployment without actually executing it"))
+    .action(async (options, command) => {
     await requireProjectRoot();
-    const client = apiClient(options);
-    const status = await startDeploy(client, path.resolve(options.sourceDir), {
-        targetOrg: options.targetOrg,
+    if (options.flagsDir) {
+        await applyFlagsDir(command, options.flagsDir);
+        options = command.opts();
+    }
+    const client = await apiClient(options);
+    const sourceDirs = (options.sourceDir.length > 0 ? options.sourceDir : ["src"]).map((dir) => path.resolve(dir));
+    const status = await startDeploy(client, sourceDirs, {
+        targetOrg: await resolveTargetOrg(options.targetOrg),
         checkOnly: true,
+        apiVersion: options.apiVersion,
+        manifest: options.manifest,
+        metadata: options.metadata && options.metadata.length > 0 ? options.metadata : undefined,
+        metadataDir: options.metadataDir,
+        singlePackage: options.singlePackage,
+        testLevel: options.testLevel,
+        tests: options.tests && options.tests.length > 0 ? options.tests : undefined,
+        ignoreErrors: options.ignoreErrors,
+        ignoreWarnings: options.ignoreWarnings,
+        ignoreConflicts: options.ignoreConflicts,
+        purgeOnDelete: options.purgeOnDelete,
+        preDestructiveChanges: options.preDestructiveChanges,
+        postDestructiveChanges: options.postDestructiveChanges,
+        coverageFormatters: options.coverageFormatters && options.coverageFormatters.length > 0 ? options.coverageFormatters : undefined,
+        junit: options.junit,
     });
-    output(await waitForDeploy(client, status, options.wait));
+    const final = await waitForDeploy(client, status, options.wait);
+    await writeDeployResults(options.resultsDir, final);
+    printDeployResult(final, options);
 });
 projectDeploy
     .command("quick")
@@ -108,7 +225,7 @@ projectDeploy
     .option("-b, --base-url <url>", "API base URL")
     .option("-t, --token <token>", "Bearer token")
     .action(async (options) => {
-    const client = apiClient(options);
+    const client = await apiClient(options);
     const status = await quickDeploy(client, options.jobId);
     output(await waitForDeploy(client, status, options.wait));
 });
@@ -119,7 +236,7 @@ projectDeploy
     .option("-b, --base-url <url>", "API base URL")
     .option("-t, --token <token>", "Bearer token")
     .action(async (options) => {
-    output(await reportDeploy(apiClient(options), options.jobId));
+    output(await reportDeploy(await apiClient(options), options.jobId));
 });
 projectDeploy
     .command("resume")
@@ -129,7 +246,7 @@ projectDeploy
     .option("-b, --base-url <url>", "API base URL")
     .option("-t, --token <token>", "Bearer token")
     .action(async (options) => {
-    output(await resumeDeploy(apiClient(options), options.jobId, options.wait));
+    output(await resumeDeploy(await apiClient(options), options.jobId, options.wait));
 });
 projectDeploy
     .command("cancel")
@@ -138,7 +255,7 @@ projectDeploy
     .option("-b, --base-url <url>", "API base URL")
     .option("-t, --token <token>", "Bearer token")
     .action(async (options) => {
-    output(await cancelDeploy(apiClient(options), options.jobId));
+    output(await cancelDeploy(await apiClient(options), options.jobId));
 });
 projectDeploy
     .command("preview")
@@ -153,23 +270,56 @@ const projectRetrieve = project.command("retrieve").description("Retrieve metada
 projectRetrieve
     .command("start")
     .description("Retrieve metadata from an org to your local project")
-    .option("-d, --source-dir <dir>", "Directory to write retrieved source into", "src")
-    .option("-o, --target-org <org>", "Org to retrieve from")
-    .option("-w, --wait <seconds>", "Seconds to wait for the retrieve to finish", parseWait, 60)
-    .option("-b, --base-url <url>", "API base URL")
-    .option("-t, --token <token>", "Bearer token")
-    .action(async (options) => {
+    .option("-a, --api-version <version>", "Target API version for the retrieve")
+    .option("--flags-dir <path>", "Import flag values from a directory")
+    .option("-c, --ignore-conflicts", "Ignore conflicts and save files, even if they overwrite local changes", false)
+    .option("--json", "Format output as JSON", false)
+    .option("-x, --manifest <path>", "File path for the manifest (package.xml) that specifies the components to retrieve")
+    .option("-m, --metadata <name>", "Metadata component names to retrieve (repeatable)", collect, [])
+    .option("-r, --output-dir <path>", "Directory root for the retrieved source files", "src")
+    .option("-n, --package-name <name>", "Package names to retrieve (repeatable)", collect, [])
+    .option("--single-package", "Indicates that the zip file points to a directory structure for a single package", false)
+    .option("-d, --source-dir <path>", "File paths for source to retrieve from the org (repeatable)", collect, [])
+    .option("-t, --target-metadata-dir <path>", "Directory to write the retrieved metadata-format zip into")
+    .option("-o, --target-org <org>", "Username or alias of the target org")
+    .option("-z, --unzip", "Extract files from the retrieved zip file", false)
+    .option("-w, --wait <seconds>", "Seconds to wait for the retrieve to finish", parseWait, DEFAULT_DEPLOY_WAIT_SECONDS)
+    .option("--zip-file-name <name>", "File name for the retrieved zip file")
+    .option("--base-url <url>", "API base URL")
+    .option("--token <token>", "Bearer token")
+    .action(async (options, command) => {
     await requireProjectRoot();
-    const client = apiClient(options);
-    let result = await startRetrieve(client, options.targetOrg);
+    if (options.flagsDir) {
+        await applyFlagsDir(command, options.flagsDir);
+        options = command.opts();
+    }
+    const client = await apiClient(options);
+    let result = await startRetrieve(client, {
+        targetOrg: await resolveTargetOrg(options.targetOrg),
+        apiVersion: options.apiVersion,
+        manifest: options.manifest,
+        metadata: options.metadata && options.metadata.length > 0 ? options.metadata : undefined,
+        packageNames: options.packageName && options.packageName.length > 0 ? options.packageName : undefined,
+        sourceDir: options.sourceDir.length > 0 ? options.sourceDir : undefined,
+        singlePackage: options.singlePackage,
+        ignoreConflicts: options.ignoreConflicts,
+        zipFileName: options.zipFileName,
+    });
     if (options.wait > 0 && !result.done) {
         result = await resumeRetrieve(client, result.id, options.wait);
     }
-    if (result.success && result.files) {
-        await writeSourceFiles(path.resolve(options.sourceDir), result.files);
-        console.log(`Retrieved ${result.files.length} file(s) into ${options.sourceDir}`);
+    if (result.success && result.files && (options.unzip || !options.targetMetadataDir)) {
+        await writeSourceFiles(path.resolve(options.outputDir), result.files);
+        console.log(`Retrieved ${result.files.length} file(s) into ${options.outputDir}`);
     }
-    const { files, ...summary } = result;
+    if (result.success && result.metadataZip && options.targetMetadataDir) {
+        const zipDir = path.resolve(options.targetMetadataDir);
+        await mkdir(zipDir, { recursive: true });
+        const zipPath = path.join(zipDir, options.zipFileName ?? "unpackaged.zip");
+        await writeFile(zipPath, Buffer.from(result.metadataZip, "base64"));
+        console.log(`Wrote metadata zip to ${zipPath}`);
+    }
+    const { files, metadataZip, ...summary } = result;
     output(summary);
 });
 projectRetrieve
@@ -179,7 +329,7 @@ projectRetrieve
     .option("-b, --base-url <url>", "API base URL")
     .option("-t, --token <token>", "Bearer token")
     .action(async (options) => {
-    const rows = await previewRetrieve(apiClient(options), options.targetOrg);
+    const rows = await previewRetrieve(await apiClient(options), options.targetOrg);
     console.table(rows);
 });
 const org = program.command("org").description("Manage your Salesforce org connections");
@@ -194,13 +344,15 @@ orgLogin
     .option("-b, --base-url <url>", "API base URL")
     .option("-t, --token <token>", "Bearer token")
     .action(async (options) => {
-    const record = await loginWeb(apiClient(options), {
+    const client = await apiClient(options);
+    const record = await loginWeb(client, {
         alias: options.alias,
         setDefault: options.setDefault,
         waitSeconds: options.wait,
         instanceUrl: options.instanceUrl,
     });
     console.log(`Logged in to ${record.instanceUrl} as ${record.username} (alias: ${record.alias})`);
+    await saveProjectLoginDefaults(client.baseUrl, record.alias);
 });
 orgLogin
     .command("jwt")
@@ -214,8 +366,10 @@ orgLogin
     .option("-b, --base-url <url>", "API base URL")
     .option("-t, --token <token>", "Bearer token")
     .action(async (options) => {
-    const record = await loginJwt(apiClient(options), options);
+    const client = await apiClient(options);
+    const record = await loginJwt(client, options);
     console.log(`Logged in to ${record.instanceUrl} as ${record.username} (alias: ${record.alias})`);
+    await saveProjectLoginDefaults(client.baseUrl, record.alias);
 });
 orgLogin
     .command("sfdx-url")
@@ -234,8 +388,10 @@ orgLogin
             : (() => {
                 throw new Error("Pass --sfdx-url-file <path> or --sfdx-url-stdin.");
             })();
-    const record = await loginSfdxUrl(apiClient(options), { sfdxAuthUrl, alias: options.alias, setDefault: options.setDefault });
+    const client = await apiClient(options);
+    const record = await loginSfdxUrl(client, { sfdxAuthUrl, alias: options.alias, setDefault: options.setDefault });
     console.log(`Logged in to ${record.instanceUrl} as ${record.username} (alias: ${record.alias})`);
+    await saveProjectLoginDefaults(client.baseUrl, record.alias);
 });
 orgLogin
     .command("access-token")
@@ -250,13 +406,40 @@ orgLogin
     if (!accessToken) {
         throw new Error("Pipe the access token via stdin, e.g. echo $TOKEN | xon org login access-token -r <url>.");
     }
-    const record = await loginAccessToken(apiClient(options), {
+    const client = await apiClient(options);
+    const record = await loginAccessToken(client, {
         instanceUrl: options.instanceUrl,
         accessToken,
         alias: options.alias,
         setDefault: options.setDefault,
     });
     console.log(`Logged in to ${record.instanceUrl} as ${record.username} (alias: ${record.alias})`);
+    await saveProjectLoginDefaults(client.baseUrl, record.alias);
+});
+orgLogin
+    .command("credentials")
+    .description("Log in using your xon backend credentials, exchanged for an org access token")
+    .requiredOption("-u, --login-id <id>", "Login id / username for your xon backend account")
+    .requiredOption("-r, --instance-url <url>", "Instance URL of the org")
+    .option("-a, --alias <alias>", "Alias to save this org connection under")
+    .option("-d, --set-default", "Set this org as the default", false)
+    .option("-b, --base-url <url>", "API base URL")
+    .option("-t, --token <token>", "Bearer token")
+    .action(async (options) => {
+    const password = await readStdin();
+    if (!password) {
+        throw new Error("Pipe the password via stdin, e.g. echo $PASSWORD | xon org login credentials -u <loginId> -r <url>.");
+    }
+    const client = await apiClient(options);
+    const record = await loginCredentials(client, {
+        loginId: options.loginId,
+        password,
+        instanceUrl: options.instanceUrl,
+        alias: options.alias,
+        setDefault: options.setDefault,
+    });
+    console.log(`Logged in to ${record.instanceUrl} as ${record.username} (alias: ${record.alias})`);
+    await saveProjectLoginDefaults(client.baseUrl, record.alias);
 });
 org
     .command("logout")
@@ -266,7 +449,7 @@ org
     .option("-b, --base-url <url>", "API base URL")
     .option("-t, --token <token>", "Bearer token")
     .action(async (options) => {
-    const client = apiClient(options);
+    const client = await apiClient(options);
     if (options.all) {
         const { orgs } = await listOrgs();
         for (const record of orgs) {
@@ -276,7 +459,7 @@ org
         await clearOrgs();
         return;
     }
-    const record = await logoutOrg(client, options.targetOrg);
+    const record = await logoutOrg(client, await resolveTargetOrg(options.targetOrg));
     console.log(`Logged out of ${record.alias}`);
 });
 org
@@ -286,7 +469,7 @@ org
     .option("-b, --base-url <url>", "API base URL")
     .option("-t, --token <token>", "Bearer token")
     .action(async (options) => {
-    output(await displayOrg(apiClient(options), options.targetOrg));
+    output(await displayOrg(await apiClient(options), await resolveTargetOrg(options.targetOrg)));
 });
 org
     .command("open")
@@ -297,7 +480,7 @@ org
     .option("-b, --base-url <url>", "API base URL")
     .option("-t, --token <token>", "Bearer token")
     .action(async (options) => {
-    const { url, org: record } = await openOrg(apiClient(options), { alias: options.targetOrg, path: options.path });
+    const { url, org: record } = await openOrg(await apiClient(options), { alias: await resolveTargetOrg(options.targetOrg), path: options.path });
     if (options.urlOnly) {
         console.log(url);
     }
@@ -321,7 +504,7 @@ deploy
     .option("-t, --token <token>", "Bearer token")
     .action(async (options) => {
     const payload = JSON.parse(await (await import("node:fs/promises")).readFile(options.file, "utf8"));
-    output(await apiClient(options).post("/deployRequests", payload));
+    output(await (await apiClient(options)).post("/deployRequests", payload));
 });
 deploy
     .command("get <id>")
@@ -329,7 +512,7 @@ deploy
     .option("-b, --base-url <url>", "API base URL")
     .option("-t, --token <token>", "Bearer token")
     .action(async (id, options) => {
-    output(await apiClient(options).get(`/deployRequests/${encodeURIComponent(id)}`));
+    output(await (await apiClient(options)).get(`/deployRequests/${encodeURIComponent(id)}`));
 });
 program.parseAsync().catch((error) => {
     if (error instanceof CommanderError) {

package/dist/deploy.js

@@ -1,11 +1,45 @@
+import { readFile } from "node:fs/promises";
 import { pollJob } from "./polling.js";
 import { collectSourceFiles } from "./source.js";
-export async function startDeploy(client, sourceDir, options) {
-    const source = await collectSourceFiles(sourceDir);
+export const TEST_LEVELS = ["NoTestRun", "RunSpecifiedTests", "RunLocalTests", "RunAllTestsInOrg", "RunRelevantTests"];
+export const COVERAGE_FORMATTERS = [
+    "clover",
+    "cobertura",
+    "html-spa",
+    "html",
+    "json",
+    "json-summary",
+    "lcovonly",
+    "none",
+    "teamcity",
+    "text",
+    "text-summary",
+];
+export async function startDeploy(client, sourceDirs, options) {
+    const source = (await Promise.all(sourceDirs.map((dir) => collectSourceFiles(dir)))).flat();
+    const metadataDir = options.metadataDir ? await collectSourceFiles(options.metadataDir) : undefined;
+    const manifest = options.manifest ? await readFile(options.manifest, "utf8") : undefined;
+    const preDestructiveChanges = options.preDestructiveChanges ? await readFile(options.preDestructiveChanges, "utf8") : undefined;
+    const postDestructiveChanges = options.postDestructiveChanges ? await readFile(options.postDestructiveChanges, "utf8") : undefined;
     return client.post("/deployRequests", {
         source,
         targetOrg: options.targetOrg,
         checkOnly: options.checkOnly ?? false,
+        apiVersion: options.apiVersion,
+        manifest,
+        metadata: options.metadata,
+        metadataDir,
+        singlePackage: options.singlePackage,
+        testLevel: options.testLevel,
+        tests: options.tests,
+        ignoreErrors: options.ignoreErrors,
+        ignoreWarnings: options.ignoreWarnings,
+        ignoreConflicts: options.ignoreConflicts,
+        purgeOnDelete: options.purgeOnDelete,
+        preDestructiveChanges,
+        postDestructiveChanges,
+        coverageFormatters: options.coverageFormatters,
+        junit: options.junit,
     });
 }
 export async function reportDeploy(client, id) {

package/dist/flags-dir.js

@@ -0,0 +1,35 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+function toCamelCase(fileName) {
+    const base = fileName.replace(/\.[^.]+$/, "");
+    return base.replace(/-([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+export async function applyFlagsDir(command, dir) {
+    let entries;
+    try {
+        entries = await readdir(dir);
+    }
+    catch {
+        throw new Error(`--flags-dir directory not found: ${dir}`);
+    }
+    for (const entry of entries) {
+        const key = toCamelCase(entry);
+        if (command.getOptionValueSource(key) !== "default") {
+            continue;
+        }
+        const content = (await readFile(path.join(dir, entry), "utf8")).trim();
+        if (content.length === 0) {
+            continue;
+        }
+        const current = command.getOptionValue(key);
+        if (typeof current === "boolean") {
+            command.setOptionValueWithSource(key, content !== "false", "cli");
+        }
+        else if (Array.isArray(current)) {
+            command.setOptionValueWithSource(key, content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean), "cli");
+        }
+        else {
+            command.setOptionValueWithSource(key, content, "cli");
+        }
+    }
+}

package/dist/org-store.js

@@ -13,8 +13,8 @@ async function readStore() {
     }
 }
 async function writeStore(data) {
-    await mkdir(storeDir, { recursive: true });
-    await writeFile(storePath, `${JSON.stringify(data, null, 2)}\n`);
+    await mkdir(storeDir, { recursive: true, mode: 0o700 });
+    await writeFile(storePath, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
 }
 export async function saveOrg(record, setDefault) {
     const data = await readStore();
@@ -54,3 +54,11 @@ export async function listOrgs() {
     const data = await readStore();
     return { orgs: Object.values(data.orgs), defaultOrg: data.defaultOrg };
 }
+export async function tryGetOrg(alias) {
+    try {
+        return await getOrg(alias);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/org.js

@@ -9,13 +9,14 @@ export function openInBrowser(url) {
             : `xdg-open "${url}"`;
     exec(command);
 }
-async function finishLogin(response, alias, setDefault) {
+async function finishLogin(response, alias, setDefault, tokenOverride) {
     const record = {
         alias: alias ?? response.username,
         orgId: response.orgId,
         username: response.username,
         instanceUrl: response.instanceUrl,
         connectedAt: new Date().toISOString(),
+        token: tokenOverride ?? response.token,
     };
     await saveOrg(record, setDefault);
     return record;
@@ -56,7 +57,19 @@ export async function loginAccessToken(client, options) {
         instanceUrl: options.instanceUrl,
         accessToken: options.accessToken,
     });
-    return finishLogin(response, options.alias, options.setDefault);
+    return finishLogin(response, options.alias, options.setDefault, options.accessToken);
+}
+export async function loginCredentials(client, options) {
+    const { token } = await client.post("/auth/login", {
+        loginId: options.loginId,
+        password: options.password,
+    });
+    return loginAccessToken(client, {
+        instanceUrl: options.instanceUrl,
+        accessToken: token,
+        alias: options.alias,
+        setDefault: options.setDefault,
+    });
 }
 export async function logoutOrg(client, alias) {
     const record = await getOrg(alias);

package/dist/project.js

@@ -17,3 +17,16 @@ export async function readProject(directory = ".") {
     const contents = await readFile(path.resolve(directory, projectFile), "utf8");
     return JSON.parse(contents);
 }
+export async function updateProjectConfig(directory, patch) {
+    const config = await readProject(directory);
+    const updated = { ...config, ...patch };
+    await writeFile(path.resolve(directory, projectFile), `${JSON.stringify(updated, null, 2)}\n`);
+}
+export async function tryReadProject(directory = ".") {
+    try {
+        return await readProject(directory);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/retrieve.js

@@ -1,6 +1,18 @@
+import { readFile } from "node:fs/promises";
 import { pollJob } from "./polling.js";
-export async function startRetrieve(client, targetOrg) {
-    return client.post("/retrieveRequests", { targetOrg });
+export async function startRetrieve(client, options) {
+    const manifest = options.manifest ? await readFile(options.manifest, "utf8") : undefined;
+    return client.post("/retrieveRequests", {
+        targetOrg: options.targetOrg,
+        apiVersion: options.apiVersion,
+        manifest,
+        metadata: options.metadata,
+        packageNames: options.packageNames,
+        sourceDir: options.sourceDir,
+        singlePackage: options.singlePackage,
+        ignoreConflicts: options.ignoreConflicts,
+        zipFileName: options.zipFileName,
+    });
 }
 export async function resumeRetrieve(client, id, waitSeconds) {
     return pollJob(client, `/retrieveRequests/${encodeURIComponent(id)}`, { waitSeconds });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyberxon/xon",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "description": "A CLI for Xon projects and deployments",
   "type": "module",
   "license": "UNLICENSED",