@trayai/tray-sync-cli 0.0.1

package/dist/commands/env.js

@@ -0,0 +1,534 @@
+import path from "node:path";
+import { readdir as fsReaddir, readFile as fsReadFile } from "node:fs/promises";
+import { Command, InvalidArgumentError } from "commander";
+import { createTrayClientForRegion } from "../api/trayClient.js";
+import { readCredentials, writeCredentials } from "../config/credentials.js";
+import { readEnvironments, writeEnvironments } from "../config/environments.js";
+import { readProjectMappings, writeProjectMappings } from "../config/mappings.js";
+import { readProjectState } from "../config/state.js";
+import { readJson } from "../config/io.js";
+import { readTrayYaml } from "../config/trayYaml.js";
+import { entityDisplayName } from "../lib/exportStructure.js";
+import { resolveContainedSafe } from "../lib/pathContainment.js";
+import { describeRegion } from "../lib/regionDisplay.js";
+import { PUBLIC_REGIONS, parseRegion } from "../lib/regionParsing.js";
+import { resolveToken } from "../lib/tokenResolution.js";
+import { isUuid } from "../lib/uuid.js";
+import { OutputFormats, parseFormat } from "../lib/outputFormat.js";
+import { listWorkspaceAuthentications, matchAuthCandidates, prioritizeAuths, } from "../lib/authDiscovery.js";
+import { isFullyResolved, resolveProjectRequirements, } from "../lib/promoteTarget.js";
+import { checkProjectDrift, DriftStatuses } from "./status.js";
+import { printAddedEnvironment, printConnectivityCheck, printEnvAlreadyExists, printEnvNotConfigured, printEnvResolveProject, printEnvResolveProjectFullyResolved, printInvalidEnvName, printNoTargetEnvironments, printNoTokenSkippingConnectivity, printRemovedCredentials, printRemovedEnvironment, printEnvResolveProjectError, printRemovedMapping, printSourceEnvHeader, printSourceEnvLine, printTargetEnvHeader, printTargetEnvLine, printTokenNotSaved, printTrayYamlNotFound, } from "../views/env/env.js";
+import { printEnvListJson, printEnvResolveResultJson, } from "../views/env/shared.js";
+import { printError, printInvalidAuthMappings, printLocalDrift, printNoTargetProjectMapped, printProjectError, printProjectNoStateFile, printProjectNotPulledLocally, printTargetEnvNotFound, } from "../views/promote/promote.js";
+const ENV_NAME_RE = /^[a-zA-Z0-9_-]+$/;
+function emptyMapping() {
+    return { authentications: {}, config: {}, connectors: [], services: [] };
+}
+async function checkConnectivity(deps, region, workspaceId, tokenFlag) {
+    const credentials = await readCredentials(deps.env);
+    let token;
+    try {
+        token = resolveToken({ tokenFlag, credentials, workspaceId, env: deps.env });
+    }
+    catch {
+        return { status: "no-token" };
+    }
+    const client = deps.createClient(region, token);
+    try {
+        await client.request("GET", `/v2/projects/workspaces/${workspaceId}`);
+        return { status: "ok" };
+    }
+    catch (err) {
+        return { status: "failed", message: err.message };
+    }
+}
+function describeConnectivity(result) {
+    switch (result.status) {
+        case "ok":
+            return "✅ connected";
+        case "no-token":
+            return "no token available";
+        case "failed":
+            return `❌ (${result.message})`;
+    }
+}
+export async function runEnvAdd(deps, options) {
+    const { cwd, env, stdout, stderr } = deps;
+    if (!ENV_NAME_RE.test(options.name)) {
+        printInvalidEnvName(stderr, ENV_NAME_RE, options.name);
+        return 1;
+    }
+    const environments = await readEnvironments(cwd);
+    if (environments.environments[options.name]) {
+        printEnvAlreadyExists(stderr, options.name);
+        return 1;
+    }
+    environments.environments[options.name] = {
+        region: options.region,
+        workspace_id: options.workspaceId,
+    };
+    await writeEnvironments(environments, cwd);
+    printAddedEnvironment(stdout, options.name, describeRegion(options.region), options.workspaceId);
+    if (options.token) {
+        const credentials = await readCredentials(env);
+        const alreadySet = credentials.workspaces[options.workspaceId] !== undefined;
+        if (!alreadySet || options.forceToken) {
+            credentials.workspaces[options.workspaceId] = {
+                region: options.region,
+                token: options.token,
+            };
+            await writeCredentials(credentials, env);
+        }
+        else {
+            printTokenNotSaved(stderr, options.workspaceId);
+        }
+    }
+    const result = await checkConnectivity(deps, options.region, options.workspaceId, options.token);
+    if (result.status === "no-token") {
+        printNoTokenSkippingConnectivity(stdout);
+    }
+    else {
+        printConnectivityCheck(stdout, describeConnectivity(result));
+    }
+    return 0;
+}
+function toConnectivityJson(result) {
+    return result.status === "failed" ? { status: "failed", message: result.message } : { status: result.status };
+}
+export async function runEnvList(deps, options) {
+    const { cwd, stdout, stderr } = deps;
+    const trayYaml = await readTrayYaml(cwd);
+    if (!trayYaml) {
+        printTrayYamlNotFound(stderr);
+        return 1;
+    }
+    const environments = await readEnvironments(cwd);
+    const names = Object.keys(environments.environments).sort();
+    if (options.format === OutputFormats.JSON) {
+        const sourceResult = await checkConnectivity(deps, trayYaml.region, trayYaml.workspace_id);
+        const targets = [];
+        for (const name of names) {
+            const entry = environments.environments[name];
+            const result = await checkConnectivity(deps, entry.region, entry.workspace_id);
+            targets.push({
+                name,
+                region: entry.region,
+                workspace_id: entry.workspace_id,
+                connectivity: toConnectivityJson(result),
+            });
+        }
+        printEnvListJson(stdout, {
+            source: {
+                region: trayYaml.region,
+                workspace_id: trayYaml.workspace_id,
+                connectivity: toConnectivityJson(sourceResult),
+            },
+            targets,
+        });
+        return 0;
+    }
+    printSourceEnvHeader(stdout);
+    const sourceResult = await checkConnectivity(deps, trayYaml.region, trayYaml.workspace_id);
+    printSourceEnvLine(stdout, describeRegion(trayYaml.region), trayYaml.workspace_id, describeConnectivity(sourceResult));
+    printTargetEnvHeader(stdout);
+    if (names.length === 0) {
+        printNoTargetEnvironments(stdout);
+        return 0;
+    }
+    for (const name of names) {
+        const entry = environments.environments[name];
+        const result = await checkConnectivity(deps, entry.region, entry.workspace_id);
+        printTargetEnvLine(stdout, name, describeRegion(entry.region), entry.workspace_id, describeConnectivity(result));
+    }
+    return 0;
+}
+export async function runEnvRemove(deps, options) {
+    const { cwd, env, readdir, stdout, stderr } = deps;
+    const environments = await readEnvironments(cwd);
+    const entry = environments.environments[options.name];
+    if (!entry) {
+        printEnvNotConfigured(stdout, options.name);
+        return 0;
+    }
+    delete environments.environments[options.name];
+    await writeEnvironments(environments, cwd);
+    printRemovedEnvironment(stdout, options.name);
+    const trayYaml = await readTrayYaml(cwd);
+    if (trayYaml) {
+        const projectsRoot = path.join(cwd, "projects");
+        let existingDirs;
+        try {
+            existingDirs = await readdir(projectsRoot);
+        }
+        catch {
+            existingDirs = [];
+        }
+        for (const projectId of trayYaml.projects) {
+            const dirName = existingDirs.find((name) => name.split("--")[0] === projectId);
+            if (!dirName)
+                continue;
+            const projectDirPath = path.join(projectsRoot, dirName);
+            const mappings = await readProjectMappings(projectDirPath);
+            if (!mappings || !mappings.environments[options.name])
+                continue;
+            delete mappings.environments[options.name];
+            await writeProjectMappings(projectDirPath, mappings);
+            printRemovedMapping(stdout, options.name, dirName);
+        }
+    }
+    if (options.forgetCredentials) {
+        const credentials = await readCredentials(env);
+        if (credentials.workspaces[entry.workspace_id]) {
+            delete credentials.workspaces[entry.workspace_id];
+            await writeCredentials(credentials, env);
+            printRemovedCredentials(stdout, entry.workspace_id);
+        }
+    }
+    return 0;
+}
+function findProjectDirName(existingDirs, projectId) {
+    return existingDirs.find((name) => name.split("--")[0] === projectId);
+}
+function toEnvResolveProjectErrorJson(error) {
+    if (error.reason === "no_target_project_mapped") {
+        return { reason: "no_target_project_mapped", mappings_path: error.mappingsPath };
+    }
+    if (error.reason === "project_error") {
+        return { reason: "project_error", message: error.message, target_project_id: error.targetProjectId };
+    }
+    return { reason: "invalid_auth_mappings", invalid_auth_mappings: error.invalidAuthMappings };
+}
+export async function runEnvResolve(deps, options) {
+    const { cwd, env, createClient, readdir, readFile, readdirRecursive, stdout, stderr } = deps;
+    const asJson = options.format === OutputFormats.JSON;
+    const trayYaml = await readTrayYaml(cwd);
+    if (!trayYaml) {
+        printTrayYamlNotFound(stderr);
+        return 1;
+    }
+    const environments = await readEnvironments(cwd);
+    const targetEnv = environments.environments[options.to];
+    if (!targetEnv) {
+        printTargetEnvNotFound(stderr, options.to);
+        return 1;
+    }
+    const credentials = await readCredentials(env);
+    let targetToken;
+    try {
+        targetToken = resolveToken({
+            tokenFlag: options.token,
+            credentials,
+            workspaceId: targetEnv.workspace_id,
+            envName: options.to,
+            env,
+        });
+    }
+    catch (err) {
+        printError(stderr, err.message);
+        return 1;
+    }
+    const targetClient = createClient(targetEnv.region, targetToken);
+    const { authentications } = await listWorkspaceAuthentications(targetClient, targetEnv.region, targetEnv.workspace_id);
+    const targeted = options.projectIds !== undefined && options.projectIds.length > 0;
+    const plannedIds = targeted ? options.projectIds : trayYaml.projects;
+    const projectsRoot = path.join(cwd, "projects");
+    let existingDirs;
+    try {
+        existingDirs = await readdir(projectsRoot);
+    }
+    catch {
+        existingDirs = [];
+    }
+    const projectViews = [];
+    let anyUnresolved = false;
+    for (const projectId of plannedIds) {
+        const dirName = findProjectDirName(existingDirs, projectId);
+        if (!dirName) {
+            printProjectNotPulledLocally(stderr, projectId);
+            return 1;
+        }
+        const projectDirPath = await resolveContainedSafe(projectsRoot, dirName);
+        const drift = await checkProjectDrift({ readdirRecursive, readFile }, projectId, projectDirPath);
+        if (drift.never_pulled) {
+            printProjectNoStateFile(stderr, projectId);
+            return 1;
+        }
+        const dirty = drift.drift.filter((d) => d.status !== DriftStatuses.CLEAN);
+        if (dirty.length > 0) {
+            printLocalDrift(stderr, projectId, dirName, dirty);
+            return 1;
+        }
+        const state = (await readProjectState(projectDirPath));
+        const projectJsonPath = await resolveContainedSafe(projectDirPath, "project.json");
+        const project = await readJson(projectJsonPath);
+        const sourceProjectName = project ? entityDisplayName(project) : projectId;
+        const knownTargetProjectId = (await readProjectMappings(projectDirPath))?.environments[options.to]
+            ?.target_project_id;
+        let resolution;
+        try {
+            resolution = await resolveProjectRequirements(targetClient, { readFile }, {
+                projectDirPath,
+                envName: options.to,
+                targetWorkspaceId: targetEnv.workspace_id,
+                sourceProjectName,
+                state,
+                autoCreateProjects: Boolean(options.dryRun),
+                validateAuthMappings: false,
+            });
+        }
+        catch (err) {
+            if (!options.dryRun) {
+                printProjectError(stderr, projectId, sourceProjectName, err.message, knownTargetProjectId);
+                return 1;
+            }
+            anyUnresolved = true;
+            const error = {
+                reason: "project_error",
+                message: err.message,
+                targetProjectId: knownTargetProjectId,
+            };
+            if (!asJson) {
+                printEnvResolveProjectError(stdout, projectId, sourceProjectName, error);
+            }
+            projectViews.push({
+                projectId,
+                sourceProjectName,
+                unresolvedAuthentications: [],
+                autoResolvedAuthentications: [],
+                hasNewConfigKeys: false,
+                error,
+            });
+            continue;
+        }
+        if (resolution.status === "no_target_project_mapped") {
+            if (!options.dryRun) {
+                printNoTargetProjectMapped(stderr, sourceProjectName, projectId, options.to, resolution.mappingsPath);
+                return 1;
+            }
+            anyUnresolved = true;
+            const error = {
+                reason: "no_target_project_mapped",
+                mappingsPath: resolution.mappingsPath,
+            };
+            if (!asJson) {
+                printEnvResolveProjectError(stdout, projectId, sourceProjectName, error);
+            }
+            projectViews.push({
+                projectId,
+                sourceProjectName,
+                unresolvedAuthentications: [],
+                autoResolvedAuthentications: [],
+                hasNewConfigKeys: false,
+                error,
+            });
+            continue;
+        }
+        if (resolution.status === "invalid_auth_mappings") {
+            if (!options.dryRun) {
+                printInvalidAuthMappings(stderr, projectId, sourceProjectName, resolution.invalidAuthMappings);
+                return 1;
+            }
+            anyUnresolved = true;
+            const error = {
+                reason: "invalid_auth_mappings",
+                invalidAuthMappings: resolution.invalidAuthMappings,
+            };
+            if (!asJson) {
+                printEnvResolveProjectError(stdout, projectId, sourceProjectName, error);
+            }
+            projectViews.push({
+                projectId,
+                sourceProjectName,
+                unresolvedAuthentications: [],
+                autoResolvedAuthentications: [],
+                hasNewConfigKeys: false,
+                error,
+            });
+            continue;
+        }
+        const { unresolved } = resolution;
+        if (isFullyResolved(unresolved)) {
+            if (!asJson) {
+                printEnvResolveProjectFullyResolved(stdout, projectId, sourceProjectName);
+            }
+            projectViews.push({
+                projectId,
+                sourceProjectName,
+                unresolvedAuthentications: [],
+                autoResolvedAuthentications: [],
+                hasNewConfigKeys: false,
+            });
+            continue;
+        }
+        const autoResolvedViews = [];
+        const unresolvedViews = [];
+        const autoResolvedMappings = {};
+        for (const auth of unresolved.unresolvedAuthentications) {
+            const candidates = prioritizeAuths(matchAuthCandidates(auth, authentications));
+            if (options.autoResolve && candidates.length > 0) {
+                const chosen = candidates[0];
+                autoResolvedMappings[auth.authExportId] = chosen.id;
+                autoResolvedViews.push({ authExportId: auth.authExportId, title: auth.title, chosen });
+                continue;
+            }
+            unresolvedViews.push({
+                authExportId: auth.authExportId,
+                title: auth.title,
+                service: auth.service,
+                candidates,
+            });
+        }
+        if (Object.keys(autoResolvedMappings).length > 0) {
+            const mappingsFile = (await readProjectMappings(projectDirPath)) ?? { version: 1, environments: {} };
+            const mapping = mappingsFile.environments[options.to] ?? emptyMapping();
+            mapping.authentications = { ...mapping.authentications, ...autoResolvedMappings };
+            mappingsFile.environments[options.to] = mapping;
+            await writeProjectMappings(projectDirPath, mappingsFile);
+        }
+        if (unresolvedViews.length > 0 || unresolved.hasNewConfigKeys) {
+            anyUnresolved = true;
+        }
+        const projectView = {
+            projectId,
+            sourceProjectName,
+            unresolvedAuthentications: unresolvedViews,
+            autoResolvedAuthentications: autoResolvedViews,
+            hasNewConfigKeys: unresolved.hasNewConfigKeys,
+        };
+        projectViews.push(projectView);
+        if (!asJson) {
+            printEnvResolveProject(stdout, projectView);
+        }
+    }
+    if (asJson) {
+        printEnvResolveResultJson(stdout, {
+            projects: projectViews.map((p) => ({
+                project_id: p.projectId,
+                source_project_name: p.sourceProjectName,
+                fully_resolved: !p.error && p.unresolvedAuthentications.length === 0 && !p.hasNewConfigKeys,
+                unresolved_authentications: p.unresolvedAuthentications.map((auth) => ({
+                    auth_export_id: auth.authExportId,
+                    title: auth.title,
+                    service: auth.service,
+                    candidates: auth.candidates.map((c) => ({
+                        id: c.id,
+                        name: c.name,
+                        service: c.service,
+                        created: c.created,
+                        match_kind: c.matchKind,
+                    })),
+                })),
+                auto_resolved_authentications: p.autoResolvedAuthentications.map((auth) => ({
+                    auth_export_id: auth.authExportId,
+                    title: auth.title,
+                    chosen: {
+                        id: auth.chosen.id,
+                        name: auth.chosen.name,
+                        service: auth.chosen.service,
+                        created: auth.chosen.created,
+                        match_kind: auth.chosen.matchKind,
+                    },
+                })),
+                has_new_config_keys: p.hasNewConfigKeys,
+                ...(p.error ? { error: toEnvResolveProjectErrorJson(p.error) } : {}),
+            })),
+        });
+    }
+    return anyUnresolved ? 1 : 0;
+}
+function parseUuid(value, flagName) {
+    if (!isUuid(value)) {
+        throw new InvalidArgumentError(`${flagName} must be a UUID`);
+    }
+    return value;
+}
+function parseProjectIds(value, previous) {
+    if (!isUuid(value)) {
+        throw new InvalidArgumentError("--project must be a UUID");
+    }
+    return [...(previous ?? []), value];
+}
+async function readdirRecursiveReal(dirPath) {
+    try {
+        const entries = await fsReaddir(dirPath, { recursive: true, withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile())
+            .map((entry) => path.relative(dirPath, path.join(entry.parentPath, entry.name)));
+    }
+    catch {
+        return [];
+    }
+}
+function realDeps() {
+    return {
+        cwd: process.cwd(),
+        env: process.env,
+        createClient: (region, token) => createTrayClientForRegion(region, token),
+        readdir: (dir) => fsReaddir(dir),
+        readFile: (filePath) => fsReadFile(filePath, "utf8"),
+        readdirRecursive: (dir) => readdirRecursiveReal(dir),
+        stdout: (line) => console.log(line),
+        stderr: (line) => console.error(line),
+    };
+}
+export const envCommand = new Command("env").description("Manage target environments (environments.json)");
+envCommand
+    .command("add")
+    .description("Add a target environment")
+    .argument("<name>", "Environment name")
+    .requiredOption("-r, --region <region>", `Tray regions: ${PUBLIC_REGIONS.map(describeRegion).join(", ")}`, parseRegion)
+    .requiredOption("-w, --workspace-id <id>", "Tray workspace UUID", (value) => parseUuid(value, "--workspace-id"))
+    .option("-t, --token <token>", "Tray API token to store in ~/.tray/credentials.json")
+    .option("-f, --force-token", "overwrite an existing credentials entry for this workspace")
+    .action(async (name, opts) => {
+    const exitCode = await runEnvAdd(realDeps(), {
+        name,
+        region: opts.region,
+        workspaceId: opts.workspaceId,
+        token: opts.token,
+        forceToken: Boolean(opts.forceToken),
+    });
+    process.exitCode = exitCode;
+});
+envCommand
+    .command("list")
+    .description("List source and target environments with connectivity status")
+    .option("--format <format>", "human or json", parseFormat, OutputFormats.HUMAN)
+    .action(async (opts) => {
+    const exitCode = await runEnvList(realDeps(), { format: opts.format });
+    process.exitCode = exitCode;
+});
+envCommand
+    .command("remove")
+    .description("Remove a target environment and its per-project mappings")
+    .argument("<name>", "Environment name")
+    .option("--forget-credentials", "also remove the workspace's entry from credentials.json")
+    .action(async (name, opts) => {
+    const exitCode = await runEnvRemove(realDeps(), {
+        name,
+        forgetCredentials: Boolean(opts.forgetCredentials),
+    });
+    process.exitCode = exitCode;
+});
+envCommand
+    .command("resolve")
+    .description("Report unresolved auth requirements for a target env, with candidate matches")
+    .argument("<env-name>", "target environment name, e.g. \"staging\" (see `tray env list` for configured names)")
+    .option("-p, --project <id...>", "resolve only these project IDs", parseProjectIds)
+    .option("-t, --token <token>", "Tray API token (target environment)")
+    .option("--auto-resolve", "write the top-ranked candidate for each unresolved authentication into mappings.json")
+    .option("--dry-run", "auto-create a missing target project + scaffold mappings.json so a real check can run before ever promoting (writes those two things; never writes an auth pick — combine with --auto-resolve for that)")
+    .option("--format <format>", "human or json", parseFormat, OutputFormats.HUMAN)
+    .action(async (envName, opts) => {
+    const exitCode = await runEnvResolve(realDeps(), {
+        to: envName,
+        token: opts.token,
+        projectIds: opts.project,
+        autoResolve: Boolean(opts.autoResolve),
+        dryRun: Boolean(opts.dryRun),
+        format: opts.format,
+    });
+    process.exitCode = exitCode;
+});
+//# sourceMappingURL=env.js.map

package/dist/commands/init.js

@@ -0,0 +1,115 @@
+import { readdir as fsReaddir, rename as fsRename, rm as fsRm } from "node:fs/promises";
+import { Command, InvalidArgumentError } from "commander";
+import { createTrayClientForRegion } from "../api/trayClient.js";
+import { readCredentials, writeCredentials } from "../config/credentials.js";
+import { readTrayYaml, writeTrayYaml } from "../config/trayYaml.js";
+import { writeEnvironments } from "../config/environments.js";
+import { Scopes } from "../config/types.js";
+import { describeRegion } from "../lib/regionDisplay.js";
+import { PUBLIC_REGIONS, parseRegion } from "../lib/regionParsing.js";
+import { resolveToken } from "../lib/tokenResolution.js";
+import { isUuid } from "../lib/uuid.js";
+import { runPull } from "./pull.js";
+import { printConnectivityCheckFailed, printConnectivityCheckSucceeded, printNoTokenSkippingConnectivityAndPull, printTokenNotSaved, printTrayYamlAlreadyExists, } from "../views/init/init.js";
+const SCOPES = Object.values(Scopes);
+function parseScope(value) {
+    if (!SCOPES.includes(value)) {
+        throw new InvalidArgumentError(`scope must be one of: ${SCOPES.join(", ")}`);
+    }
+    return value;
+}
+function parseUuid(value, flagName) {
+    if (!isUuid(value)) {
+        throw new InvalidArgumentError(`${flagName} must be a UUID`);
+    }
+    return value;
+}
+function parseProjectIds(value, previous) {
+    return [...(previous ?? []), parseUuid(value, "--project")];
+}
+export async function runInit(deps, options) {
+    const { cwd, env, createClient, readdir, rm, rename, stdout, stderr } = deps;
+    const existing = await readTrayYaml(cwd);
+    if (existing) {
+        printTrayYamlAlreadyExists(stderr);
+        return 1;
+    }
+    await writeTrayYaml({
+        version: 1,
+        scope: options.scope,
+        region: options.region,
+        workspace_id: options.workspaceId,
+        projects: options.scope === Scopes.PROJECT ? (options.projectIds ?? []) : [],
+    }, cwd);
+    await writeEnvironments({ version: 1, environments: {} }, cwd);
+    if (options.token) {
+        const credentials = await readCredentials(env);
+        const alreadySet = credentials.workspaces[options.workspaceId] !== undefined;
+        if (!alreadySet || options.forceToken) {
+            credentials.workspaces[options.workspaceId] = {
+                region: options.region,
+                token: options.token,
+            };
+            await writeCredentials(credentials, env);
+        }
+        else {
+            printTokenNotSaved(stderr, options.workspaceId, options.region);
+        }
+    }
+    let token;
+    try {
+        const credentials = await readCredentials(env);
+        token = resolveToken({
+            tokenFlag: options.token,
+            credentials,
+            workspaceId: options.workspaceId,
+            env,
+        });
+    }
+    catch {
+        printNoTokenSkippingConnectivityAndPull(stdout);
+        return 0;
+    }
+    const client = createClient(options.region, token);
+    try {
+        await client.request("GET", `/v2/projects/workspaces/${options.workspaceId}`);
+        printConnectivityCheckSucceeded(stdout);
+    }
+    catch (err) {
+        printConnectivityCheckFailed(stdout, err.message);
+    }
+    const shouldPull = options.scope === Scopes.WORKSPACE || (options.projectIds?.length ?? 0) > 0;
+    if (!shouldPull) {
+        return 0;
+    }
+    return runPull({ cwd, createClient, readdir, rm, rename, stdout }, { token, projectIds: options.scope === Scopes.PROJECT ? options.projectIds : undefined });
+}
+export const initCommand = new Command("init")
+    .description("Scaffold a new tray-sync-cli repository")
+    .requiredOption("-r, --region <region>", `Tray regions: ${PUBLIC_REGIONS.map(describeRegion).join(", ")}`, parseRegion)
+    .requiredOption("-w, --workspace-id <id>", "Tray workspace UUID", (value) => parseUuid(value, "--workspace-id"))
+    .option("-s, --scope <scope>", "project or workspace", parseScope, Scopes.PROJECT)
+    .option("-p, --project <id...>", "project scope only: pull these project IDs after scaffolding (ignored in workspace scope, which pulls all projects)", parseProjectIds)
+    .option("-t, --token <token>", "Tray API token to store in ~/.tray/credentials.json")
+    .option("-f, --force-token", "overwrite an existing credentials entry for this workspace")
+    .action(async (opts) => {
+    const exitCode = await runInit({
+        cwd: process.cwd(),
+        env: process.env,
+        createClient: (region, token) => createTrayClientForRegion(region, token),
+        readdir: (dir) => fsReaddir(dir),
+        rm: (dir) => fsRm(dir, { recursive: true, force: true }),
+        rename: (oldPath, newPath) => fsRename(oldPath, newPath),
+        stdout: (line) => console.log(line),
+        stderr: (line) => console.error(line),
+    }, {
+        scope: opts.scope,
+        region: opts.region,
+        workspaceId: opts.workspaceId,
+        projectIds: opts.project,
+        token: opts.token,
+        forceToken: Boolean(opts.forceToken),
+    });
+    process.exitCode = exitCode;
+});
+//# sourceMappingURL=init.js.map