@trayai/tray-sync-cli 0.0.1

package/dist/commands/project.js

@@ -0,0 +1,175 @@
+import path from "node:path";
+import { readdir as fsReaddir, rm as fsRm } from "node:fs/promises";
+import { Command, InvalidArgumentError } from "commander";
+import { createTrayClientForRegion } from "../api/trayClient.js";
+import { readCredentials } from "../config/credentials.js";
+import { readProjectState } from "../config/state.js";
+import { readTrayYaml, writeTrayYaml } from "../config/trayYaml.js";
+import { Scopes } from "../config/types.js";
+import { resolveToken } from "../lib/tokenResolution.js";
+import { isUuid } from "../lib/uuid.js";
+import { OutputFormats, parseFormat } from "../lib/outputFormat.js";
+import { printAddedProject, printAlreadyTracked, printLastPulled, printNoProjectsTracked, printNotPulledLocally, printNotTracked, printRemovedProject, printTrayYamlNotFound, printValidationSkippedOrFailed, printValidationSucceeded, printWorkspaceScopeDenied, } from "../views/project/project.js";
+import { printProjectListJson } from "../views/project/shared.js";
+function findProjectDir(existingDirs, projectId) {
+    return existingDirs.find((name) => name.split("--")[0] === projectId);
+}
+async function requireTrayYaml(deps) {
+    const trayYaml = await readTrayYaml(deps.cwd);
+    if (!trayYaml) {
+        printTrayYamlNotFound(deps.stderr);
+        return null;
+    }
+    return trayYaml;
+}
+function refuseIfWorkspaceScope(trayYaml, stderr) {
+    if (trayYaml.scope !== Scopes.WORKSPACE)
+        return false;
+    printWorkspaceScopeDenied(stderr);
+    return true;
+}
+async function listProjectDirs(readdir, projectsRoot) {
+    try {
+        return await readdir(projectsRoot);
+    }
+    catch {
+        return [];
+    }
+}
+export async function runProjectAdd(deps, options) {
+    const { cwd, env, createClient, stdout, stderr } = deps;
+    const trayYaml = await requireTrayYaml(deps);
+    if (!trayYaml)
+        return 1;
+    if (refuseIfWorkspaceScope(trayYaml, stderr))
+        return 1;
+    if (trayYaml.projects.includes(options.projectId)) {
+        printAlreadyTracked(stdout, options.projectId);
+        return 0;
+    }
+    const credentials = await readCredentials(env);
+    try {
+        const token = resolveToken({
+            tokenFlag: options.token,
+            credentials,
+            workspaceId: trayYaml.workspace_id,
+            env,
+        });
+        const client = createClient(trayYaml.region, token);
+        await client.request("GET", `/v2/projects/${options.projectId}`);
+        printValidationSucceeded(stdout, options.projectId);
+    }
+    catch (err) {
+        printValidationSkippedOrFailed(stdout, err.message);
+    }
+    const projects = [...trayYaml.projects, options.projectId].sort();
+    await writeTrayYaml({ ...trayYaml, projects }, cwd);
+    printAddedProject(stdout, options.projectId);
+    return 0;
+}
+export async function runProjectRemove(deps, options) {
+    const { cwd, readdir, rm, stdout, stderr } = deps;
+    const trayYaml = await requireTrayYaml(deps);
+    if (!trayYaml)
+        return 1;
+    if (refuseIfWorkspaceScope(trayYaml, stderr))
+        return 1;
+    if (!trayYaml.projects.includes(options.projectId)) {
+        printNotTracked(stdout, options.projectId);
+        return 0;
+    }
+    const projects = trayYaml.projects.filter((id) => id !== options.projectId);
+    await writeTrayYaml({ ...trayYaml, projects }, cwd);
+    const projectsRoot = path.join(cwd, "projects");
+    const existingDirs = await listProjectDirs(readdir, projectsRoot);
+    const dirName = findProjectDir(existingDirs, options.projectId);
+    if (dirName) {
+        await rm(path.join(projectsRoot, dirName));
+    }
+    printRemovedProject(stdout, options.projectId, Boolean(dirName));
+    return 0;
+}
+export async function runProjectList(deps, options) {
+    const { cwd, readdir, stdout } = deps;
+    const trayYaml = await requireTrayYaml(deps);
+    if (!trayYaml)
+        return 1;
+    const projectsRoot = path.join(cwd, "projects");
+    const existingDirs = await listProjectDirs(readdir, projectsRoot);
+    if (options.format === OutputFormats.JSON) {
+        const rows = [];
+        for (const projectId of trayYaml.projects) {
+            const dirName = findProjectDir(existingDirs, projectId);
+            if (!dirName) {
+                rows.push({ project_id: projectId, dir_name: null, last_sync: null });
+                continue;
+            }
+            const state = await readProjectState(path.join(projectsRoot, dirName));
+            rows.push({ project_id: projectId, dir_name: dirName, last_sync: state?.last_sync ?? null });
+        }
+        printProjectListJson(stdout, rows);
+        return 0;
+    }
+    if (trayYaml.projects.length === 0) {
+        printNoProjectsTracked(stdout);
+        return 0;
+    }
+    for (const projectId of trayYaml.projects) {
+        const dirName = findProjectDir(existingDirs, projectId);
+        if (!dirName) {
+            printNotPulledLocally(stdout, projectId);
+            continue;
+        }
+        const state = await readProjectState(path.join(projectsRoot, dirName));
+        const lastSync = state?.last_sync ?? "never";
+        printLastPulled(stdout, dirName, lastSync);
+    }
+    return 0;
+}
+function parseUuid(value, flagName) {
+    if (!isUuid(value)) {
+        throw new InvalidArgumentError(`${flagName} must be a UUID`);
+    }
+    return value;
+}
+function realDeps() {
+    return {
+        cwd: process.cwd(),
+        env: process.env,
+        createClient: (region, token) => createTrayClientForRegion(region, token),
+        readdir: (dir) => fsReaddir(dir),
+        rm: (dir) => fsRm(dir, { recursive: true, force: true }),
+        stdout: (line) => console.log(line),
+        stderr: (line) => console.error(line),
+    };
+}
+export const projectCommand = new Command("project").description("Manage tray.yaml.projects (project scope only for add/remove)");
+projectCommand
+    .command("add")
+    .description("Track a project (project scope only)")
+    .argument("<project-id>", "Tray project UUID", (value) => parseUuid(value, "project-id"))
+    .option("-t, --token <token>", "Tray API token, for best-effort validation")
+    .action(async (projectId, opts) => {
+    const exitCode = await runProjectAdd(realDeps(), {
+        projectId,
+        token: opts.token,
+    });
+    process.exitCode = exitCode;
+});
+projectCommand
+    .command("remove")
+    .description("Untrack a project and delete its local directory (project scope only)")
+    .argument("<project-id>", "Tray project UUID", (value) => parseUuid(value, "project-id"))
+    .action(async (projectId) => {
+    const exitCode = await runProjectRemove(realDeps(), { projectId });
+    process.exitCode = exitCode;
+});
+projectCommand
+    .command("list")
+    .description("List managed projects with directory names and last-pulled timestamps")
+    .option("--format <format>", "human or json", parseFormat, OutputFormats.HUMAN)
+    .action(async (opts) => {
+    const exitCode = await runProjectList(realDeps(), { format: opts.format });
+    process.exitCode = exitCode;
+});
+//# sourceMappingURL=project.js.map

package/dist/commands/promote.js

@@ -0,0 +1,289 @@
+import path from "node:path";
+import { readdir as fsReaddir, readFile as fsReadFile, rm as fsRm } from "node:fs/promises";
+import { Command, InvalidArgumentError } from "commander";
+import { createTrayClientForRegion } from "../api/trayClient.js";
+import { readCredentials } from "../config/credentials.js";
+import { readEnvironments } from "../config/environments.js";
+import { readProjectMappings } from "../config/mappings.js";
+import { promoteProgressPath } from "../config/paths.js";
+import { readJson, writeJson } from "../config/io.js";
+import { readProjectState } from "../config/state.js";
+import { readTrayYaml } from "../config/trayYaml.js";
+import { resolveContainedSafe } from "../lib/pathContainment.js";
+import { entityDisplayName } from "../lib/exportStructure.js";
+import { importProject, previewImport } from "../lib/promoteExecute.js";
+import { printProjectImportImpact, toProjectImportImpact, } from "../lib/promoteReport.js";
+import { isFullyResolved, resolveProjectRequirements, scaffoldUnresolvedAuthentications, } from "../lib/promoteTarget.js";
+import { resolveToken } from "../lib/tokenResolution.js";
+import { isUuid } from "../lib/uuid.js";
+import { OutputFormats, parseFormat } from "../lib/outputFormat.js";
+import { checkProjectDrift, DriftStatuses } from "./status.js";
+import { printError, printInvalidAuthMappings, printLocalDrift, printMutuallyExclusiveResumeAndProject, printNoTargetProjectMapped, printProjectError, printProjectNoStateFile, printProjectNotPulledLocally, printPromoted, printTargetEnvNotFound, printTrayYamlNotFound, printUnresolvedRequirements, } from "../views/promote/promote.js";
+import { printPromoteResultJson } from "../views/promote/shared.js";
+function findProjectDir(existingDirs, projectId) {
+    return existingDirs.find((name) => name.split("--")[0] === projectId);
+}
+function newPromoteProgress(trayYaml, planned) {
+    return {
+        pull_id: `${trayYaml.workspace_id}-${planned.length}`,
+        started_at: new Date().toISOString(),
+        workspace_id: trayYaml.workspace_id,
+        region: trayYaml.region,
+        planned,
+        completed: [],
+        failed: [],
+    };
+}
+export async function runPromote(deps, options) {
+    const { cwd, env, createClient, readdir, readFile, readdirRecursive, rm, stdout, stderr } = deps;
+    const asJson = options.format === OutputFormats.JSON;
+    const promoted = [];
+    function fail(error) {
+        if (asJson) {
+            printPromoteResultJson(stdout, { dry_run: Boolean(options.dryRun), promoted, error });
+        }
+        return 1;
+    }
+    if (options.resume && options.projectIds && options.projectIds.length > 0) {
+        if (asJson)
+            return fail({ reason: "mutually_exclusive_resume_and_project" });
+        printMutuallyExclusiveResumeAndProject(stderr);
+        return 1;
+    }
+    const trayYaml = await readTrayYaml(cwd);
+    if (!trayYaml) {
+        if (asJson)
+            return fail({ reason: "tray_yaml_not_found" });
+        printTrayYamlNotFound(stderr);
+        return 1;
+    }
+    const environments = await readEnvironments(cwd);
+    const targetEnv = environments.environments[options.to];
+    if (!targetEnv) {
+        if (asJson)
+            return fail({ reason: "target_env_not_found", env_name: options.to });
+        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) {
+        if (asJson)
+            return fail({ reason: "token_resolution_failed", message: err.message });
+        printError(stderr, err.message);
+        return 1;
+    }
+    const targetClient = createClient(targetEnv.region, targetToken);
+    const targeted = options.projectIds !== undefined && options.projectIds.length > 0;
+    let plannedIds = targeted ? options.projectIds : trayYaml.projects;
+    let progress;
+    if (!options.dryRun) {
+        if (options.resume) {
+            progress = await readJson(promoteProgressPath(cwd));
+            if (progress) {
+                plannedIds = progress.planned;
+            }
+            else {
+                progress = newPromoteProgress(trayYaml, plannedIds);
+                await writeJson(promoteProgressPath(cwd), progress);
+            }
+        }
+        else {
+            progress = newPromoteProgress(trayYaml, plannedIds);
+            await writeJson(promoteProgressPath(cwd), progress);
+        }
+    }
+    const alreadyCompleted = new Set(progress?.completed ?? []);
+    const projectsRoot = path.join(cwd, "projects");
+    let existingDirs;
+    try {
+        existingDirs = await readdir(projectsRoot);
+    }
+    catch {
+        existingDirs = [];
+    }
+    for (const projectId of plannedIds) {
+        if (alreadyCompleted.has(projectId)) {
+            continue;
+        }
+        const dirName = findProjectDir(existingDirs, projectId);
+        if (!dirName) {
+            if (asJson)
+                return fail({ reason: "project_not_pulled_locally", project_id: projectId });
+            printProjectNotPulledLocally(stderr, projectId);
+            return 1;
+        }
+        const projectDirPath = await resolveContainedSafe(projectsRoot, dirName);
+        const drift = await checkProjectDrift({ readdirRecursive, readFile }, projectId, projectDirPath);
+        if (drift.never_pulled) {
+            if (asJson)
+                return fail({ reason: "project_no_state_file", project_id: projectId });
+            printProjectNoStateFile(stderr, projectId);
+            return 1;
+        }
+        const dirty = drift.drift.filter((d) => d.status !== DriftStatuses.CLEAN);
+        if (dirty.length > 0) {
+            if (asJson) {
+                return fail({ reason: "local_drift", project_id: projectId, dir_name: dirName, drift: dirty });
+            }
+            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;
+        let knownTargetProjectId = (await readProjectMappings(projectDirPath))
+            ?.environments[options.to]?.target_project_id;
+        try {
+            const resolution = await resolveProjectRequirements(targetClient, { readFile }, {
+                projectDirPath,
+                envName: options.to,
+                targetWorkspaceId: targetEnv.workspace_id,
+                sourceProjectName,
+                state,
+                autoCreateProjects: Boolean(options.autoCreateProjects) && !options.dryRun,
+            });
+            if (resolution.status === "no_target_project_mapped") {
+                if (asJson) {
+                    return fail({
+                        reason: "no_target_project_mapped",
+                        project_id: projectId,
+                        source_project_name: sourceProjectName,
+                        env_name: options.to,
+                        mappings_path: resolution.mappingsPath,
+                    });
+                }
+                printNoTargetProjectMapped(stderr, sourceProjectName, projectId, options.to, resolution.mappingsPath);
+                return 1;
+            }
+            if (resolution.status === "invalid_auth_mappings") {
+                if (asJson) {
+                    return fail({
+                        reason: "invalid_auth_mappings",
+                        project_id: projectId,
+                        source_project_name: sourceProjectName,
+                        invalid_auth_mappings: resolution.invalidAuthMappings,
+                    });
+                }
+                printInvalidAuthMappings(stderr, projectId, sourceProjectName, resolution.invalidAuthMappings);
+                return 1;
+            }
+            const { targetProjectId, payload, unresolved } = resolution;
+            knownTargetProjectId = targetProjectId;
+            if (!isFullyResolved(unresolved)) {
+                await scaffoldUnresolvedAuthentications(projectDirPath, options.to, unresolved);
+                if (asJson) {
+                    return fail({
+                        reason: "unresolved_requirements",
+                        project_id: projectId,
+                        source_project_name: sourceProjectName,
+                        env_name: options.to,
+                        unresolved_authentications: unresolved.unresolvedAuthentications,
+                        has_new_config_keys: unresolved.hasNewConfigKeys,
+                    });
+                }
+                printUnresolvedRequirements(stderr, projectId, sourceProjectName, options.to, unresolved);
+                return 1;
+            }
+            const preview = await previewImport(targetClient, targetProjectId, payload);
+            const impact = toProjectImportImpact(sourceProjectName, projectId, preview.projectImpact);
+            if (asJson) {
+                promoted.push(impact);
+            }
+            else {
+                printProjectImportImpact(stdout, impact);
+            }
+            if (options.dryRun) {
+                continue;
+            }
+            await importProject(targetClient, targetProjectId, payload);
+            if (!asJson) {
+                printPromoted(stdout, projectId, sourceProjectName, options.to);
+            }
+        }
+        catch (err) {
+            if (asJson) {
+                return fail({
+                    reason: "project_error",
+                    project_id: projectId,
+                    source_project_name: sourceProjectName,
+                    message: err.message,
+                    target_project_id: knownTargetProjectId,
+                });
+            }
+            printProjectError(stderr, projectId, sourceProjectName, err.message, knownTargetProjectId);
+            return 1;
+        }
+        if (progress) {
+            progress = { ...progress, completed: [...progress.completed, projectId] };
+            await writeJson(promoteProgressPath(cwd), progress);
+        }
+    }
+    if (progress) {
+        await rm(promoteProgressPath(cwd)).catch(() => { });
+    }
+    if (asJson) {
+        printPromoteResultJson(stdout, { dry_run: Boolean(options.dryRun), promoted });
+    }
+    return 0;
+}
+function parseUuid(value, previous) {
+    if (!isUuid(value)) {
+        throw new InvalidArgumentError("--project must be a UUID");
+    }
+    return [...(previous ?? []), value];
+}
+export const promoteCommand = new Command("promote")
+    .description("Reconstruct local projects and import them into a target Tray environment")
+    .requiredOption("--to <env>", "target environment name (see `tray env list`)")
+    .option("-p, --project <id...>", "promote only these project IDs", parseUuid)
+    .option("--resume", "resume a previously interrupted promote")
+    .option("--dry-run", "report what would change without creating projects or importing")
+    .option("--auto-create-projects", "create the target project when no mapping exists yet")
+    .option("-t, --token <token>", "Tray API token (used for both source and target)")
+    .option("--format <format>", "human or json", parseFormat, OutputFormats.HUMAN)
+    .action(async (opts) => {
+    const cwd = process.cwd();
+    const exitCode = await runPromote({
+        cwd,
+        env: process.env,
+        createClient: (region, token) => createTrayClientForRegion(region, token),
+        readdir: (dir) => fsReaddir(dir),
+        readFile: (filePath) => fsReadFile(filePath, "utf8"),
+        readdirRecursive: (dir) => readdirRecursiveReal(dir),
+        rm: (filePath) => fsRm(filePath, { force: true }),
+        stdout: (line) => console.log(line),
+        stderr: (line) => console.error(line),
+    }, {
+        to: opts.to,
+        token: opts.token,
+        projectIds: opts.project,
+        resume: Boolean(opts.resume),
+        dryRun: Boolean(opts.dryRun),
+        autoCreateProjects: Boolean(opts.autoCreateProjects),
+        format: opts.format,
+    });
+    process.exitCode = exitCode;
+});
+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 [];
+    }
+}
+//# sourceMappingURL=promote.js.map