@trayai/tray-sync-cli 1.0.1 → 1.0.2

package/README.md

@@ -25,6 +25,7 @@ npm install -g @trayai/tray-sync-cli
 | `tray env add <name>` | Add a target environment |
 | `tray env list` | List source and target environments with connectivity status |
 | `tray env remove <name>` | Remove a target environment and its per-project mappings |
+| `tray env discover [env]` | List an env's projects (id + name, default) and/or matching authentications — `env` defaults to `source` |
 | `tray env resolve <env-name>` | Report unresolved auth requirements for a target env, with candidate matches |
 | `tray auth set -w <workspace-id> -r <region> -t <token>` | Set (or overwrite) a workspace's token |
 | `tray auth remove -w <workspace-id>` | Remove a workspace's stored token |
@@ -66,6 +67,14 @@ Example:
 tray init -r us1 -w 11111111-1111-1111-1111-111111111111 -t <token> -p <project_id>
 ```
 
+Don't know the project ID yet? Run `init` without `-p` (an empty scaffold is fine), then:
+
+```bash
+tray env discover
+```
+
+lists every project in your source workspace — id + name — so you don't have to dig it out of Tray's UI.
+
 A few notes on the flags:
 
 - **`-p <project-id>`** pulls that project immediately after scaffolding. Omit it and `init` just scaffolds an empty repository — you can pull specific projects later with: `tray pull -p <project_id>` OR  `tray project add <project-id>` followed by `tray pull`. 

package/dist/commands/env.js

@@ -15,14 +15,15 @@ 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 { dedupeUsedAuths, listWorkspaceAuthentications, matchAuthCandidates, prioritizeAuths, usedAuthsInProject, } 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, printSourceEnvTable, printTargetEnvHeader, printTargetEnvTable, printTokenNotSaved, printTrayYamlNotFound, } from "../views/env/env.v2.js";
+import { printAddedEnvironment, printConnectivityCheck, printDiscoverAuthsHeader, printDiscoverEnvHeader, printDiscoverNoAuthsUsed, printDiscoverNoProjects, printDiscoverProjectsTable, printEnvAlreadyExists, printEnvNotConfigured, printEnvNotFound, printEnvResolveProject, printReservedEnvName, printEnvResolveProjectFullyResolved, printInvalidEnvName, printNoTargetEnvironments, printNoTokenSkippingConnectivity, printRemovedCredentials, printRemovedEnvironment, printEnvResolveProjectError, printRemovedMapping, printSourceAuthsTable, printSourceEnvTable, printTargetAuthsTable, printTargetEnvHeader, printTargetEnvTable, printTokenNotSaved, printTrayYamlNotFound, } from "../views/env/env.v2.js";
 import { printEnvListJson, printEnvResolveResultJson, } from "../views/env/shared.js";
 import { printError, printInvalidAuthMappings, printLocalDrift, printNoTargetProjectMapped, printProjectError, printProjectNoStateFile, printProjectNotPulledLocally, printTargetEnvNotFound, } from "../views/promote/promote.v2.js";
 import { FAILURE_ICON, SUCCESS_ICON } from "../views/icons.js";
 const ENV_NAME_RE = /^[a-zA-Z0-9_-]+$/;
+export const SOURCE_ENV_NAME = "source";
 function emptyMapping() {
     return { authentications: {}, config: {}, connectors: [], services: [] };
 }
@@ -60,6 +61,10 @@ export async function runEnvAdd(deps, options) {
         printInvalidEnvName(stderr, ENV_NAME_RE, options.name);
         return 1;
     }
+    if (options.name === SOURCE_ENV_NAME) {
+        printReservedEnvName(stderr, options.name);
+        return 1;
+    }
     const environments = await readEnvironments(cwd);
     if (environments.environments[options.name]) {
         printEnvAlreadyExists(stderr, options.name);
@@ -194,6 +199,119 @@ export async function runEnvRemove(deps, options) {
     }
     return 0;
 }
+async function listProjectsWithNames(client, workspaceId) {
+    const result = (await client.request("GET", `/v2/projects/workspaces/${workspaceId}`));
+    return result.projects;
+}
+function resolveDiscoverTarget(envName, trayYaml, environments) {
+    if (envName === SOURCE_ENV_NAME) {
+        return { region: trayYaml.region, workspaceId: trayYaml.workspace_id };
+    }
+    const entry = environments.environments[envName];
+    if (!entry)
+        return undefined;
+    return { region: entry.region, workspaceId: entry.workspace_id };
+}
+async function usedAuthsAcrossLocalProjects(deps, cwd, projectIds) {
+    const projectsRoot = path.join(cwd, "projects");
+    let existingDirs;
+    try {
+        existingDirs = await deps.readdir(projectsRoot);
+    }
+    catch {
+        existingDirs = [];
+    }
+    const used = [];
+    for (const projectId of projectIds) {
+        const dirName = existingDirs.find((name) => name.split("--")[0] === projectId);
+        if (!dirName)
+            continue;
+        const projectDirPath = path.join(projectsRoot, dirName);
+        const projectFiles = await deps.readdirRecursive(projectDirPath);
+        used.push(...(await usedAuthsInProject(deps.readFile, projectDirPath, projectFiles)));
+    }
+    return dedupeUsedAuths(used);
+}
+export async function runEnvDiscover(deps, options) {
+    const { cwd, env, createClient, readdir, readFile, readdirRecursive, stdout, stderr } = deps;
+    const trayYaml = await readTrayYaml(cwd);
+    if (!trayYaml) {
+        printTrayYamlNotFound(stderr);
+        return 1;
+    }
+    const environments = await readEnvironments(cwd);
+    const target = resolveDiscoverTarget(options.env, trayYaml, environments);
+    if (!target) {
+        printEnvNotFound(stderr, options.env);
+        return 1;
+    }
+    const credentials = await readCredentials(env);
+    let token;
+    try {
+        token = resolveToken({
+            tokenFlag: options.token,
+            credentials,
+            workspaceId: target.workspaceId,
+            envName: options.env === SOURCE_ENV_NAME ? undefined : options.env,
+            env,
+        });
+    }
+    catch (err) {
+        printError(stderr, err.message);
+        return 1;
+    }
+    const client = createClient(target.region, token);
+    const showProjects = options.all || options.projects || (!options.projects && !options.authentications);
+    const showAuths = Boolean(options.all || options.authentications);
+    const isSource = options.env === SOURCE_ENV_NAME;
+    printDiscoverEnvHeader(stdout, options.env, isSource);
+    if (showProjects) {
+        const projects = await listProjectsWithNames(client, target.workspaceId);
+        const rows = projects
+            .map((p) => ({ id: p.id, name: p.name }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+        if (rows.length === 0) {
+            printDiscoverNoProjects(stdout, options.env);
+        }
+        else {
+            printDiscoverProjectsTable(stdout, rows);
+        }
+    }
+    if (showAuths) {
+        const used = await usedAuthsAcrossLocalProjects({ readdir, readFile, readdirRecursive }, cwd, trayYaml.projects);
+        if (used.length === 0) {
+            printDiscoverNoAuthsUsed(stdout);
+        }
+        else {
+            const { authentications } = await listWorkspaceAuthentications(client, target.region, target.workspaceId);
+            printDiscoverAuthsHeader(stdout);
+            if (isSource) {
+                const rows = used.map((requirement) => {
+                    const self = authentications.find((a) => a.group === requirement.group);
+                    return { name: self?.name ?? requirement.title, id: self?.id ?? "", service: requirement.service };
+                });
+                rows.sort((a, b) => a.service.name.localeCompare(b.service.name) || a.name.localeCompare(b.name));
+                printSourceAuthsTable(stdout, rows);
+            }
+            else {
+                const matchedTitlesByCandidateId = new Map();
+                for (const requirement of used) {
+                    for (const candidate of matchAuthCandidates(requirement, authentications)) {
+                        const titles = matchedTitlesByCandidateId.get(candidate.id) ?? [];
+                        titles.push(requirement.title);
+                        matchedTitlesByCandidateId.set(candidate.id, titles);
+                    }
+                }
+                const rows = authentications
+                    .filter((a) => matchedTitlesByCandidateId.has(a.id))
+                    .map((a) => ({ name: a.name, id: a.id, service: a.service, matchedTitles: matchedTitlesByCandidateId.get(a.id) }));
+                rows.sort((a, b) => a.service.name.localeCompare(b.service.name) || a.name.localeCompare(b.name));
+                printTargetAuthsTable(stdout, rows);
+            }
+        }
+    }
+    return 0;
+}
 function findProjectDirName(existingDirs, projectId) {
     return existingDirs.find((name) => name.split("--")[0] === projectId);
 }
@@ -310,7 +428,7 @@ export async function runEnvResolve(deps, options) {
         }
         if (resolution.status === "no_target_project_mapped") {
             if (!options.dryRun) {
-                printNoTargetProjectMapped(stderr, sourceProjectName, projectId, options.to, resolution.mappingsPath);
+                printNoTargetProjectMapped(stderr, sourceProjectName, projectId, options.to, resolution.mappingsPath, "env resolve");
                 return 1;
             }
             anyUnresolved = true;
@@ -518,6 +636,24 @@ envCommand
     });
     process.exitCode = exitCode;
 });
+envCommand
+    .command("discover")
+    .description("List available projects and/or authentications for an env (default: source) — --projects (default) shows name+id; --authentications shows workspace auths matching what locally pulled projects use; --all shows both")
+    .argument("[env]", `"${SOURCE_ENV_NAME}" (default) or a target environment name (see \`tray env list\`)`, SOURCE_ENV_NAME)
+    .option("--projects", "list the env's projects (name + id) — the default when no flag is given")
+    .option("--authentications", "list authentications in the env's workspace matching what locally pulled source projects use")
+    .option("--all", "shorthand for --projects and --authentications together")
+    .option("-t, --token <token>", "Tray API token")
+    .action(async (envName, opts) => {
+    const exitCode = await runEnvDiscover(realDeps(), {
+        env: envName,
+        token: opts.token,
+        projects: Boolean(opts.projects),
+        authentications: Boolean(opts.authentications),
+        all: Boolean(opts.all),
+    });
+    process.exitCode = exitCode;
+});
 envCommand
     .command("resolve")
     .description("Report unresolved auth requirements for a target env, with candidate matches")

package/dist/commands/promote.js

@@ -163,7 +163,7 @@ export async function runPromote(deps, options) {
                         mappings_path: resolution.mappingsPath,
                     });
                 }
-                printNoTargetProjectMapped(stderr, sourceProjectName, projectId, options.to, resolution.mappingsPath);
+                printNoTargetProjectMapped(stderr, sourceProjectName, projectId, options.to, resolution.mappingsPath, "promote");
                 return 1;
             }
             if (resolution.status === "invalid_auth_mappings") {

package/dist/lib/authDiscovery.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import path from "node:path";
 import { urlsForRegion } from "./region.js";
 const GET_AUTHENTICATIONS_QUERY = `
   query GetAuthenticationsPrivate(
@@ -73,4 +74,56 @@ export function matchAuthCandidates(requirement, authentications) {
 export function prioritizeAuths(candidates) {
     return candidates;
 }
+export function extractUsedAuths(workflow) {
+    const steps = workflow.steps;
+    if (typeof steps !== "object" || steps === null) {
+        return [];
+    }
+    const used = [];
+    for (const step of Object.values(steps)) {
+        if (typeof step !== "object" || step === null)
+            continue;
+        const authentication = step.authentication;
+        if (typeof authentication !== "object" || authentication === null)
+            continue;
+        const auth = authentication;
+        const group = auth.group;
+        const title = auth.title;
+        const serviceName = auth.service_name;
+        const serviceVersion = auth.service_version;
+        if (typeof group !== "string" ||
+            typeof title !== "string" ||
+            typeof serviceName !== "string" ||
+            (typeof serviceVersion !== "string" && typeof serviceVersion !== "number")) {
+            continue;
+        }
+        used.push({ group, title, service: { name: serviceName, version: String(serviceVersion) } });
+    }
+    return used;
+}
+export function dedupeUsedAuths(used) {
+    const seen = new Map();
+    for (const auth of used) {
+        if (!seen.has(auth.group)) {
+            seen.set(auth.group, auth);
+        }
+    }
+    return [...seen.values()];
+}
+export async function usedAuthsInProject(readFile, projectDirPath, projectFiles) {
+    const workflowJsonPaths = projectFiles.filter((relativePath) => relativePath.startsWith(`workflows${path.sep}`) && relativePath.endsWith(`${path.sep}workflow.json`));
+    const used = [];
+    for (const relativePath of workflowJsonPaths) {
+        let workflow;
+        try {
+            const raw = await readFile(path.join(projectDirPath, relativePath));
+            workflow = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        used.push(...extractUsedAuths(workflow));
+    }
+    return used;
+}
 //# sourceMappingURL=authDiscovery.js.map

package/dist/views/env/env.v2.js

@@ -1,9 +1,12 @@
 import ansis from "ansis";
 import Table from "cli-table3";
-import { FAILURE_ICON, INFO_ICON, WARNING_ICON } from "../icons.js";
+import { FAILURE_ICON, INFO_ICON, SUCCESS_ICON, WARNING_ICON } from "../icons.js";
 export function printInvalidEnvName(stderr, nameRe, name) {
     stderr(`${FAILURE_ICON} Environment name must match ${nameRe}: "${name}"`);
 }
+export function printReservedEnvName(stderr, name) {
+    stderr(`${FAILURE_ICON} "${ansis.bold(name)}" is reserved (used by \`${ansis.bold("tray env discover")}\` to mean the source workspace) and cannot be a target environment name.`);
+}
 export function printEnvAlreadyExists(stderr, name) {
     stderr(`${FAILURE_ICON} Environment "${ansis.bold(name)}" already exists. Run \`${ansis.bold("tray env remove")}\` first to replace it.`);
 }
@@ -34,6 +37,9 @@ export function printConnectivityCheck(stdout, description) {
 export function printTrayYamlNotFound(stderr) {
     stderr(`${FAILURE_ICON} tray.yaml not found. Run \`${ansis.bold("tray init")}\` first.`);
 }
+export function printEnvNotFound(stderr, name) {
+    stderr(`${FAILURE_ICON} "${ansis.bold(name)}" is not "${ansis.bold("source")}" and is not a configured target environment. See \`${ansis.bold("tray env list")}\` for configured names.`);
+}
 function envTable() {
     return new Table({
         head: ["Environment", "Region", "Workspace ID", "Status"].map((h) => ansis.bold(h)),
@@ -73,7 +79,7 @@ export function printRemovedCredentials(stdout, workspaceId) {
     stdout(`${ansis.bold("Removed")} credentials for workspace ${workspaceId}.`);
 }
 export function printEnvResolveProjectFullyResolved(stdout, projectId, sourceProjectName) {
-    stdout(`${ansis.bold(`${sourceProjectName} (${projectId})`)}: fully resolved, nothing to do`);
+    stdout(`${SUCCESS_ICON} ${ansis.bold(`${sourceProjectName} (${projectId})`)}: fully resolved, nothing to do`);
 }
 export function printEnvResolveProjectError(stdout, projectId, sourceProjectName, error) {
     stdout(`${ansis.bold(`${sourceProjectName} (${projectId})`)}:`);
@@ -112,4 +118,51 @@ export function printEnvResolveProject(stdout, project) {
         stdout(`  new config keys require mapping — see mappings.json's config entry`);
     }
 }
+export function printDiscoverEnvHeader(stdout, envName, isSource) {
+    stdout(ansis.bold(isSource ? "Environment: source" : `Environment: target (${envName})`));
+    stdout("");
+}
+export function printDiscoverNoProjects(stdout, envName) {
+    stdout(`${INFO_ICON} No projects found in "${ansis.bold(envName)}".`);
+}
+export function printDiscoverProjectsTable(stdout, rows) {
+    stdout("[Projects]");
+    const table = new Table({
+        head: ["Name", "ID"].map((h) => ansis.bold(h)),
+        style: { head: [] },
+    });
+    for (const row of rows) {
+        table.push([row.name, row.id]);
+    }
+    stdout(table.toString());
+    stdout("");
+}
+export function printDiscoverNoAuthsUsed(stdout) {
+    stdout(`${INFO_ICON} No locally pulled project uses an authentication.`);
+}
+export function printDiscoverAuthsHeader(stdout) {
+    stdout("[Available Authentications]");
+}
+export function printSourceAuthsTable(stdout, rows) {
+    const table = new Table({
+        head: ["Name", "ID", "Service"].map((h) => ansis.bold(h)),
+        style: { head: [] },
+    });
+    for (const row of rows) {
+        table.push([row.name, row.id, `${row.service.name} v${row.service.version}`]);
+    }
+    stdout(table.toString());
+    stdout("");
+}
+export function printTargetAuthsTable(stdout, rows) {
+    const table = new Table({
+        head: ["Name", "Service", "ID", "Match"].map((h) => ansis.bold(h)),
+        style: { head: [] },
+    });
+    for (const row of rows) {
+        table.push([row.name, `${row.service.name} v${row.service.version}`, row.id, row.matchedTitles.join("\n")]);
+    }
+    stdout(table.toString());
+    stdout("");
+}
 //# sourceMappingURL=env.v2.js.map

package/dist/views/promote/promote.v2.js

@@ -22,9 +22,17 @@ export function printProjectNoStateFile(stderr, projectId) {
 export function printLocalDrift(stderr, projectId, dirName, dirty) {
     printIssueBlock(stderr, `Project ${ansis.bold(`${projectId} (${dirName})`)} has local drift; refusing to promote:`, dirty.map((d) => `${d.status}\t${d.path}`), `Run \`${ansis.bold("tray pull")}\` to refresh, or resolve the drift, then retry.`);
 }
-export function printNoTargetProjectMapped(stderr, sourceProjectName, projectId, envName, mappingsPath) {
-    stderr(`${FAILURE_ICON} ${ansis.bold(`"${sourceProjectName}" (${projectId})`)} has no target project mapped for "${ansis.bold(envName)}".`);
-    stderr(`Fill in target_project_id in ${mappingsPath}, or re-run with ${ansis.bold("--auto-create-projects")}.`);
+export function printNoTargetProjectMapped(stderr, sourceProjectName, projectId, envName, mappingsPath, command) {
+    if (command === "promote") {
+        stderr(`${FAILURE_ICON} ${ansis.bold(`"${sourceProjectName}" (${projectId})`)} has no target project mapped for "${ansis.bold(envName)}".`);
+        stderr(`Fill in target_project_id in ${mappingsPath}, or re-run with ${ansis.bold("--auto-create-projects")}.`);
+        return;
+    }
+    stderr("");
+    stderr("Your source environment is missing the following resolution:");
+    stderr(`${FAILURE_ICON} Project ${ansis.bold(`"${sourceProjectName}" (${projectId})`)} has no target project mapped for "${ansis.bold(envName)}".`);
+    stderr(`Fill in ${ansis.bold("target_project_id")} in ${mappingsPath}.`);
+    stderr(`${INFO_ICON} Run \`${ansis.bold(`tray env discover ${envName}`)}\` to see available target projects.`);
 }
 export function printInvalidAuthMappings(stderr, projectId, sourceProjectName, invalidAuthMappings) {
     printIssueBlock(stderr, `Project ${ansis.bold(`${projectId} (${sourceProjectName})`)} has unresolved authentication mappings:`, invalidAuthMappings.map((invalid) => `${ansis.bold(invalid.authExportId)}: "${invalid.value}" is not a valid target authentication id`), "Fill in a real target authentication id for each entry above, then retry.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trayai/tray-sync-cli",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "CLI tool to clone Tray projects and related assets to a local directory, and promote them between Tray environments",
   "bin": {
     "tray": "dist/cli.js"