@treeseed/sdk 0.13.0-rc.8 → 0.13.0-rc.80

package/dist/platform/contracts.js

@@ -0,0 +1,93 @@
+import { z } from "zod";
+const digest = z.string().regex(/^sha256:[0-9a-f]{64}$/u);
+const commit = z.string().regex(/^[0-9a-f]{40}$/u);
+const integrationComponentSchema = z.object({
+  id: z.string().min(1),
+  version: z.string().min(1),
+  commit,
+  digest,
+  artifact: z.string().min(1)
+}).strict();
+const integrationLockSchema = z.object({
+  schemaVersion: z.literal("treeseed.platform-integration-lock/v1"),
+  release: z.string().min(1),
+  components: z.array(integrationComponentSchema).min(1),
+  digest
+}).strict();
+const hostTemplateSchema = z.object({
+  schemaVersion: z.literal("treeseed.platform-host-template/v1"),
+  id: z.string().min(1),
+  profiles: z.array(z.string().min(1)).min(1),
+  integration: z.object({ id: z.string().min(1), digest }),
+  inputs: z.array(z.object({ name: z.string().min(1), required: z.boolean(), sensitive: z.boolean().default(false) }))
+}).strict();
+const projectCreatePlanSchema = z.object({
+  schemaVersion: z.literal("treeseed.platform-project-create-plan/v1"),
+  slug: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/u),
+  template: z.object({ id: z.string().min(1), version: z.string().min(1), digest }),
+  team: z.string().min(1),
+  repository: z.object({ owner: z.string().min(1), name: z.string().min(1), visibility: z.enum(["public", "private"]) }),
+  steps: z.array(z.enum(["project", "repository", "template", "library", "inventory"])),
+  actions: z.array(z.object({
+    step: z.enum(["project", "repository", "template", "library", "inventory"]),
+    action: z.enum(["create", "adopt", "apply", "bind", "publish", "noop", "blocked"])
+  })),
+  observationDigest: digest,
+  planDigest: digest,
+  ok: z.boolean(),
+  blockers: z.array(z.string())
+}).strict();
+const projectCreateReceiptSchema = z.object({
+  schemaVersion: z.literal("treeseed.platform-project-create-receipt/v1"),
+  planDigest: digest,
+  slug: projectCreatePlanSchema.shape.slug,
+  template: projectCreatePlanSchema.shape.template,
+  team: z.string().min(1),
+  repository: projectCreatePlanSchema.shape.repository,
+  projectId: z.string().min(1),
+  repositoryUrl: z.string().url(),
+  libraryBindingId: z.string().min(1),
+  inventoryVersion: z.number().int().positive(),
+  actions: projectCreatePlanSchema.shape.actions
+}).strict();
+const providerRegistrationRequestSchema = z.object({
+  schemaVersion: z.literal("treeseed.provider-registration-request/v1"),
+  requestId: z.string().uuid(),
+  teamId: z.string().min(1),
+  publicKey: z.string().min(32),
+  capabilities: z.array(z.string().min(1)),
+  state: z.enum(["pending-approval", "approved", "rejected", "revoked"]),
+  createdAt: z.string().datetime()
+}).strict();
+const providerSessionSchema = z.object({
+  schemaVersion: z.literal("treeseed.provider-session/v1"),
+  providerId: z.string().min(1),
+  scope: z.array(z.string().min(1)).min(1),
+  issuedAt: z.string().datetime(),
+  expiresAt: z.string().datetime(),
+  token: z.string().min(1)
+}).strict();
+const environmentProfileDescriptorSchema = z.object({
+  schemaVersion: z.literal("treeseed.provider-environment-profile/v1"),
+  id: z.string().min(1),
+  variables: z.array(z.object({ name: z.string().regex(/^[A-Z_][A-Z0-9_]*$/u), available: z.boolean(), rotatedAt: z.string().datetime().optional() }))
+}).strict();
+const assignmentEnvironmentGrantSchema = z.object({
+  schemaVersion: z.literal("treeseed.assignment-environment-grant/v1"),
+  assignmentId: z.string().min(1),
+  profileId: z.string().min(1),
+  variables: z.array(z.string().regex(/^[A-Z_][A-Z0-9_]*$/u)),
+  network: z.object({ allowed: z.boolean(), destinations: z.array(z.string()).default([]) }),
+  expiresAt: z.string().datetime()
+}).strict();
+export {
+  assignmentEnvironmentGrantSchema,
+  environmentProfileDescriptorSchema,
+  hostTemplateSchema,
+  integrationComponentSchema,
+  integrationLockSchema,
+  projectCreatePlanSchema,
+  projectCreateReceiptSchema,
+  providerRegistrationRequestSchema,
+  providerSessionSchema
+};

package/dist/platform/index.d.ts

@@ -0,0 +1,6 @@
+export * from './schemas.js';
+export * from './contracts.js';
+export * from './inventory.js';
+export * from './project-create.js';
+export * from './workset.js';
+export * from './verification.js';

package/dist/platform/index.js

@@ -0,0 +1,6 @@
+export * from "./schemas.js";
+export * from "./contracts.js";
+export * from "./inventory.js";
+export * from "./project-create.js";
+export * from "./workset.js";
+export * from "./verification.js";

package/dist/platform/inventory.d.ts

@@ -0,0 +1,11 @@
+import { type Inventory, type PlatformProfile } from './schemas.js';
+export interface LoadedInventory {
+    root: string;
+    path: string;
+    digest: string;
+    inventory: Inventory;
+}
+export declare function loadPlatformInventory(root?: string): LoadedInventory;
+export declare function loadPlatformProfile(path: string): PlatformProfile;
+export declare function loadPlatformProfiles(root?: string): PlatformProfile[];
+export declare function resolveProfileProjects(profiles: readonly PlatformProfile[], selected: readonly string[]): string[];

package/dist/platform/inventory.js

@@ -0,0 +1,53 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { parse } from "yaml";
+import { inventorySchema, profileSchema } from "./schemas.js";
+function yamlFile(path) {
+  return parse(readFileSync(path, "utf8"));
+}
+function loadPlatformInventory(root = process.cwd()) {
+  const sitePath = resolve(root, "treeseed.site.yaml");
+  const site = yamlFile(sitePath);
+  const reference = site.development?.local?.inventory;
+  if (reference?.source !== "seed" || !reference.path) {
+    throw new Error("treeseed.site.yaml must declare development.local.inventory with source seed and a relative path.");
+  }
+  if (resolve(root, reference.path) !== resolve(dirname(sitePath), reference.path)) {
+    throw new Error("Inventory path must resolve beneath the Platform root.");
+  }
+  const path = resolve(root, reference.path);
+  if (!path.startsWith(`${resolve(root)}/`)) throw new Error("Inventory path escapes the Platform root.");
+  const source = readFileSync(path, "utf8");
+  return { root: resolve(root), path, digest: `sha256:${createHash("sha256").update(source).digest("hex")}`, inventory: inventorySchema.parse(parse(source)) };
+}
+function loadPlatformProfile(path) {
+  return profileSchema.parse(yamlFile(path));
+}
+function loadPlatformProfiles(root = process.cwd()) {
+  const directory = resolve(root, "profiles");
+  if (!existsSync(directory)) return [];
+  return readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isFile() && /\.ya?ml$/u.test(entry.name)).map((entry) => loadPlatformProfile(resolve(directory, entry.name))).sort((left, right) => left.id.localeCompare(right.id));
+}
+function resolveProfileProjects(profiles, selected) {
+  const catalog = new Map(profiles.map((profile) => [profile.id, profile]));
+  const result = /* @__PURE__ */ new Set();
+  const active = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (active.has(id)) throw new Error(`Profile inheritance cycle includes ${id}.`);
+    const profile = catalog.get(id);
+    if (!profile) throw new Error(`Unknown Platform profile ${id}.`);
+    active.add(id);
+    profile.extends.forEach(visit);
+    profile.sources.projects.forEach((project) => result.add(project));
+    active.delete(id);
+  };
+  selected.forEach(visit);
+  return [...result].sort();
+}
+export {
+  loadPlatformInventory,
+  loadPlatformProfile,
+  loadPlatformProfiles,
+  resolveProfileProjects
+};

package/dist/platform/project-create.d.ts

@@ -0,0 +1,49 @@
+import { type ProjectCreatePlan, type ProjectCreateReceipt } from './contracts.js';
+export type ProjectCreateStep = 'project' | 'repository' | 'template' | 'library' | 'inventory';
+export type ProjectCreateState = 'missing' | 'ready' | 'conflict';
+export interface ProjectCreateTarget {
+    slug: string;
+    template: {
+        id: string;
+        version: string;
+        digest: string;
+    };
+    team: string;
+    repository: {
+        owner: string;
+        name: string;
+        visibility: 'public' | 'private';
+    };
+}
+export interface ProjectCreateObservation {
+    project: {
+        state: ProjectCreateState;
+        id?: string;
+    };
+    repository: {
+        state: ProjectCreateState;
+        url?: string;
+    };
+    template: {
+        state: ProjectCreateState;
+        digest?: string;
+    };
+    library: {
+        state: ProjectCreateState;
+        bindingId?: string;
+    };
+    inventory: {
+        state: ProjectCreateState;
+        version?: number;
+    };
+}
+export interface ProjectCreateAuthority {
+    observe(target: ProjectCreateTarget): Promise<ProjectCreateObservation>;
+    reconcileProject(target: ProjectCreateTarget): Promise<void>;
+    reconcileRepository(target: ProjectCreateTarget): Promise<void>;
+    applyTemplate(target: ProjectCreateTarget): Promise<void>;
+    reconcileLibrary(target: ProjectCreateTarget): Promise<void>;
+    publishInventory(target: ProjectCreateTarget): Promise<void>;
+}
+export declare function planPlatformProjectCreate(target: ProjectCreateTarget, authority: Pick<ProjectCreateAuthority, 'observe'>): Promise<ProjectCreatePlan>;
+export declare function applyPlatformProjectCreate(plan: ProjectCreatePlan, authority: ProjectCreateAuthority): Promise<ProjectCreateReceipt>;

package/dist/platform/project-create.js

@@ -0,0 +1,75 @@
+import { createHash } from "node:crypto";
+import { projectCreatePlanSchema, projectCreateReceiptSchema } from "./contracts.js";
+const steps = ["project", "repository", "template", "library", "inventory"];
+const actionFor = {
+  project: "create",
+  repository: "adopt",
+  template: "apply",
+  library: "bind",
+  inventory: "publish"
+};
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value && typeof value === "object") return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+  return JSON.stringify(value);
+}
+function digest(value) {
+  return `sha256:${createHash("sha256").update(canonical(value)).digest("hex")}`;
+}
+function blockers(observation) {
+  return steps.filter((step) => observation[step].state === "conflict").map((step) => `${step}_conflicts_with_requested_target`);
+}
+async function planPlatformProjectCreate(target, authority) {
+  const observation = await authority.observe(target);
+  const conflicts = blockers(observation);
+  const base = {
+    schemaVersion: "treeseed.platform-project-create-plan/v1",
+    ...target,
+    steps: [...steps],
+    actions: steps.map((step) => ({ step, action: observation[step].state === "ready" ? "noop" : observation[step].state === "conflict" ? "blocked" : actionFor[step] })),
+    observationDigest: digest(observation),
+    ok: conflicts.length === 0,
+    blockers: conflicts
+  };
+  return projectCreatePlanSchema.parse({ ...base, planDigest: digest(base) });
+}
+function requireReady(observation) {
+  const incomplete = steps.filter((step) => observation[step].state !== "ready");
+  if (incomplete.length) throw new Error(`Project creation postconditions are incomplete: ${incomplete.join(", ")}.`);
+  if (!observation.project.id || !observation.repository.url || !observation.library.bindingId || !observation.inventory.version) {
+    throw new Error("Project creation authority returned incomplete receipt identities.");
+  }
+}
+async function applyPlatformProjectCreate(plan, authority) {
+  const accepted = projectCreatePlanSchema.parse(plan);
+  const { planDigest: _planDigest, ...unsigned } = accepted;
+  if (digest(unsigned) !== accepted.planDigest) throw new Error("Project creation plan digest does not match its frozen inputs.");
+  if (!accepted.ok || accepted.blockers.length) throw new Error("Blocked project creation plans cannot be applied.");
+  const target = { slug: accepted.slug, template: accepted.template, team: accepted.team, repository: accepted.repository };
+  const current = await authority.observe(target);
+  if (digest(current) !== accepted.observationDigest) throw new Error("Project creation authority changed after planning; create a new plan.");
+  const operations = {
+    project: authority.reconcileProject,
+    repository: authority.reconcileRepository,
+    template: authority.applyTemplate,
+    library: authority.reconcileLibrary,
+    inventory: authority.publishInventory
+  };
+  for (const item of accepted.actions) if (item.action !== "noop") await operations[item.step].call(authority, target);
+  const final = await authority.observe(target);
+  requireReady(final);
+  return projectCreateReceiptSchema.parse({
+    schemaVersion: "treeseed.platform-project-create-receipt/v1",
+    planDigest: accepted.planDigest,
+    ...target,
+    projectId: final.project.id,
+    repositoryUrl: final.repository.url,
+    libraryBindingId: final.library.bindingId,
+    inventoryVersion: final.inventory.version,
+    actions: accepted.actions
+  });
+}
+export {
+  applyPlatformProjectCreate,
+  planPlatformProjectCreate
+};