@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/operations/services/template-registry.js

@@ -1,595 +0,0 @@
-import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { basename, dirname, relative, resolve } from "node:path";
-import { runTreeseedGit } from "./git-runner.js";
-import {
-  normalizeTreeseedTemplateId
-} from "../../sdk-types.js";
-import { RemoteTemplateCatalogClient } from "../../template-catalog.js";
-import {
-  normalizeTemplateLaunchRequirements
-} from "../../template-launch-requirements.js";
-import { preserveProjectLaunchHostBindingConfigOverlay } from "./template-host-bindings.js";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-import {
-  resolveTreeseedTemplateCatalogCachePath,
-  resolveTreeseedTemplateCatalogEndpoint
-} from "./config-runtime.js";
-import {
-  cliPackageVersion,
-  agentPackageVersion,
-  corePackageVersion,
-  cliPackageRoot,
-  localTemplateArtifactsRoot,
-  sdkPackageVersion
-} from "./runtime-paths.js";
-const TEMPLATE_CATEGORIES = ["starter", "example", "fixture", "reference-app"];
-function loadJsonFile(filePath) {
-  return JSON.parse(readFileSync(filePath, "utf8"));
-}
-function ensureDir(filePath) {
-  mkdirSync(dirname(filePath), { recursive: true });
-}
-const templatePayloadIgnoredDirectoryNames = /* @__PURE__ */ new Set([
-  "node_modules",
-  "dist",
-  ".astro"
-]);
-const templatePayloadIgnoredRelativePaths = /* @__PURE__ */ new Set([
-  ".treeseed/generated",
-  ".treeseed/test-reports",
-  "public/books"
-]);
-function normalizeTemplateRelativePath(path) {
-  return path.split(/[\\/]+/u).join("/");
-}
-function isIgnoredTemplatePayloadDirectory(root, directoryPath) {
-  const relativePath = normalizeTemplateRelativePath(relative(root, directoryPath));
-  return templatePayloadIgnoredDirectoryNames.has(basename(directoryPath)) || templatePayloadIgnoredRelativePaths.has(relativePath);
-}
-function listFiles(root, currentRoot = root) {
-  if (!existsSync(currentRoot)) {
-    return [];
-  }
-  const files = [];
-  for (const entry of readdirSync(currentRoot, { withFileTypes: true })) {
-    const fullPath = resolve(currentRoot, entry.name);
-    if (entry.isDirectory()) {
-      if (!isIgnoredTemplatePayloadDirectory(root, fullPath)) {
-        files.push(...listFiles(root, fullPath));
-      }
-      continue;
-    }
-    files.push(fullPath);
-  }
-  return files;
-}
-function listTemplateArtifactIds() {
-  const packagedIds = existsSync(localTemplateArtifactsRoot) ? readdirSync(localTemplateArtifactsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name) : [];
-  const localStarterIds = listLocalStarterArtifacts().map((entry) => entry.id);
-  return [.../* @__PURE__ */ new Set([...packagedIds, ...localStarterIds])].sort((left, right) => left.localeCompare(right, void 0, { sensitivity: "base" }));
-}
-const LOCAL_STARTER_ID_TO_DIRECTORY = {
-  "research": "research",
-  "engineering": "engineering"
-};
-function localStartersRoot() {
-  return resolve(cliPackageRoot, "..", "..", "starters");
-}
-function resolveLocalStarterArtifactRoot(id) {
-  const directory = LOCAL_STARTER_ID_TO_DIRECTORY[normalizeTreeseedTemplateId(id)];
-  if (!directory) {
-    return null;
-  }
-  const artifactRoot = resolve(localStartersRoot(), directory);
-  return existsSync(resolve(artifactRoot, "template.config.json")) && existsSync(resolve(artifactRoot, "template")) ? artifactRoot : null;
-}
-function listLocalStarterArtifacts() {
-  return Object.keys(LOCAL_STARTER_ID_TO_DIRECTORY).map((id) => {
-    const artifactRoot = resolveLocalStarterArtifactRoot(id);
-    return artifactRoot ? { id, artifactRoot } : null;
-  }).filter((entry) => Boolean(entry));
-}
-function isTextFile(filePath) {
-  return !/\.(png|jpe?g|gif|webp|ico|woff2?|ttf|eot|pdf|zip|gz)$/iu.test(filePath);
-}
-function validateTemplateProductShape(product) {
-  if (!product.id || !product.displayName || !product.description || !product.summary) {
-    throw new Error(`Template product ${product.id || "(unknown)"} is missing required identity metadata.`);
-  }
-  if (!TEMPLATE_CATEGORIES.includes(product.category)) {
-    throw new Error(`Template product ${product.id} uses unsupported category "${product.category}".`);
-  }
-  if (product.status !== "draft" && product.status !== "live" && product.status !== "archived") {
-    throw new Error(`Template product ${product.id} uses unsupported status "${product.status}".`);
-  }
-  if (product.fulfillmentMode === "packaged" && !existsSync(product.artifactManifestPath)) {
-    throw new Error(`Template product ${product.id} points to a missing artifact manifest: ${product.artifactManifestPath}`);
-  }
-  if (product.fulfillmentMode === "packaged" && !existsSync(product.templateRoot)) {
-    throw new Error(`Template product ${product.id} points to a missing template payload: ${product.templateRoot}`);
-  }
-}
-function validateTemplateManifest(definition) {
-  const { manifest, templateRoot, manifestPath, product } = definition;
-  if (!TEMPLATE_CATEGORIES.includes(manifest.category)) {
-    throw new Error(`Invalid template category in ${manifestPath}: ${manifest.category}`);
-  }
-  if (!manifest.id || !manifest.displayName || !manifest.description) {
-    throw new Error(`Template manifest ${manifestPath} is missing required metadata fields.`);
-  }
-  if (manifest.id !== product.id) {
-    throw new Error(`Template product ${product.id} does not match artifact id ${manifest.id}.`);
-  }
-  if (!existsSync(templateRoot)) {
-    throw new Error(`Template ${manifest.id} is missing template/ at ${templateRoot}.`);
-  }
-  manifest.launchRequirements = normalizeTemplateLaunchRequirements(manifest.launchRequirements, `${manifestPath}: launchRequirements`);
-  validateTemplatePlaceholders(definition);
-}
-function validateTemplatePlaceholders(definition) {
-  const declaredTokens = new Set(definition.manifest.variables.map((variable) => variable.token));
-  const discoveredTokens = /* @__PURE__ */ new Set();
-  for (const filePath of listFiles(definition.templateRoot)) {
-    if (!isTextFile(filePath)) {
-      continue;
-    }
-    const contents = readFileSync(filePath, "utf8");
-    for (const match of contents.matchAll(/__[A-Z0-9_]+__/g)) {
-      discoveredTokens.add(match[0]);
-    }
-  }
-  for (const token of discoveredTokens) {
-    if (!declaredTokens.has(token)) {
-      throw new Error(`Template ${definition.manifest.id} uses undeclared token ${token}.`);
-    }
-  }
-}
-function normalizeTemplateProduct(remoteProduct) {
-  const id = normalizeTreeseedTemplateId(remoteProduct.id);
-  const artifactRoot = resolve(localTemplateArtifactsRoot, id);
-  const source = remoteProduct.fulfillment.source;
-  return {
-    ...remoteProduct,
-    id,
-    contentPath: source.kind === "git" ? `${source.repoUrl}#${id}` : `r2://${source.bucket ?? "bucket"}/${source.objectKey}#${id}`,
-    artifactRoot,
-    artifactManifestPath: resolve(artifactRoot, "template.config.json"),
-    templateRoot: resolve(artifactRoot, "template"),
-    fulfillmentMode: remoteProduct.fulfillment.mode ?? "packaged"
-  };
-}
-function sanitizeCacheSegment(value) {
-  return value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "source";
-}
-function resolveTemplateSourceCacheRoot(product, options) {
-  const cachePath = resolveTreeseedTemplateCatalogCachePath(options.cwd ?? process.cwd());
-  const sourceVersion = product.fulfillment.source.kind === "git" ? product.fulfillment.source.ref : product.fulfillment.source.version;
-  return resolve(dirname(cachePath), "templates", sanitizeCacheSegment(product.id), sanitizeCacheSegment(sourceVersion));
-}
-function runGit(commandArgs, cwd) {
-  const mutating = /^(add|commit|checkout|switch|merge|tag|push|fetch|worktree|submodule|reset|clean|restore|branch|clone)$/u.test(commandArgs[0] ?? "");
-  const result = runTreeseedGit(commandArgs, {
-    cwd: cwd ?? process.cwd(),
-    mode: mutating ? "mutate" : "read"
-  });
-  if (result.status !== 0) {
-    throw new Error(result.stderr?.trim() || result.stdout?.trim() || `git ${commandArgs.join(" ")} failed`);
-  }
-}
-function readGitOutput(commandArgs, cwd) {
-  const result = runTreeseedGit(commandArgs, {
-    cwd: cwd ?? process.cwd(),
-    mode: "read",
-    allowFailure: true
-  });
-  return result.status === 0 ? result.stdout.trim() : null;
-}
-function materializeGitTemplateSource(product, options) {
-  const cacheRoot = resolveTemplateSourceCacheRoot(product, options);
-  const repoRoot = resolve(cacheRoot, "repo");
-  const source = product.fulfillment.source;
-  const cachedOrigin = existsSync(resolve(repoRoot, ".git")) ? readGitOutput(["config", "--get", "remote.origin.url"], repoRoot) : null;
-  if (cachedOrigin !== source.repoUrl) {
-    rmSync(cacheRoot, { recursive: true, force: true });
-    mkdirSync(cacheRoot, { recursive: true });
-    runGit(["clone", "--no-checkout", source.repoUrl, repoRoot]);
-  }
-  runGit(["fetch", "--all", "--tags"], repoRoot);
-  runGit(["checkout", "--force", source.ref], repoRoot);
-  const artifactRoot = resolve(repoRoot, source.directory);
-  return {
-    artifactRoot,
-    manifestPath: resolve(artifactRoot, "template.config.json"),
-    templateRoot: resolve(artifactRoot, "template")
-  };
-}
-function materializeR2TemplateSource(product) {
-  if (existsSync(product.artifactManifestPath) && existsSync(product.templateRoot)) {
-    return {
-      artifactRoot: product.artifactRoot,
-      manifestPath: product.artifactManifestPath,
-      templateRoot: product.templateRoot
-    };
-  }
-  throw new Error(
-    `Template ${product.id} uses an R2 fulfillment source (${product.fulfillment.source.objectKey}) but no packaged artifact is present in the local cache yet.`
-  );
-}
-function resolveTemplateDefinitionPaths(product, options) {
-  const localStarterArtifactRoot = resolveLocalStarterArtifactRoot(product.id);
-  if (localStarterArtifactRoot) {
-    return {
-      artifactRoot: localStarterArtifactRoot,
-      manifestPath: resolve(localStarterArtifactRoot, "template.config.json"),
-      templateRoot: resolve(localStarterArtifactRoot, "template")
-    };
-  }
-  if (existsSync(product.artifactManifestPath) && existsSync(product.templateRoot)) {
-    return {
-      artifactRoot: product.artifactRoot,
-      manifestPath: product.artifactManifestPath,
-      templateRoot: product.templateRoot
-    };
-  }
-  return product.fulfillment.source.kind === "git" ? materializeGitTemplateSource(product, options) : materializeR2TemplateSource(product);
-}
-function readTemplateCatalogCache(cachePath) {
-  if (!existsSync(cachePath)) {
-    return null;
-  }
-  return loadJsonFile(cachePath);
-}
-function writeTemplateCatalogCache(cachePath, endpoint, response) {
-  ensureDir(cachePath);
-  const payload = {
-    endpoint,
-    fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    items: response.items
-  };
-  writeFileSync(cachePath, `${JSON.stringify(payload, null, 2)}
-`, "utf8");
-}
-async function loadRemoteTemplateCatalog(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const env = options.env ?? process.env;
-  const endpoint = resolveTreeseedTemplateCatalogEndpoint(cwd, env);
-  const cachePath = resolveTreeseedTemplateCatalogCachePath(cwd);
-  try {
-    const response = await new RemoteTemplateCatalogClient({ endpoint }).listTemplates();
-    writeTemplateCatalogCache(cachePath, endpoint, response);
-    return {
-      items: response.items,
-      endpoint,
-      usedCache: false
-    };
-  } catch (error) {
-    const cached = readTemplateCatalogCache(cachePath);
-    if (!cached) {
-      throw error;
-    }
-    options.writeWarning?.(
-      `Using cached template catalog from ${cached.fetchedAt} because the remote endpoint could not be reached.`
-    );
-    return {
-      items: cached.items,
-      endpoint: cached.endpoint,
-      usedCache: true
-    };
-  }
-}
-function loadTemplateState(siteRoot) {
-  const statePath = resolve(siteRoot, ".treeseed", "template-state.json");
-  if (!existsSync(statePath)) {
-    throw new Error(`Template state is missing at ${statePath}. This site may not have been created from a Treeseed template.`);
-  }
-  return loadJsonFile(statePath);
-}
-function writeTemplateState(siteRoot, state) {
-  const statePath = resolve(siteRoot, ".treeseed", "template-state.json");
-  ensureDir(statePath);
-  writeFileSync(statePath, `${JSON.stringify(state, null, 2)}
-`, "utf8");
-}
-function toTitleCase(value) {
-  return value.split(/[-_\s]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
-}
-function inferSlug(target, explicitSlug) {
-  return (explicitSlug ?? target).toLowerCase().replace(/[^a-z0-9-]+/g, "-");
-}
-function inferName(target, explicitName) {
-  return explicitName ?? toTitleCase(target);
-}
-function resolveVariableValue(variable, input) {
-  switch (variable.deriveFrom) {
-    case "slug":
-      return inferSlug(input.target, input.slug);
-    case "name":
-      return inferName(input.target, input.name);
-    case "siteUrl":
-      return input.siteUrl ?? variable.default ?? "";
-    case "contactEmail":
-      return input.contactEmail ?? variable.default ?? "";
-    case "repositoryUrl":
-      return input.repositoryUrl ?? variable.default ?? "";
-    case "discordUrl":
-      return input.discordUrl ?? variable.default ?? "";
-    case "cliVersion":
-      return `^${cliPackageVersion}`;
-    case "agentVersion":
-      return `^${agentPackageVersion}`;
-    case "coreVersion":
-      return `^${corePackageVersion}`;
-    case "sdkVersion":
-      return `^${sdkPackageVersion}`;
-    default:
-      return variable.default ?? "";
-  }
-}
-function applyReplacements(source, replacements) {
-  let output = source;
-  for (const [token, value] of Object.entries(replacements)) {
-    output = output.split(token).join(value);
-  }
-  return output;
-}
-function renderTemplateFile(filePath, replacements) {
-  return applyReplacements(readFileSync(filePath, "utf8"), replacements);
-}
-function copyTemplateTree(templateRoot, targetRoot, replacements) {
-  for (const filePath of listFiles(templateRoot)) {
-    const relativePath = relative(templateRoot, filePath);
-    const outputPath = resolve(targetRoot, relativePath);
-    ensureDir(outputPath);
-    if (isTextFile(filePath)) {
-      writeFileSync(outputPath, renderTemplateFile(filePath, replacements), "utf8");
-      continue;
-    }
-    cpSync(filePath, outputPath, { recursive: false });
-  }
-}
-function syncManagedPackageJson(targetPath, sourcePath, replacements, check) {
-  const currentJson = existsSync(targetPath) ? loadJsonFile(targetPath) : {};
-  const templateJson = JSON.parse(renderTemplateFile(sourcePath, replacements));
-  const nextJson = {
-    ...currentJson,
-    type: templateJson.type ?? currentJson.type,
-    scripts: typeof templateJson.scripts === "object" && templateJson.scripts !== null ? { ...currentJson.scripts ?? {}, ...templateJson.scripts } : currentJson.scripts,
-    dependencies: {
-      ...currentJson.dependencies ?? {},
-      ...Object.fromEntries(
-        Object.entries(templateJson.dependencies ?? {}).filter(([name]) => name.startsWith("@treeseed/"))
-      )
-    }
-  };
-  const currentSerialized = `${JSON.stringify(currentJson, null, 2)}
-`;
-  const nextSerialized = `${JSON.stringify(nextJson, null, 2)}
-`;
-  if (currentSerialized === nextSerialized) {
-    return false;
-  }
-  if (!check) {
-    writeFileSync(targetPath, nextSerialized, "utf8");
-  }
-  return true;
-}
-function validateYamlFile(filePath) {
-  parseYaml(readFileSync(filePath, "utf8"));
-}
-async function listTemplateProducts(options = {}) {
-  const remoteCatalog = await loadRemoteTemplateCatalog(options);
-  return remoteCatalog.items.map((entry) => normalizeTemplateProduct(entry)).sort((left, right) => {
-    const featuredDiff = Number(Boolean(right.featured)) - Number(Boolean(left.featured));
-    if (featuredDiff !== 0) {
-      return featuredDiff;
-    }
-    return left.displayName.localeCompare(right.displayName, void 0, { sensitivity: "base" });
-  });
-}
-async function resolveTemplateProduct(id, options = {}) {
-  const normalizedId = normalizeTreeseedTemplateId(id);
-  const product = (await listTemplateProducts(options)).find((entry) => entry.id === normalizedId);
-  if (!product) {
-    throw new Error(`Unable to resolve remote template product "${id}".`);
-  }
-  return product;
-}
-async function resolveTemplateDefinition(id, options = {}, category) {
-  const product = await resolveTemplateProduct(id, options);
-  if (category && product.category !== category) {
-    throw new Error(`Unable to resolve template "${id}" in category "${category}".`);
-  }
-  validateTemplateProductShape(product);
-  const resolvedPaths = resolveTemplateDefinitionPaths(product, options);
-  const manifest = loadJsonFile(resolvedPaths.manifestPath);
-  const definition = {
-    product,
-    manifestPath: resolvedPaths.manifestPath,
-    templateRoot: resolvedPaths.templateRoot,
-    manifest
-  };
-  validateTemplateManifest(definition);
-  return definition;
-}
-async function validateTemplateProduct(product, options = {}) {
-  const definition = await resolveTemplateDefinition(product.id, options);
-  if (definition.manifest.templateApiVersion !== definition.product.templateApiVersion) {
-    throw new Error(`Template product ${definition.product.id} and artifact templateApiVersion do not match.`);
-  }
-  if ((definition.manifest.templateVersion ?? "") && definition.manifest.templateVersion !== definition.product.templateVersion) {
-    throw new Error(`Template product ${definition.product.id} and artifact templateVersion do not match.`);
-  }
-  if (definition.manifest.minCliVersion !== definition.product.minCliVersion) {
-    throw new Error(`Template product ${definition.product.id} and artifact minCliVersion do not match.`);
-  }
-  if ((definition.manifest.minCoreVersion ?? "") && definition.manifest.minCoreVersion !== definition.product.minCoreVersion) {
-    throw new Error(`Template product ${definition.product.id} and artifact minCoreVersion do not match.`);
-  }
-  return definition;
-}
-async function validateAllTemplateDefinitions(options = {}) {
-  const ids = listTemplateArtifactIds();
-  return Promise.all(ids.map((id) => validateTemplateProduct({ id }, options)));
-}
-function buildTemplateReplacements(manifest, input) {
-  const replacements = {};
-  for (const variable of manifest.variables) {
-    const value = resolveVariableValue(variable, input);
-    if (variable.required && !value) {
-      throw new Error(`Template "${manifest.id}" requires a value for "${variable.name}".`);
-    }
-    replacements[variable.token] = value;
-  }
-  return replacements;
-}
-async function scaffoldTemplateProject(templateId, targetRoot, input, options = {}) {
-  const definition = await resolveTemplateDefinition(templateId, options);
-  const replacements = buildTemplateReplacements(definition.manifest, {
-    ...input,
-    target: basename(targetRoot)
-  });
-  copyTemplateTree(definition.templateRoot, targetRoot, replacements);
-  writeTemplateState(targetRoot, {
-    templateId: definition.product.id,
-    templateVersion: definition.product.templateVersion,
-    sourceRef: definition.product.fulfillment.source.ref,
-    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    replacements,
-    ...input.hostBindingState ? {
-      hostBindings: input.hostBindingState.hostBindings,
-      hostBindingPlans: input.hostBindingState.hostBindingPlans,
-      hostBindingSummaries: input.hostBindingState.hostBindingSummaries,
-      hostBindingConfig: input.hostBindingState.hostBindingConfig
-    } : {}
-  });
-  return definition.product;
-}
-function recordTemplateHostBindingState(siteRoot, hostBindingState) {
-  const state = loadTemplateState(siteRoot);
-  writeTemplateState(siteRoot, {
-    ...state,
-    hostBindings: hostBindingState.hostBindings,
-    hostBindingPlans: hostBindingState.hostBindingPlans,
-    hostBindingSummaries: hostBindingState.hostBindingSummaries,
-    hostBindingConfig: hostBindingState.hostBindingConfig
-  });
-}
-function preserveHostBindingOverlayIfNeeded(relativePath, currentContent, nextContent, state) {
-  if (!state.hostBindingPlans) {
-    return nextContent;
-  }
-  if (relativePath !== "treeseed.site.yaml" && relativePath !== "src/env.yaml" && relativePath !== "src/manifest.yaml" && relativePath !== "package.json") {
-    return nextContent;
-  }
-  return preserveProjectLaunchHostBindingConfigOverlay({
-    target: relativePath,
-    currentContent,
-    nextContent,
-    hostBindingPlans: state.hostBindingPlans
-  });
-}
-function structuredTemplateContentMatches(relativePath, currentContent, nextContent) {
-  if (relativePath !== "treeseed.site.yaml" && relativePath !== "src/env.yaml" && relativePath !== "src/manifest.yaml" && relativePath !== "package.json") {
-    return false;
-  }
-  try {
-    const current = relativePath === "package.json" ? JSON.parse(currentContent || "{}") : parseYaml(currentContent || "{}");
-    const next = relativePath === "package.json" ? JSON.parse(nextContent || "{}") : parseYaml(nextContent || "{}");
-    return JSON.stringify(current) === JSON.stringify(next);
-  } catch {
-    return false;
-  }
-}
-async function syncTemplateProject(siteRoot, options = {}) {
-  const check = options.check === true;
-  const state = loadTemplateState(siteRoot);
-  const definition = await resolveTemplateDefinition(state.templateId, options);
-  const managedSurface = definition.manifest.managedSurface ?? {};
-  const changes = [];
-  for (const relativePath of managedSurface.coreManaged ?? []) {
-    const targetPath = resolve(siteRoot, relativePath);
-    const sourcePath = resolve(definition.templateRoot, relativePath);
-    if (!existsSync(sourcePath)) {
-      throw new Error(`Managed template file is missing from artifact: ${relativePath}`);
-    }
-    if (relativePath === "package.json") {
-      if (syncManagedPackageJson(targetPath, sourcePath, state.replacements, check)) {
-        changes.push(relativePath);
-      }
-      continue;
-    }
-    const currentContent = existsSync(targetPath) ? readFileSync(targetPath, "utf8") : "";
-    const nextContent = preserveHostBindingOverlayIfNeeded(
-      relativePath,
-      currentContent,
-      renderTemplateFile(sourcePath, state.replacements),
-      state
-    );
-    if (currentContent === nextContent) {
-      continue;
-    }
-    if (state.hostBindingPlans && structuredTemplateContentMatches(relativePath, currentContent, nextContent)) {
-      continue;
-    }
-    if (!check) {
-      ensureDir(targetPath);
-      writeFileSync(targetPath, nextContent, "utf8");
-    }
-    changes.push(relativePath);
-  }
-  for (const relativePath of managedSurface.validatedOnly ?? []) {
-    const targetPath = resolve(siteRoot, relativePath);
-    if (!existsSync(targetPath)) {
-      throw new Error(`Validated file is missing from generated site: ${relativePath}`);
-    }
-    validateYamlFile(targetPath);
-  }
-  if (!check) {
-    writeTemplateState(siteRoot, {
-      ...state,
-      templateId: definition.product.id,
-      templateVersion: definition.product.templateVersion,
-      sourceRef: definition.product.fulfillment.source.ref,
-      lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-  }
-  return changes;
-}
-function serializeTemplateRegistryEntry(product) {
-  return {
-    id: product.id,
-    displayName: product.displayName,
-    description: product.description,
-    summary: product.summary,
-    status: product.status,
-    featured: Boolean(product.featured),
-    category: product.category,
-    tags: product.tags ?? [],
-    publisher: product.publisher,
-    templateVersion: product.templateVersion,
-    templateApiVersion: product.templateApiVersion,
-    minCliVersion: product.minCliVersion,
-    minCoreVersion: product.minCoreVersion,
-    fulfillmentMode: product.fulfillment.mode ?? "packaged",
-    source: product.fulfillment.source,
-    launchRequirements: product.launchRequirements
-  };
-}
-async function exportTemplateCatalogYaml(options = {}) {
-  return stringifyYaml((await listTemplateProducts(options)).map(serializeTemplateRegistryEntry));
-}
-export {
-  TEMPLATE_CATEGORIES,
-  buildTemplateReplacements,
-  exportTemplateCatalogYaml,
-  listTemplateProducts,
-  recordTemplateHostBindingState,
-  resolveTemplateDefinition,
-  resolveTemplateProduct,
-  scaffoldTemplateProject,
-  serializeTemplateRegistryEntry,
-  syncTemplateProject,
-  validateAllTemplateDefinitions,
-  validateTemplateProduct
-};

package/dist/operations/services/template-secret-sync.d.ts

@@ -1,97 +0,0 @@
-import { syncTreeseedCloudflareEnvironment, syncTreeseedGitHubEnvironment, syncTreeseedRailwayEnvironment, type TreeseedConfigScope } from './config-runtime.js';
-import type { ProjectLaunchResolvedHostBinding, ProjectLaunchSecretDeploymentPlanItem } from '../../template-launch-requirements.js';
-import type { ProjectLaunchRequirementKind } from '../../sdk-types.js';
-export type ProjectLaunchSecretSyncProvider = 'github' | 'cloudflare' | 'railway';
-export type ProjectLaunchSecretSyncStatus = 'synced' | 'skipped' | 'failed';
-export type ProjectLaunchSecretSyncProviderStatus = 'running' | 'completed' | 'failed';
-export type ProjectLaunchSecretSyncTargetKind = 'github-secret' | 'github-variable' | 'cloudflare-secret' | 'cloudflare-var' | 'railway-secret' | 'railway-var';
-export interface ProjectLaunchSecretValueDiagnostic {
-    code: 'missing_value' | 'unsupported_target';
-    requirementKey: string;
-    requirementKind: ProjectLaunchRequirementKind;
-    env: string;
-    source: string;
-    targets: string[];
-    scopes: TreeseedConfigScope[];
-    message: string;
-}
-export interface ProjectLaunchResolvedSecretValueItem {
-    requirementKey: string;
-    requirementKind: ProjectLaunchRequirementKind;
-    env: string;
-    source: string;
-    targets: ProjectLaunchSecretSyncTargetKind[];
-    scopes: TreeseedConfigScope[];
-    sensitivity: string;
-    sourceHostId?: string | null;
-    resolved: boolean;
-}
-export interface ProjectLaunchSecretValueOverlayResult {
-    valuesOverlay: Record<string, string>;
-    items: ProjectLaunchResolvedSecretValueItem[];
-    diagnostics: ProjectLaunchSecretValueDiagnostic[];
-}
-export interface ProjectLaunchSecretSyncSummaryItem {
-    provider: ProjectLaunchSecretSyncProvider;
-    scope: TreeseedConfigScope;
-    target: ProjectLaunchSecretSyncTargetKind;
-    env: string;
-    requirementKey: string;
-    requirementKind: ProjectLaunchRequirementKind;
-    sensitivity: string;
-    status: ProjectLaunchSecretSyncStatus;
-    error?: {
-        message: string;
-    };
-}
-export interface ProjectLaunchSecretSyncProviderSummary {
-    provider: ProjectLaunchSecretSyncProvider;
-    scope: TreeseedConfigScope;
-    entryIds: string[];
-    status: Exclude<ProjectLaunchSecretSyncProviderStatus, 'running'>;
-    error?: {
-        message: string;
-    };
-}
-export interface ProjectLaunchSecretSyncProgressEvent {
-    provider: ProjectLaunchSecretSyncProvider;
-    scope: TreeseedConfigScope;
-    status: ProjectLaunchSecretSyncProviderStatus;
-    entryIds: string[];
-    message: string;
-}
-export interface ProjectLaunchSecretSyncResult {
-    ok: boolean;
-    items: ProjectLaunchSecretSyncSummaryItem[];
-    providers: ProjectLaunchSecretSyncProviderSummary[];
-    diagnostics: ProjectLaunchSecretValueDiagnostic[];
-}
-export interface ProjectLaunchSecretSyncAdapters {
-    github?: typeof syncTreeseedGitHubEnvironment;
-    cloudflare?: typeof syncTreeseedCloudflareEnvironment;
-    railway?: typeof syncTreeseedRailwayEnvironment;
-}
-export interface ResolveProjectLaunchSecretValueOverlayOptions {
-    hostBindings?: Record<string, ProjectLaunchResolvedHostBinding> | null;
-    secretDeploymentPlan?: {
-        items?: ProjectLaunchSecretDeploymentPlanItem[] | null;
-    } | null;
-    valuesOverlay?: Record<string, string | undefined> | null;
-    valuesByScope?: Partial<Record<TreeseedConfigScope, Record<string, string | undefined> | null>> | null;
-    processEnv?: Record<string, string | undefined>;
-    scopes?: TreeseedConfigScope[];
-}
-export interface SyncProjectLaunchHostBindingSecretsOptions extends ResolveProjectLaunchSecretValueOverlayOptions {
-    projectRoot: string;
-    repository?: string | null;
-    planOnly?: boolean;
-    providers?: ProjectLaunchSecretSyncProvider[];
-    onProgress?: (event: ProjectLaunchSecretSyncProgressEvent) => void | Promise<void>;
-    adapters?: ProjectLaunchSecretSyncAdapters;
-}
-export declare class ProjectLaunchSecretSyncError extends Error {
-    readonly result: ProjectLaunchSecretSyncResult;
-    constructor(message: string, result: ProjectLaunchSecretSyncResult);
-}
-export declare function resolveProjectLaunchSecretValueOverlay(options: ResolveProjectLaunchSecretValueOverlayOptions): ProjectLaunchSecretValueOverlayResult;
-export declare function syncProjectLaunchHostBindingSecrets(options: SyncProjectLaunchHostBindingSecretsOptions): Promise<ProjectLaunchSecretSyncResult>;