@trayai/tray-sync-cli 0.0.1

package/dist/config/yaml.js

@@ -0,0 +1,22 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { parse, stringify } from "yaml";
+export async function readYaml(filePath) {
+    let raw;
+    try {
+        raw = await readFile(filePath, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return undefined;
+        throw err;
+    }
+    return parse(raw);
+}
+export async function writeYaml(filePath, data) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    const tmpPath = `${filePath}.tmp-${process.pid}`;
+    await writeFile(tmpPath, stringify(data), "utf8");
+    await rename(tmpPath, filePath);
+}
+//# sourceMappingURL=yaml.js.map

package/dist/lib/authDiscovery.js

@@ -0,0 +1,76 @@
+import { createHash } from "node:crypto";
+import { urlsForRegion } from "./region.js";
+const GET_AUTHENTICATIONS_QUERY = `
+  query GetAuthenticationsPrivate(
+    $first: Int, $last: Int, $after: String, $before: String,
+    $name: String, $workspaceIds: [String!], $serviceId: String
+  ) {
+    viewer {
+      userAuthentications(
+        last: $last, first: $first, after: $after, before: $before,
+        criteria: { name: $name, workspaceIds: $workspaceIds, serviceId: $serviceId }
+      ) {
+        edges { node {
+          id, name, created, group,
+          creator { id }
+          service { name, version }
+        } }
+        pageInfo { hasNextPage, endCursor }
+      }
+    }
+  }
+`;
+export async function listWorkspaceAuthentications(client, region, workspaceId) {
+    const weaverUrl = urlsForRegion(region).weaverUrl;
+    const authentications = [];
+    let after;
+    for (;;) {
+        const data = (await client.graphql(GET_AUTHENTICATIONS_QUERY, { workspaceIds: [workspaceId], first: 50, after }, weaverUrl));
+        for (const { node } of data.viewer.userAuthentications.edges) {
+            authentications.push({
+                id: node.id,
+                name: node.name,
+                created: node.created,
+                group: node.group,
+                creatorId: node.creator.id,
+                service: node.service,
+            });
+        }
+        const { hasNextPage, endCursor } = data.viewer.userAuthentications.pageInfo;
+        if (!hasNextPage || !endCursor)
+            break;
+        after = endCursor;
+    }
+    return { authentications };
+}
+export function computeAuthGroup(title, serviceName, serviceVersion) {
+    const bytes = Buffer.from(`${serviceName}:${serviceVersion}:${title}`, "utf8");
+    const hash = createHash("md5").update(bytes).digest();
+    hash[6] = (hash[6] & 0x0f) | 0x30;
+    hash[8] = (hash[8] & 0x3f) | 0x80;
+    const hex = hash.toString("hex");
+    return [hex.slice(0, 8), hex.slice(8, 12), hex.slice(12, 16), hex.slice(16, 20), hex.slice(20, 32)].join("-");
+}
+export const AuthCandidateMatchKinds = {
+    EXACT: "exact",
+    SAME_SERVICE: "same_service",
+};
+export function matchAuthCandidates(requirement, authentications) {
+    const requirementGroup = computeAuthGroup(requirement.title, requirement.service.name, requirement.service.version);
+    const exact = [];
+    const sameService = [];
+    for (const auth of authentications) {
+        if (auth.group === requirementGroup) {
+            exact.push({ ...auth, matchKind: AuthCandidateMatchKinds.EXACT });
+        }
+        else if (auth.service.name === requirement.service.name &&
+            auth.service.version === requirement.service.version) {
+            sameService.push({ ...auth, matchKind: AuthCandidateMatchKinds.SAME_SERVICE });
+        }
+    }
+    return [...exact, ...sameService];
+}
+export function prioritizeAuths(candidates) {
+    return candidates;
+}
+//# sourceMappingURL=authDiscovery.js.map

package/dist/lib/checksum.js

@@ -0,0 +1,5 @@
+import { createHash } from "node:crypto";
+export function sha256(content) {
+    return `sha256:${createHash("sha256").update(content, "utf8").digest("hex")}`;
+}
+//# sourceMappingURL=checksum.js.map

package/dist/lib/exportStructure.js

@@ -0,0 +1,23 @@
+import { IncompatibleApiError } from "../api/errors.js";
+export function entityDisplayName(entity) {
+    return entity.name ?? entity.title ?? "";
+}
+export function parseExportStructure(raw) {
+    if (typeof raw !== "object" || raw === null) {
+        throw new IncompatibleApiError("exportProject: response is not an object");
+    }
+    const candidate = raw;
+    if (!Array.isArray(candidate.projects) || candidate.projects.length === 0) {
+        throw new IncompatibleApiError("exportProject: missing or empty projects[]");
+    }
+    if (!Array.isArray(candidate.workflows)) {
+        throw new IncompatibleApiError("exportProject: missing workflows[]");
+    }
+    for (const key of ["data_tables", "vector_tables", "agents", "apim_operations"]) {
+        if (candidate[key] !== undefined && !Array.isArray(candidate[key])) {
+            throw new IncompatibleApiError(`exportProject: ${key} is present but not an array`);
+        }
+    }
+    return candidate;
+}
+//# sourceMappingURL=exportStructure.js.map

package/dist/lib/outputFormat.js

@@ -0,0 +1,12 @@
+import { InvalidArgumentError } from "commander";
+export const OutputFormats = {
+    HUMAN: "human",
+    JSON: "json",
+};
+export function parseFormat(value) {
+    if (value !== OutputFormats.HUMAN && value !== OutputFormats.JSON) {
+        throw new InvalidArgumentError(`--format must be one of: ${OutputFormats.HUMAN}, ${OutputFormats.JSON}`);
+    }
+    return value;
+}
+//# sourceMappingURL=outputFormat.js.map

package/dist/lib/pathContainment.js

@@ -0,0 +1,37 @@
+import path from "node:path";
+import { lstat } from "node:fs/promises";
+export function resolveContained(rootDir, relativePath) {
+    const root = path.resolve(rootDir);
+    const resolved = path.resolve(root, relativePath);
+    if (resolved !== root && !resolved.startsWith(root + path.sep)) {
+        throw new Error(`path escapes project root: "${relativePath}" resolves outside "${root}"`);
+    }
+    return resolved;
+}
+export async function assertNoSymlinkInPath(rootDir, resolvedPath) {
+    const root = path.resolve(rootDir);
+    const relative = path.relative(root, resolvedPath);
+    const segments = relative === "" ? [] : relative.split(path.sep);
+    let current = root;
+    for (const segment of segments) {
+        current = path.join(current, segment);
+        let stats;
+        try {
+            stats = await lstat(current);
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return;
+            throw err;
+        }
+        if (stats.isSymbolicLink()) {
+            throw new Error(`path contains a symlink: "${current}" is a symlink (rejected under "${root}")`);
+        }
+    }
+}
+export async function resolveContainedSafe(rootDir, relativePath) {
+    const resolved = resolveContained(rootDir, relativePath);
+    await assertNoSymlinkInPath(rootDir, resolved);
+    return resolved;
+}
+//# sourceMappingURL=pathContainment.js.map

package/dist/lib/promoteExecute.js

@@ -0,0 +1,8 @@
+import { toRequestBody } from "./promoteTarget.js";
+export async function previewImport(client, targetProjectId, payload) {
+    return (await client.request("POST", `/v1/projects/${targetProjectId}/imports/previews`, toRequestBody(payload)));
+}
+export async function importProject(client, targetProjectId, payload) {
+    return (await client.request("POST", `/v1/projects/${targetProjectId}/imports`, toRequestBody(payload)));
+}
+//# sourceMappingURL=promoteExecute.js.map

package/dist/lib/promoteReconstruct.js

@@ -0,0 +1,35 @@
+import { resolveContainedSafe } from "./pathContainment.js";
+async function readEntityFile(readFile, projectDirPath, resourcePath) {
+    const resolvedPath = await resolveContainedSafe(projectDirPath, resourcePath);
+    const content = await readFile(resolvedPath);
+    return JSON.parse(content);
+}
+async function readOrderedEntities(readFile, projectDirPath, state, orderKey) {
+    const ids = state.order[orderKey];
+    const entities = [];
+    for (const id of ids) {
+        const resource = state.resources[id];
+        if (!resource) {
+            throw new Error(`state.json.order.${orderKey} references "${id}", but state.json.resources has no entry for it.`);
+        }
+        entities.push(await readEntityFile(readFile, projectDirPath, resource.path));
+    }
+    return entities;
+}
+export async function reconstructExportStructure(deps, projectDirPath, state) {
+    const projectJsonPath = await resolveContainedSafe(projectDirPath, "project.json");
+    const project = JSON.parse(await deps.readFile(projectJsonPath));
+    const exportStructure = {
+        tray_export_version: state.tray_export_version,
+        export_type: "project",
+        projects: [project],
+        workflows: await readOrderedEntities(deps.readFile, projectDirPath, state, "workflows"),
+        data_tables: await readOrderedEntities(deps.readFile, projectDirPath, state, "data_tables"),
+        vector_tables: await readOrderedEntities(deps.readFile, projectDirPath, state, "vector_tables"),
+        agents: await readOrderedEntities(deps.readFile, projectDirPath, state, "agents"),
+        apim_operations: await readOrderedEntities(deps.readFile, projectDirPath, state, "apim_operations"),
+        solution: null,
+    };
+    return JSON.stringify(exportStructure);
+}
+//# sourceMappingURL=promoteReconstruct.js.map

package/dist/lib/promoteReport.js

@@ -0,0 +1,44 @@
+export const ChangeKinds = {
+    CREATED: "created",
+    UPDATED: "updated",
+    REMOVED: "removed",
+};
+export function toProjectImportImpact(projectName, projectId, impact) {
+    const { workflows, config } = impact;
+    return {
+        projectName,
+        projectId,
+        workflows: [
+            ...workflows.created.map((w) => ({ name: w.name, id: w.id, kind: ChangeKinds.CREATED })),
+            ...workflows.updated.map((w) => ({ name: w.name, id: w.id, kind: ChangeKinds.UPDATED })),
+            ...workflows.removed.map((w) => ({ name: w.name, id: w.id, kind: ChangeKinds.REMOVED })),
+        ],
+        config: [
+            ...config.created.map((c) => ({ name: c.key, kind: ChangeKinds.CREATED })),
+            ...config.updated.map((c) => ({ name: c.key, kind: ChangeKinds.UPDATED })),
+            ...config.removed.map((c) => ({ name: c.key, kind: ChangeKinds.REMOVED })),
+        ],
+    };
+}
+export function printProjectImportImpact(stdout, impact) {
+    stdout(`${impact.projectName} (${impact.projectId})`);
+    if (impact.workflows.length === 0) {
+        stdout("  workflows: no changes");
+    }
+    else {
+        stdout("  workflows:");
+        for (const w of impact.workflows) {
+            stdout(`    ${w.kind}: ${w.name}${w.id ? ` (${w.id})` : ""}`);
+        }
+    }
+    if (impact.config.length === 0) {
+        stdout("  config: no changes");
+    }
+    else {
+        stdout("  config:");
+        for (const c of impact.config) {
+            stdout(`    ${c.kind}: ${c.name}`);
+        }
+    }
+}
+//# sourceMappingURL=promoteReport.js.map

package/dist/lib/promoteTarget.js

@@ -0,0 +1,129 @@
+import { readProjectMappings, writeProjectMappings } from "../config/mappings.js";
+import { projectMappingsPath } from "../config/paths.js";
+import { reconstructExportStructure } from "./promoteReconstruct.js";
+import { isUuid } from "./uuid.js";
+function emptyMapping() {
+    return { target_project_id: "", authentications: {}, config: {}, connectors: [], services: [] };
+}
+export async function resolveTargetProjectId(client, options) {
+    const mappingsFile = (await readProjectMappings(options.projectDirPath)) ?? { version: 1, environments: {} };
+    const mapping = mappingsFile.environments[options.envName] ?? emptyMapping();
+    if (mapping.target_project_id) {
+        return { status: "resolved", targetProjectId: mapping.target_project_id, mapping };
+    }
+    if (!options.autoCreateProjects) {
+        if (!mappingsFile.environments[options.envName]) {
+            mappingsFile.environments[options.envName] = mapping;
+            await writeProjectMappings(options.projectDirPath, mappingsFile);
+        }
+        return { status: "missing", mappingsPath: projectMappingsPath(options.projectDirPath) };
+    }
+    const targetProjectId = await createProject(client, {
+        workspaceId: options.targetWorkspaceId,
+        name: options.sourceProjectName,
+    });
+    const updatedMapping = { ...mapping, target_project_id: targetProjectId };
+    mappingsFile.environments[options.envName] = updatedMapping;
+    await writeProjectMappings(options.projectDirPath, mappingsFile);
+    return { status: "resolved", targetProjectId, mapping: updatedMapping };
+}
+export function toRequestBody(payload) {
+    return { ...payload, exportedProjectJson: JSON.parse(payload.exportedProjectJson) };
+}
+export function assembleImportPayload(mapping, exportedProjectJson) {
+    return {
+        exportedProjectJson,
+        authenticationResolution: Object.entries(mapping.authentications).map(([authExportId, authenticationId]) => ({ authExportId, authenticationId })),
+        configOverride: mapping.config,
+        connectorMapping: mapping.connectors,
+        serviceMapping: mapping.services,
+    };
+}
+export async function createProject(client, options) {
+    const result = (await client.request("POST", "/v2/projects", {
+        workspaceId: options.workspaceId,
+        name: options.name,
+        description: options.description ?? "",
+        tags: [],
+        workflows: [],
+    }));
+    return result.id;
+}
+export async function getImportRequirements(client, targetProjectId, payload) {
+    return (await client.request("POST", `/v1/projects/${targetProjectId}/imports/requirements`, toRequestBody({
+        exportedProjectJson: payload.exportedProjectJson,
+        connectorMapping: payload.connectorMapping,
+        serviceMapping: payload.serviceMapping,
+    })));
+}
+export function findUnresolvedRequirements(requirements, mappedAuthentications = {}) {
+    return {
+        unresolvedAuthentications: requirements.authenticationsRequirements
+            .filter((auth) => {
+            if (auth.resolvedAuthentication)
+                return false;
+            const mapped = mappedAuthentications[auth.authExportId];
+            return !(mapped !== undefined && isUuid(mapped));
+        })
+            .map((auth) => ({ authExportId: auth.authExportId, title: auth.title, service: auth.service })),
+        hasNewConfigKeys: requirements.newConfigKeys,
+    };
+}
+export function isFullyResolved(unresolved) {
+    return unresolved.unresolvedAuthentications.length === 0 && !unresolved.hasNewConfigKeys;
+}
+export const MISSING_TARGET_AUTHENTICATION = "MISSING_TARGET_AUTHENTICATION";
+export async function scaffoldUnresolvedAuthentications(projectDirPath, envName, unresolved) {
+    if (unresolved.unresolvedAuthentications.length === 0) {
+        return;
+    }
+    const mappingsFile = (await readProjectMappings(projectDirPath)) ?? { version: 1, environments: {} };
+    const mapping = mappingsFile.environments[envName] ?? emptyMapping();
+    let changed = false;
+    for (const auth of unresolved.unresolvedAuthentications) {
+        if (!(auth.authExportId in mapping.authentications)) {
+            mapping.authentications[auth.authExportId] = MISSING_TARGET_AUTHENTICATION;
+            changed = true;
+        }
+    }
+    if (changed) {
+        mappingsFile.environments[envName] = mapping;
+        await writeProjectMappings(projectDirPath, mappingsFile);
+    }
+}
+export function validateAuthenticationMappings(mapping) {
+    return Object.entries(mapping.authentications)
+        .filter(([, authenticationId]) => !isUuid(authenticationId))
+        .map(([authExportId, value]) => ({ authExportId, value }));
+}
+export async function resolveProjectRequirements(client, deps, options) {
+    const targetResolution = await resolveTargetProjectId(client, {
+        projectDirPath: options.projectDirPath,
+        envName: options.envName,
+        targetWorkspaceId: options.targetWorkspaceId,
+        sourceProjectName: options.sourceProjectName,
+        autoCreateProjects: options.autoCreateProjects,
+    });
+    if (targetResolution.status === "missing") {
+        return { status: "no_target_project_mapped", mappingsPath: targetResolution.mappingsPath };
+    }
+    if (options.validateAuthMappings ?? true) {
+        const invalidAuthMappings = validateAuthenticationMappings(targetResolution.mapping);
+        if (invalidAuthMappings.length > 0) {
+            return { status: "invalid_auth_mappings", invalidAuthMappings };
+        }
+    }
+    const exportedProjectJson = await reconstructExportStructure(deps, options.projectDirPath, options.state);
+    const payload = assembleImportPayload(targetResolution.mapping, exportedProjectJson);
+    const requirements = await getImportRequirements(client, targetResolution.targetProjectId, payload);
+    const unresolved = findUnresolvedRequirements(requirements, targetResolution.mapping.authentications);
+    return {
+        status: "resolved",
+        targetProjectId: targetResolution.targetProjectId,
+        mapping: targetResolution.mapping,
+        exportedProjectJson,
+        payload,
+        unresolved,
+    };
+}
+//# sourceMappingURL=promoteTarget.js.map

package/dist/lib/region.js

@@ -0,0 +1,26 @@
+import { Regions } from "../config/types.js";
+const REGIONS = Object.values(Regions);
+function buildRegionUrls(region) {
+    const domain = region === Regions.US1 ? "tray.io" : `${region}.tray.io`;
+    return {
+        apiBaseUrl: `https://api.${domain}`,
+        graphqlUrl: `https://${domain}/graphql`,
+        weaverUrl: `https://weaver.${domain}`,
+    };
+}
+const REGION_URLS = Object.fromEntries(REGIONS.map((region) => [region, buildRegionUrls(region)]));
+export function urlsForRegion(region) {
+    return REGION_URLS[region];
+}
+export const ALLOWED_HOSTS = new Set(Object.values(REGION_URLS).flatMap(({ apiBaseUrl, graphqlUrl, weaverUrl }) => [apiBaseUrl, graphqlUrl, weaverUrl].map((url) => new URL(url).host)));
+export function isAllowedUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    return parsed.protocol === "https:" && ALLOWED_HOSTS.has(parsed.host);
+}
+//# sourceMappingURL=region.js.map

package/dist/lib/regionDisplay.js

@@ -0,0 +1,11 @@
+const REGION_LABELS = {
+    us1: "USA",
+    eu1: "EMEA",
+    ap1: "APAC",
+    ap2: "JPN",
+    staging: "Staging",
+};
+export function describeRegion(region) {
+    return `${region} (${REGION_LABELS[region]})`;
+}
+//# sourceMappingURL=regionDisplay.js.map

package/dist/lib/regionParsing.js

@@ -0,0 +1,12 @@
+import { InvalidArgumentError } from "commander";
+import { Regions } from "../config/types.js";
+import { describeRegion } from "./regionDisplay.js";
+export const REGIONS = Object.values(Regions);
+export const PUBLIC_REGIONS = REGIONS.filter((region) => region !== Regions.STAGING);
+export function parseRegion(value) {
+    if (!REGIONS.includes(value)) {
+        throw new InvalidArgumentError(`region must be one of: ${PUBLIC_REGIONS.map(describeRegion).join(", ")}`);
+    }
+    return value;
+}
+//# sourceMappingURL=regionParsing.js.map

package/dist/lib/scriptExtraction.js

@@ -0,0 +1,46 @@
+import { slugify } from "./slug.js";
+const CONNECTORS = {
+    "python-script": { extension: "py", commentPrefix: "#" },
+    script: { extension: "js", commentPrefix: "//" },
+};
+function banner(commentPrefix, workflowJsonPath, stepKey) {
+    return (`${commentPrefix} --- extracted by tray-sync-cli; edits here do NOT sync back to Tray ---\n` +
+        `${commentPrefix} Source of truth: ${workflowJsonPath} (steps["${stepKey}"].properties.script.value)\n`);
+}
+export function extractScripts(workflow) {
+    const steps = workflow.steps;
+    if (typeof steps !== "object" || steps === null) {
+        return [];
+    }
+    const extracted = [];
+    for (const [stepKey, step] of Object.entries(steps)) {
+        if (typeof step !== "object" || step === null)
+            continue;
+        const connector = step.connector;
+        const connectorName = typeof connector === "object" && connector !== null
+            ? connector.name
+            : undefined;
+        if (typeof connectorName !== "string")
+            continue;
+        const language = CONNECTORS[connectorName];
+        if (!language)
+            continue;
+        const properties = step.properties;
+        if (typeof properties !== "object" || properties === null)
+            continue;
+        const script = properties.script;
+        if (typeof script !== "object" || script === null)
+            continue;
+        const value = script.value;
+        if (typeof value !== "string")
+            continue;
+        const title = typeof step.title === "string"
+            ? step.title
+            : "";
+        const fileName = `${slugify(stepKey)}--${slugify(title)}.${language.extension}`;
+        const content = `${banner(language.commentPrefix, "../workflow.json", stepKey)}\n${value}\n`;
+        extracted.push({ stepKey, fileName, content });
+    }
+    return extracted;
+}
+//# sourceMappingURL=scriptExtraction.js.map

package/dist/lib/slug.js

@@ -0,0 +1,14 @@
+const MAX_SLUG_LENGTH = 40;
+export function slugify(name) {
+    const slug = name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, MAX_SLUG_LENGTH)
+        .replace(/-+$/, "");
+    return slug === "" ? "unnamed" : slug;
+}
+export function entityDirName(uuid, name) {
+    return `${uuid}--${slugify(name)}`;
+}
+//# sourceMappingURL=slug.js.map

package/dist/lib/tokenResolution.js

@@ -0,0 +1,19 @@
+const SOURCES_DESCRIPTION = "--token flag, ~/.tray/credentials.json, TRAY_API_TOKEN_<ENV>, or TRAY_API_TOKEN";
+export function resolveToken(options) {
+    const { tokenFlag, credentials, workspaceId, envName, env = process.env } = options;
+    if (tokenFlag)
+        return tokenFlag;
+    const credentialsToken = credentials.workspaces[workspaceId]?.token;
+    if (credentialsToken)
+        return credentialsToken;
+    if (envName) {
+        const envVarName = `TRAY_API_TOKEN_${envName.toUpperCase().replace(/-/g, "_")}`;
+        const envToken = env[envVarName];
+        if (envToken)
+            return envToken;
+    }
+    if (env.TRAY_API_TOKEN)
+        return env.TRAY_API_TOKEN;
+    throw new Error(`No Tray API token found for workspace "${workspaceId}". Provide one via: ${SOURCES_DESCRIPTION}.`);
+}
+//# sourceMappingURL=tokenResolution.js.map

package/dist/lib/uuid.js

@@ -0,0 +1,5 @@
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function isUuid(value) {
+    return UUID_RE.test(value);
+}
+//# sourceMappingURL=uuid.js.map

package/dist/views/env/env.js

@@ -0,0 +1,89 @@
+export function printInvalidEnvName(stderr, nameRe, name) {
+    stderr(`Environment name must match ${nameRe}: "${name}"`);
+}
+export function printEnvAlreadyExists(stderr, name) {
+    stderr(`Environment "${name}" already exists. Run \`tray env remove\` first to replace it.`);
+}
+export function printAddedEnvironment(stdout, name, regionDescription, workspaceId) {
+    stdout(`Added environment "${name}" (${regionDescription}, workspace ${workspaceId}).`);
+}
+export function printTokenNotSaved(stderr, workspaceId) {
+    stderr(`⚠️  --token was NOT saved: credentials.json already has a token for workspace ${workspaceId}, and the existing one was kept.\n` +
+        `   Re-run this same \`tray env add\` command with --force-token to replace it with the --token you just provided.`);
+}
+export function printNoTokenSkippingConnectivity(stdout) {
+    stdout("No token available — skipping connectivity check.");
+}
+export function printConnectivityCheck(stdout, description) {
+    stdout(`Connectivity check: ${description}`);
+}
+export function printTrayYamlNotFound(stderr) {
+    stderr("tray.yaml not found. Run `tray init` first.");
+}
+export function printSourceEnvHeader(stdout) {
+    stdout("SOURCE ENV:");
+}
+export function printSourceEnvLine(stdout, regionDescription, workspaceId, connectivityDescription) {
+    stdout(`  source (${regionDescription}, workspace ${workspaceId}): ${connectivityDescription}`);
+}
+export function printTargetEnvHeader(stdout) {
+    stdout("");
+    stdout("TARGET ENV:");
+}
+export function printNoTargetEnvironments(stdout) {
+    stdout("  No target environments configured.");
+}
+export function printTargetEnvLine(stdout, name, regionDescription, workspaceId, connectivityDescription) {
+    stdout(`  ${name} (${regionDescription}, workspace ${workspaceId}): ${connectivityDescription}`);
+}
+export function printEnvNotConfigured(stdout, name) {
+    stdout(`Environment "${name}" is not configured. Nothing to remove.`);
+}
+export function printRemovedEnvironment(stdout, name) {
+    stdout(`Removed environment "${name}" from environments.json.`);
+}
+export function printRemovedMapping(stdout, name, dirName) {
+    stdout(`Removed "${name}" mapping from ${dirName}/mappings.json.`);
+}
+export function printRemovedCredentials(stdout, workspaceId) {
+    stdout(`Removed credentials for workspace ${workspaceId}.`);
+}
+export function printEnvResolveProjectFullyResolved(stdout, projectId, sourceProjectName) {
+    stdout(`${sourceProjectName} (${projectId}): fully resolved, nothing to do`);
+}
+export function printEnvResolveProjectError(stdout, projectId, sourceProjectName, error) {
+    stdout(`${sourceProjectName} (${projectId}):`);
+    if (error.reason === "no_target_project_mapped") {
+        stdout(`  no target project mapped yet — see ${error.mappingsPath}`);
+        return;
+    }
+    if (error.reason === "project_error") {
+        const target = error.targetProjectId ? ` (target project ${error.targetProjectId})` : "";
+        stdout(`  ${error.message}${target}`);
+        return;
+    }
+    stdout(`  invalid authentication mappings:`);
+    for (const invalid of error.invalidAuthMappings) {
+        stdout(`    ${invalid.authExportId}: "${invalid.value}" is not a valid target authentication id`);
+    }
+}
+export function printEnvResolveProject(stdout, project) {
+    stdout(`${project.sourceProjectName} (${project.projectId}):`);
+    for (const auth of project.autoResolvedAuthentications) {
+        stdout(`  auto-resolved: ${auth.title} -> "${auth.chosen.name}" (id: ${auth.chosen.id}, ${auth.chosen.matchKind} match), written to mappings.json`);
+    }
+    for (const auth of project.unresolvedAuthentications) {
+        stdout(`  unresolved: ${auth.title} (${auth.service.name} v${auth.service.version})`);
+        if (auth.candidates.length === 0) {
+            stdout(`    no candidates found in the target workspace`);
+        }
+        for (const candidate of auth.candidates) {
+            stdout(`    candidate (${candidate.matchKind}): "${candidate.name}" (id: ${candidate.id}, created ${candidate.created})`);
+        }
+        stdout(`    to resolve: set mappings.json's environments.<env>.authentications["${auth.authExportId}"] to a target auth id${auth.candidates.length > 0 ? ", or re-run with --auto-resolve to pick the top candidate automatically" : ""}`);
+    }
+    if (project.hasNewConfigKeys) {
+        stdout(`  new config keys require mapping — see mappings.json's config entry`);
+    }
+}
+//# sourceMappingURL=env.js.map

package/dist/views/env/shared.js

@@ -0,0 +1,7 @@
+export function printEnvListJson(stdout, data) {
+    stdout(JSON.stringify(data));
+}
+export function printEnvResolveResultJson(stdout, result) {
+    stdout(JSON.stringify(result));
+}
+//# sourceMappingURL=shared.js.map

package/dist/views/init/init.js

@@ -0,0 +1,17 @@
+export function printTrayYamlAlreadyExists(stderr) {
+    stderr("tray.yaml already exists in this directory. Refusing to overwrite.");
+}
+export function printTokenNotSaved(stderr, workspaceId, region) {
+    stderr(`⚠️  --token was NOT saved: credentials.json already has a token for workspace ${workspaceId}, and the existing one was kept.\n` +
+        `   tray.yaml has already been written, so \`tray init\` can't be re-run here — use \`tray env add <name> --region ${region} --workspace-id ${workspaceId} --token <token> --force-token\` to replace it, or edit ~/.tray/credentials.json directly.`);
+}
+export function printNoTokenSkippingConnectivityAndPull(stdout) {
+    stdout("No token available — skipping connectivity check and pull.");
+}
+export function printConnectivityCheckSucceeded(stdout) {
+    stdout("Connectivity check: ✓");
+}
+export function printConnectivityCheckFailed(stdout, message) {
+    stdout(`Connectivity check: ✗ (${message})`);
+}
+//# sourceMappingURL=init.js.map