@trayai/tray-sync-cli 0.0.1

package/dist/commands/pull.js

@@ -0,0 +1,379 @@
+import { readdir as fsReaddir, rename as fsRename, rm as fsRm } from "node:fs/promises";
+import path from "node:path";
+import { Command, InvalidArgumentError } from "commander";
+import { createTrayClientForRegion } from "../api/trayClient.js";
+import { readCredentials } from "../config/credentials.js";
+import { writeJson, writeText } from "../config/io.js";
+import { readProjectMappings, writeProjectMappings } from "../config/mappings.js";
+import { readPullProgress, writePullProgress } from "../config/pullProgress.js";
+import { readProjectState, writeProjectState } from "../config/state.js";
+import { readTrayYaml, writeTrayYaml } from "../config/trayYaml.js";
+import { Scopes, TrayTypes, } from "../config/types.js";
+import { entityDirName } from "../lib/slug.js";
+import { entityDisplayName, parseExportStructure, } from "../lib/exportStructure.js";
+import { extractScripts } from "../lib/scriptExtraction.js";
+import { sha256 } from "../lib/checksum.js";
+import { assertNoSymlinkInPath, resolveContained, resolveContainedSafe } from "../lib/pathContainment.js";
+import { resolveToken } from "../lib/tokenResolution.js";
+import { isUuid } from "../lib/uuid.js";
+import { OutputFormats, parseFormat } from "../lib/outputFormat.js";
+import { IncompatibleApiError } from "../api/errors.js";
+import { printError, printPulled, printPulledUnchanged, printRemovedStaleProjectDir, printRenamedProjectDir, printSolutionDropped, printTrayYamlNotFound, printWouldPullProject, printWouldRenameProjectDir, printWouldSkipUnchangedProject, } from "../views/pull/pull.js";
+import { printPullResultJson } from "../views/pull/shared.js";
+const ASSET_DIRS = [
+    { field: "workflows", dirName: "workflows", fileName: "workflow.json", trayType: TrayTypes.WORKFLOW },
+    {
+        field: "data_tables",
+        dirName: "data-tables",
+        fileName: "data-table.json",
+        trayType: TrayTypes.DATA_TABLE,
+    },
+    {
+        field: "vector_tables",
+        dirName: "vector-tables",
+        fileName: "vector-table.json",
+        trayType: TrayTypes.VECTOR_TABLE,
+    },
+    { field: "agents", dirName: "agents", fileName: "agent.json", trayType: TrayTypes.AGENT },
+    {
+        field: "apim_operations",
+        dirName: "api-operations",
+        fileName: "api-operation.json",
+        trayType: TrayTypes.API_OPERATION,
+    },
+];
+const EXPORT_PROJECT_QUERY = `
+  mutation ExportProject($projectId: ID!, $exportSolution: Boolean!) {
+    exportProject(input: { projectId: $projectId, exportSolution: $exportSolution }) {
+      exportedProjectJson
+    }
+  }
+`;
+function requireUuid(id, context) {
+    if (!isUuid(id)) {
+        throw new IncompatibleApiError(`${context}: expected a UUID, got "${id}"`);
+    }
+    return id;
+}
+export async function listProjectIds(client, workspaceId) {
+    const result = (await client.request("GET", `/v2/projects/workspaces/${workspaceId}`));
+    return result.projects.map((p) => requireUuid(p.id, "listProjects: projects[].id"));
+}
+export async function writeExportedProject(projectDirPath, exportStructure, stdout) {
+    const project = exportStructure.projects[0];
+    const projectJsonPath = path.join(projectDirPath, "project.json");
+    await assertNoSymlinkInPath(projectDirPath, projectJsonPath);
+    await writeJson(projectJsonPath, project);
+    const order = {
+        workflows: [],
+        data_tables: [],
+        vector_tables: [],
+        agents: [],
+        apim_operations: [],
+    };
+    const resources = {};
+    for (const { field, dirName, fileName, trayType } of ASSET_DIRS) {
+        const entities = exportStructure[field] ?? [];
+        for (const entity of entities) {
+            const entityId = requireUuid(entity.id, `exportProject: ${field}[].id`);
+            const entityDirName_ = entityDirName(entityId, entityDisplayName(entity));
+            const entityDir = resolveContained(path.join(projectDirPath, dirName), entityDirName_);
+            const entityJsonPath = path.join(entityDir, fileName);
+            await assertNoSymlinkInPath(projectDirPath, entityJsonPath);
+            await writeJson(entityJsonPath, entity);
+            order[field].push(entityId);
+            resources[entityId] = {
+                tray_type: trayType,
+                path: path.relative(projectDirPath, entityJsonPath),
+                local_checksum: sha256(JSON.stringify(entity, null, 2) + "\n"),
+            };
+            if (field === "workflows") {
+                for (const script of extractScripts(entity)) {
+                    const scriptPath = resolveContained(path.join(entityDir, "scripts"), script.fileName);
+                    await assertNoSymlinkInPath(projectDirPath, scriptPath);
+                    await writeText(scriptPath, script.content);
+                    const resourceKey = `${entityId}.${script.stepKey}`;
+                    resources[resourceKey] = {
+                        tray_type: TrayTypes.SCRIPT,
+                        path: path.relative(projectDirPath, scriptPath),
+                        local_checksum: sha256(script.content),
+                    };
+                }
+            }
+        }
+    }
+    const solutionDropped = Boolean(exportStructure.solution);
+    if (solutionDropped) {
+        printSolutionDropped(stdout, project.id);
+    }
+    return { order, resources, solutionDropped };
+}
+const SCAFFOLD_ENV_NAME_PLACEHOLDER = "<target-env-name-placeholder>";
+function emptyEnvironmentMapping() {
+    return { target_project_id: "", authentications: {}, config: {}, connectors: [], services: [] };
+}
+async function ensureProjectMappings(projectDirPath) {
+    const existing = await readProjectMappings(projectDirPath);
+    if (!existing) {
+        await writeProjectMappings(projectDirPath, {
+            version: 1,
+            environments: { [SCAFFOLD_ENV_NAME_PLACEHOLDER]: emptyEnvironmentMapping() },
+        });
+    }
+}
+function newPullProgress(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 runPull(deps, options) {
+    const { cwd, createClient, readdir, rm, rename, stdout } = deps;
+    if (options.resume && options.resetState) {
+        throw new Error("--resume and --reset-state are mutually exclusive.");
+    }
+    const trayYaml = await readTrayYaml(cwd);
+    if (!trayYaml) {
+        throw new Error("tray.yaml not found. Run `tray init` first.");
+    }
+    const client = createClient(trayYaml.region, options.token);
+    const targeted = options.projectIds !== undefined && options.projectIds.length > 0;
+    let plannedIds;
+    if (targeted) {
+        plannedIds = options.projectIds;
+    }
+    else if (trayYaml.scope === Scopes.WORKSPACE) {
+        plannedIds = (await listProjectIds(client, trayYaml.workspace_id)).slice().sort();
+        if (!options.dryRun) {
+            await writeTrayYaml({ ...trayYaml, projects: plannedIds }, cwd);
+        }
+    }
+    else {
+        plannedIds = trayYaml.projects;
+    }
+    let progress;
+    if (!options.dryRun) {
+        if (options.resume) {
+            progress = await readPullProgress(cwd);
+            if (progress) {
+                plannedIds = progress.planned;
+            }
+            else {
+                progress = newPullProgress(trayYaml, plannedIds);
+                await writePullProgress(progress, cwd);
+            }
+        }
+        else {
+            progress = newPullProgress(trayYaml, plannedIds);
+            await writePullProgress(progress, cwd);
+        }
+    }
+    const alreadyCompleted = new Set(progress?.completed ?? []);
+    const asJson = options.format === OutputFormats.JSON;
+    const events = [];
+    for (const projectId of plannedIds) {
+        if (alreadyCompleted.has(projectId)) {
+            continue;
+        }
+        const raw = await client.graphql(EXPORT_PROJECT_QUERY, {
+            projectId,
+            exportSolution: true,
+        });
+        const exportedJson = raw.exportProject
+            .exportedProjectJson;
+        const exportStructure = parseExportStructure(JSON.parse(exportedJson));
+        const project = exportStructure.projects[0];
+        const validatedProjectId = requireUuid(project.id, "exportProject: projects[0].id");
+        const projectName = entityDisplayName(project);
+        const projectsRoot = path.join(cwd, "projects");
+        const newDirName = entityDirName(validatedProjectId, projectName);
+        const dir = await resolveContainedSafe(projectsRoot, newDirName);
+        let existingDirName;
+        try {
+            existingDirName = (await readdir(projectsRoot)).find((name) => name.split("--")[0] === validatedProjectId && name !== newDirName);
+        }
+        catch {
+            existingDirName = undefined;
+        }
+        let existingDirPath;
+        if (existingDirName) {
+            existingDirPath = await resolveContainedSafe(projectsRoot, existingDirName);
+        }
+        const existingState = await readProjectState(existingDirPath ?? dir);
+        const exportChecksum = sha256(exportedJson);
+        const unchanged = !options.resetState && existingState?.export_checksum === exportChecksum;
+        const renamedDir = existingDirName && existingDirName !== newDirName
+            ? { from: existingDirName, to: newDirName }
+            : undefined;
+        if (options.dryRun) {
+            if (renamedDir && !asJson) {
+                printWouldRenameProjectDir(stdout, renamedDir.from, renamedDir.to);
+            }
+            const action = unchanged ? "would_skip_unchanged" : "would_pull";
+            if (asJson) {
+                events.push({ project_id: projectId, project_name: projectName, action, renamed_dir: renamedDir });
+            }
+            else if (unchanged) {
+                printWouldSkipUnchangedProject(stdout, projectId, projectName);
+            }
+            else {
+                printWouldPullProject(stdout, projectId, projectName);
+            }
+            continue;
+        }
+        if (renamedDir) {
+            await rename(existingDirPath, dir);
+            if (!asJson) {
+                printRenamedProjectDir(stdout, renamedDir.from, renamedDir.to);
+            }
+        }
+        if (options.resetState) {
+            const preservedMappings = await readProjectMappings(dir);
+            await rm(dir).catch(() => { });
+            if (preservedMappings) {
+                await writeProjectMappings(dir, preservedMappings);
+            }
+        }
+        if (unchanged) {
+            await writeProjectState(dir, { ...existingState, last_sync: new Date().toISOString() });
+            if (asJson) {
+                events.push({ project_id: projectId, project_name: projectName, action: "pulled_unchanged", renamed_dir: renamedDir });
+            }
+            else {
+                printPulledUnchanged(stdout, projectId, projectName);
+            }
+        }
+        else {
+            const { order, resources, solutionDropped } = await writeExportedProject(dir, exportStructure, asJson ? () => { } : stdout);
+            const state = {
+                version: 1,
+                project_id: validatedProjectId,
+                tray_export_version: exportStructure.tray_export_version,
+                last_sync: new Date().toISOString(),
+                export_checksum: exportChecksum,
+                order,
+                resources,
+            };
+            await writeProjectState(dir, state);
+            if (asJson) {
+                events.push({
+                    project_id: projectId,
+                    project_name: projectName,
+                    action: "pulled",
+                    renamed_dir: renamedDir,
+                    solution_dropped: solutionDropped,
+                });
+            }
+            else {
+                printPulled(stdout, projectId, projectName);
+            }
+        }
+        await ensureProjectMappings(dir);
+        if (progress) {
+            progress = { ...progress, completed: [...progress.completed, projectId] };
+            await writePullProgress(progress, cwd);
+        }
+    }
+    if (options.dryRun) {
+        if (asJson) {
+            printPullResultJson(stdout, { dry_run: true, projects: events, removed_stale_dirs: [] });
+        }
+        return 0;
+    }
+    if (targeted) {
+        const merged = Array.from(new Set([...trayYaml.projects, ...plannedIds])).sort();
+        await writeTrayYaml({ ...trayYaml, projects: merged }, cwd);
+    }
+    const removedStaleDirs = [];
+    if (!targeted && trayYaml.scope === Scopes.WORKSPACE) {
+        const projectsRoot = path.join(cwd, "projects");
+        let existingDirs;
+        try {
+            existingDirs = await readdir(projectsRoot);
+        }
+        catch {
+            existingDirs = [];
+        }
+        const plannedIdSet = new Set(plannedIds);
+        for (const dirName of existingDirs) {
+            const dirId = dirName.split("--")[0];
+            if (!plannedIdSet.has(dirId)) {
+                await rm(path.join(projectsRoot, dirName));
+                if (asJson) {
+                    removedStaleDirs.push(dirName);
+                }
+                else {
+                    printRemovedStaleProjectDir(stdout, dirName);
+                }
+            }
+        }
+    }
+    if (progress) {
+        await rm(path.join(cwd, ".pull-progress.json")).catch(() => { });
+    }
+    if (asJson) {
+        printPullResultJson(stdout, { dry_run: false, projects: events, removed_stale_dirs: removedStaleDirs });
+    }
+    return 0;
+}
+function parseUuid(value, previous) {
+    if (!isUuid(value)) {
+        throw new InvalidArgumentError("--project must be a UUID");
+    }
+    return [...(previous ?? []), value];
+}
+export const pullCommand = new Command("pull")
+    .description("Export tracked projects from Tray and materialise them on disk")
+    .option("-p, --project <id...>", "pull only these project IDs, adding any not yet tracked to tray.yaml", parseUuid)
+    .option("--resume", "resume a previously interrupted pull")
+    .option("--reset-state", "ignore existing state and rewrite everything from a fresh export")
+    .option("--dry-run", "report what would change without writing anything")
+    .option("-t, --token <token>", "Tray API token")
+    .option("--format <format>", "human or json", parseFormat, OutputFormats.HUMAN)
+    .action(async (opts) => {
+    const cwd = process.cwd();
+    const stderr = (line) => console.error(line);
+    const trayYaml = await readTrayYaml(cwd);
+    if (!trayYaml) {
+        printTrayYamlNotFound(stderr);
+        process.exitCode = 1;
+        return;
+    }
+    const credentials = await readCredentials(process.env);
+    let token;
+    try {
+        token = resolveToken({
+            tokenFlag: opts.token,
+            credentials,
+            workspaceId: trayYaml.workspace_id,
+            env: process.env,
+        });
+    }
+    catch (err) {
+        printError(stderr, err.message);
+        process.exitCode = 1;
+        return;
+    }
+    const exitCode = await runPull({
+        cwd,
+        createClient: (region, tok) => createTrayClientForRegion(region, tok),
+        readdir: (dir) => fsReaddir(dir),
+        rm: (dir) => fsRm(dir, { recursive: true, force: true }),
+        rename: (oldPath, newPath) => fsRename(oldPath, newPath),
+        stdout: (line) => console.log(line),
+    }, {
+        token,
+        projectIds: opts.project,
+        resume: Boolean(opts.resume),
+        resetState: Boolean(opts.resetState),
+        dryRun: Boolean(opts.dryRun),
+        format: opts.format,
+    });
+    process.exitCode = exitCode;
+});
+//# sourceMappingURL=pull.js.map

package/dist/commands/status.js

@@ -0,0 +1,126 @@
+import path from "node:path";
+import { readdir as fsReaddir, readFile as fsReadFile } from "node:fs/promises";
+import { Command, InvalidArgumentError } from "commander";
+import { readTrayYaml } from "../config/trayYaml.js";
+import { readProjectState } from "../config/state.js";
+import { sha256 } from "../lib/checksum.js";
+import { isUuid } from "../lib/uuid.js";
+import { resolveContainedSafe } from "../lib/pathContainment.js";
+import { OutputFormats, parseFormat } from "../lib/outputFormat.js";
+import { printStatusReports } from "../views/status/status.js";
+import { printStatusReportsJson } from "../views/status/shared.js";
+export const DriftStatuses = {
+    CLEAN: "CLEAN",
+    LOCAL_MODIFIED: "LOCAL_MODIFIED",
+    LOCAL_DELETED: "LOCAL_DELETED",
+    LOCAL_ADDED: "LOCAL_ADDED",
+    INVALID_PATH: "INVALID_PATH",
+};
+export async function checkProjectDrift(deps, projectId, projectDirPath) {
+    const state = await readProjectState(projectDirPath);
+    if (!state) {
+        return { project_id: projectId, project_dir: projectDirPath, never_pulled: true, drift: [] };
+    }
+    const drift = [];
+    const trackedPaths = new Set();
+    for (const resource of Object.values(state.resources)) {
+        trackedPaths.add(resource.path);
+        let resolvedPath;
+        try {
+            resolvedPath = await resolveContainedSafe(projectDirPath, resource.path);
+        }
+        catch {
+            drift.push({ path: resource.path, status: DriftStatuses.INVALID_PATH });
+            continue;
+        }
+        let content;
+        try {
+            content = await deps.readFile(resolvedPath);
+        }
+        catch {
+            drift.push({ path: resource.path, status: DriftStatuses.LOCAL_DELETED });
+            continue;
+        }
+        const status = sha256(content) === resource.local_checksum ? DriftStatuses.CLEAN : DriftStatuses.LOCAL_MODIFIED;
+        drift.push({ path: resource.path, status });
+    }
+    const excluded = new Set(["project.json", "state.json", "mappings.json"]);
+    const allFiles = await deps.readdirRecursive(projectDirPath);
+    for (const filePath of allFiles) {
+        if (excluded.has(filePath) || trackedPaths.has(filePath))
+            continue;
+        drift.push({ path: filePath, status: DriftStatuses.LOCAL_ADDED });
+    }
+    return { project_id: projectId, project_dir: projectDirPath, never_pulled: false, drift };
+}
+export async function runStatus(deps, options) {
+    const { cwd, readdir, stdout } = deps;
+    const trayYaml = await readTrayYaml(cwd);
+    if (!trayYaml) {
+        throw new Error("tray.yaml not found. Run `tray init` first.");
+    }
+    const targetIds = options.projectIds && options.projectIds.length > 0 ? options.projectIds : trayYaml.projects;
+    const projectsRoot = path.join(cwd, "projects");
+    let existingDirs;
+    try {
+        existingDirs = await readdir(projectsRoot);
+    }
+    catch {
+        existingDirs = [];
+    }
+    const reports = [];
+    for (const projectId of targetIds) {
+        const dirName = existingDirs.find((name) => name.split("--")[0] === projectId);
+        if (!dirName) {
+            reports.push({ projectId });
+            continue;
+        }
+        const projectDirPath = path.join(projectsRoot, dirName);
+        const result = await checkProjectDrift(deps, projectId, projectDirPath);
+        reports.push({ dirName, projectId, result });
+    }
+    const isClean = (r) => r.result !== undefined &&
+        !r.result.never_pulled &&
+        r.result.drift.every((d) => d.status === DriftStatuses.CLEAN);
+    const sorted = [...reports].sort((a, b) => Number(isClean(b)) - Number(isClean(a)));
+    if (options.format === OutputFormats.JSON) {
+        printStatusReportsJson(stdout, DriftStatuses.CLEAN, sorted);
+    }
+    else {
+        printStatusReports(stdout, DriftStatuses.CLEAN, sorted);
+    }
+    return 0;
+}
+function parseUuid(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 [];
+    }
+}
+export const statusCommand = new Command("status")
+    .description("Local checksum-based drift detection (zero API calls)")
+    .option("-p, --project <id...>", "check only these project IDs", parseUuid)
+    .option("--format <format>", "human or json", parseFormat, OutputFormats.HUMAN)
+    .action(async (opts) => {
+    const cwd = process.cwd();
+    const exitCode = await runStatus({
+        cwd,
+        readdir: (dir) => fsReaddir(dir),
+        readdirRecursive: (dir) => readdirRecursiveReal(dir),
+        readFile: (filePath) => fsReadFile(filePath, "utf8"),
+        stdout: (line) => console.log(line),
+    }, { projectIds: opts.project, format: opts.format });
+    process.exitCode = exitCode;
+});
+//# sourceMappingURL=status.js.map

package/dist/config/credentials.js

@@ -0,0 +1,10 @@
+import { OWNER_ONLY_FILE_MODE, readJson, writeJson } from "./io.js";
+import { credentialsPath } from "./paths.js";
+export async function readCredentials(env) {
+    const data = await readJson(credentialsPath(env));
+    return data ?? { version: 1, workspaces: {} };
+}
+export async function writeCredentials(data, env) {
+    await writeJson(credentialsPath(env), data, { mode: OWNER_ONLY_FILE_MODE });
+}
+//# sourceMappingURL=credentials.js.map

package/dist/config/environments.js

@@ -0,0 +1,10 @@
+import { readJson, writeJson } from "./io.js";
+import { environmentsPath } from "./paths.js";
+export async function readEnvironments(cwd) {
+    const data = await readJson(environmentsPath(cwd));
+    return data ?? { version: 1, environments: {} };
+}
+export async function writeEnvironments(data, cwd) {
+    await writeJson(environmentsPath(cwd), data);
+}
+//# sourceMappingURL=environments.js.map

package/dist/config/io.js

@@ -0,0 +1,36 @@
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+export async function readJson(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return undefined;
+        throw err;
+    }
+}
+export const OWNER_ONLY_FILE_MODE = 0o600;
+export const OWNER_ONLY_DIR_MODE = 0o700;
+export async function writeJson(filePath, data, options = {}) {
+    const dir = path.dirname(filePath);
+    await mkdir(dir, { recursive: true, mode: options.mode ? OWNER_ONLY_DIR_MODE : undefined });
+    if (options.mode)
+        await chmod(dir, OWNER_ONLY_DIR_MODE);
+    const tmpPath = `${filePath}.tmp-${process.pid}`;
+    await writeFile(tmpPath, `${JSON.stringify(data, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: options.mode,
+    });
+    if (options.mode)
+        await chmod(tmpPath, options.mode);
+    await rename(tmpPath, filePath);
+}
+export async function writeText(filePath, content) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    const tmpPath = `${filePath}.tmp-${process.pid}`;
+    await writeFile(tmpPath, content, "utf8");
+    await rename(tmpPath, filePath);
+}
+//# sourceMappingURL=io.js.map

package/dist/config/mappings.js

@@ -0,0 +1,9 @@
+import { projectMappingsPath } from "./paths.js";
+import { readJson, writeJson } from "./io.js";
+export async function readProjectMappings(projectDirPath) {
+    return readJson(projectMappingsPath(projectDirPath));
+}
+export async function writeProjectMappings(projectDirPath, data) {
+    await writeJson(projectMappingsPath(projectDirPath), data);
+}
+//# sourceMappingURL=mappings.js.map

package/dist/config/paths.js

@@ -0,0 +1,33 @@
+import os from "node:os";
+import path from "node:path";
+export function userConfigDir(env = process.env) {
+    return env.TRAY_CONFIG_DIR ?? path.join(os.homedir(), ".tray");
+}
+export function credentialsPath(env) {
+    return path.join(userConfigDir(env), "credentials.json");
+}
+export function versionCheckPath(env) {
+    return path.join(userConfigDir(env), "version-check.json");
+}
+export function trayYamlPath(cwd = process.cwd()) {
+    return path.join(cwd, "tray.yaml");
+}
+export function environmentsPath(cwd = process.cwd()) {
+    return path.join(cwd, "environments.json");
+}
+export function pullProgressPath(cwd = process.cwd()) {
+    return path.join(cwd, ".pull-progress.json");
+}
+export function promoteProgressPath(cwd = process.cwd()) {
+    return path.join(cwd, ".promote-progress.json");
+}
+export function projectDir(cwd, projectId, slug) {
+    return path.join(cwd, "projects", `${projectId}--${slug}`);
+}
+export function projectMappingsPath(projectDirPath) {
+    return path.join(projectDirPath, "mappings.json");
+}
+export function projectStatePath(projectDirPath) {
+    return path.join(projectDirPath, "state.json");
+}
+//# sourceMappingURL=paths.js.map

package/dist/config/projectConfig.js

@@ -0,0 +1,16 @@
+import { readJson, writeJson } from "./io.js";
+import { projectMappingsPath, projectStatePath } from "./paths.js";
+export async function readMappings(projectDir) {
+    const data = await readJson(projectMappingsPath(projectDir));
+    return data ?? { version: 1, environments: {} };
+}
+export async function writeMappings(projectDir, data) {
+    await writeJson(projectMappingsPath(projectDir), data);
+}
+export async function readState(projectDir) {
+    return readJson(projectStatePath(projectDir));
+}
+export async function writeState(projectDir, data) {
+    await writeJson(projectStatePath(projectDir), data);
+}
+//# sourceMappingURL=projectConfig.js.map

package/dist/config/pullProgress.js

@@ -0,0 +1,9 @@
+import { pullProgressPath } from "./paths.js";
+import { readJson, writeJson } from "./io.js";
+export async function readPullProgress(cwd) {
+    return readJson(pullProgressPath(cwd));
+}
+export async function writePullProgress(data, cwd) {
+    await writeJson(pullProgressPath(cwd), data);
+}
+//# sourceMappingURL=pullProgress.js.map

package/dist/config/state.js

@@ -0,0 +1,9 @@
+import { projectStatePath } from "./paths.js";
+import { readJson, writeJson } from "./io.js";
+export async function readProjectState(projectDirPath) {
+    return readJson(projectStatePath(projectDirPath));
+}
+export async function writeProjectState(projectDirPath, data) {
+    await writeJson(projectStatePath(projectDirPath), data);
+}
+//# sourceMappingURL=state.js.map

package/dist/config/trayYaml.js

@@ -0,0 +1,9 @@
+import { trayYamlPath } from "./paths.js";
+import { readYaml, writeYaml } from "./yaml.js";
+export async function readTrayYaml(cwd) {
+    return readYaml(trayYamlPath(cwd));
+}
+export async function writeTrayYaml(data, cwd) {
+    await writeYaml(trayYamlPath(cwd), data);
+}
+//# sourceMappingURL=trayYaml.js.map

package/dist/config/types.js

@@ -0,0 +1,21 @@
+export const Regions = {
+    US1: "us1",
+    EU1: "eu1",
+    AP1: "ap1",
+    AP2: "ap2",
+    STAGING: "staging",
+};
+export const Scopes = {
+    PROJECT: "project",
+    WORKSPACE: "workspace",
+};
+export const TrayTypes = {
+    PROJECT: "project",
+    WORKFLOW: "workflow",
+    DATA_TABLE: "data_table",
+    VECTOR_TABLE: "vector_table",
+    AGENT: "agent",
+    API_OPERATION: "api_operation",
+    SCRIPT: "script",
+};
+//# sourceMappingURL=types.js.map