@treeseed/sdk 0.4.6 → 0.4.7

package/dist/operations/services/template-registry.d.ts

@@ -37,6 +37,7 @@ export interface TemplateProductDefinition extends SdkTemplateCatalogEntry {
     artifactRoot: string;
     artifactManifestPath: string;
     templateRoot: string;
+    fulfillmentMode: 'packaged' | 'git';
 }
 export interface ResolvedTemplateDefinition {
     product: TemplateProductDefinition;
@@ -82,6 +83,7 @@ export declare function serializeTemplateRegistryEntry(product: Pick<TemplatePro
     templateApiVersion: number;
     minCliVersion: string;
     minCoreVersion: string | undefined;
+    fulfillmentMode: "git" | "packaged";
     source: import("../../sdk-types.ts").SdkTemplateCatalogSource;
 };
 export declare function exportTemplateCatalogYaml(options?: TemplateCatalogOptions): Promise<string>;

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

@@ -1,4 +1,5 @@
-import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
 import { basename, dirname, relative, resolve } from "node:path";
 import { RemoteTemplateCatalogClient } from "../../template-catalog.js";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
@@ -53,10 +54,10 @@ function validateTemplateProductShape(product) {
   if (product.status !== "draft" && product.status !== "live" && product.status !== "archived") {
     throw new Error(`Template product ${product.id} uses unsupported status "${product.status}".`);
   }
-  if (!existsSync(product.artifactManifestPath)) {
+  if (product.fulfillmentMode === "packaged" && !existsSync(product.artifactManifestPath)) {
     throw new Error(`Template product ${product.id} points to a missing artifact manifest: ${product.artifactManifestPath}`);
   }
-  if (!existsSync(product.templateRoot)) {
+  if (product.fulfillmentMode === "packaged" && !existsSync(product.templateRoot)) {
     throw new Error(`Template product ${product.id} points to a missing template payload: ${product.templateRoot}`);
   }
 }
@@ -101,9 +102,55 @@ function normalizeTemplateProduct(remoteProduct) {
     contentPath: `${remoteProduct.fulfillment.source.repoUrl}#${remoteProduct.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());
+  return resolve(dirname(cachePath), "templates", sanitizeCacheSegment(product.id), sanitizeCacheSegment(product.fulfillment.source.ref));
+}
+function runGit(commandArgs, cwd) {
+  const result = spawnSync("git", commandArgs, {
+    cwd,
+    stdio: "pipe",
+    encoding: "utf8"
+  });
+  if (result.status !== 0) {
+    throw new Error(result.stderr?.trim() || result.stdout?.trim() || `git ${commandArgs.join(" ")} failed`);
+  }
+}
+function materializeGitTemplateSource(product, options) {
+  const cacheRoot = resolveTemplateSourceCacheRoot(product, options);
+  const repoRoot = resolve(cacheRoot, "repo");
+  const source = product.fulfillment.source;
+  if (!existsSync(resolve(repoRoot, ".git"))) {
+    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 resolveTemplateDefinitionPaths(product, options) {
+  if (existsSync(product.artifactManifestPath) && existsSync(product.templateRoot)) {
+    return {
+      artifactRoot: product.artifactRoot,
+      manifestPath: product.artifactManifestPath,
+      templateRoot: product.templateRoot
+    };
+  }
+  return materializeGitTemplateSource(product, options);
+}
 function readTemplateCatalogCache(cachePath) {
   if (!existsSync(cachePath)) {
     return null;
@@ -268,11 +315,12 @@ async function resolveTemplateDefinition(id, options = {}, category) {
     throw new Error(`Unable to resolve template "${id}" in category "${category}".`);
   }
   validateTemplateProductShape(product);
-  const manifest = loadJsonFile(product.artifactManifestPath);
+  const resolvedPaths = resolveTemplateDefinitionPaths(product, options);
+  const manifest = loadJsonFile(resolvedPaths.manifestPath);
   const definition = {
     product,
-    manifestPath: product.artifactManifestPath,
-    templateRoot: product.templateRoot,
+    manifestPath: resolvedPaths.manifestPath,
+    templateRoot: resolvedPaths.templateRoot,
     manifest
   };
   validateTemplateManifest(definition);
@@ -387,6 +435,7 @@ function serializeTemplateRegistryEntry(product) {
     templateApiVersion: product.templateApiVersion,
     minCliVersion: product.minCliVersion,
     minCoreVersion: product.minCoreVersion,
+    fulfillmentMode: product.fulfillment.mode ?? "packaged",
     source: product.fulfillment.source
   };
 }

package/dist/sdk-types.d.ts

@@ -777,6 +777,7 @@ export interface SdkTemplateCatalogEntry {
     minCliVersion: string;
     minCoreVersion?: string;
     fulfillment: {
+        mode?: 'packaged' | 'git';
         source: SdkTemplateCatalogSource;
         hooksPolicy: 'builtin_only' | 'trusted_only' | 'disabled';
         supportsReconcile: boolean;

package/dist/template-catalog.js

@@ -66,6 +66,7 @@ function normalizeTemplateCatalogEntry(value) {
     minCliVersion: expectString(record.minCliVersion, "minCliVersion"),
     minCoreVersion: optionalString(record.minCoreVersion),
     fulfillment: {
+      mode: optionalString(fulfillment.mode),
       source: {
         kind: "git",
         repoUrl: expectString(source.repoUrl, "fulfillment.source.repoUrl"),

package/dist/workflow/operations.d.ts

@@ -1,6 +1,7 @@
 import { resolveTreeseedWorkflowState } from '../workflow-state.ts';
 import type { TreeseedCloseInput, TreeseedConfigInput, TreeseedDestroyInput, TreeseedReleaseInput, TreeseedSaveInput, TreeseedStageInput, TreeseedSwitchInput, TreeseedTaskBranchMetadata, TreeseedWorkflowContext, TreeseedWorkflowDevInput, TreeseedWorkflowNextStep, TreeseedWorkflowOperationId, TreeseedWorkflowResult } from '../workflow.ts';
 type WorkflowWrite = NonNullable<TreeseedWorkflowContext['write']>;
+type WorkflowStatePayload = ReturnType<typeof resolveTreeseedWorkflowState>;
 export type TreeseedWorkflowErrorCode = 'validation_failed' | 'merge_conflict' | 'missing_runtime_auth' | 'deployment_timeout' | 'confirmation_required' | 'unsupported_transport' | 'unsupported_state';
 export declare class TreeseedWorkflowError extends Error {
     code: TreeseedWorkflowErrorCode;
@@ -29,7 +30,75 @@ export declare function workflowStatus(helpers: WorkflowOperationHelpers): Promi
 export declare function workflowTasks(helpers: WorkflowOperationHelpers): Promise<TreeseedWorkflowResult<{
     tasks: TreeseedTaskBranchMetadata[];
 }>>;
-export declare function workflowConfig(helpers: WorkflowOperationHelpers, input?: TreeseedConfigInput): Promise<{
+export declare function workflowConfig(helpers: WorkflowOperationHelpers, input?: TreeseedConfigInput): Promise<TreeseedWorkflowResult<{
+    mode: string;
+    scopes: ("local" | "staging" | "prod")[];
+    sync: "all" | "cloudflare" | "railway" | "none" | "github";
+    configPath: string;
+    keyPath: string;
+    repairs: TreeseedRepairAction[];
+    preflight: {
+        ok: boolean;
+        requireAuth: boolean;
+        missingCommands: string[];
+        failingAuth: string[];
+        checks: {
+            commands: {
+                [k: string]: {
+                    installed: boolean;
+                    path: string | null;
+                };
+            };
+            auth: {};
+        };
+    };
+    toolHealth: {
+        githubCli: {
+            name: any;
+            available: any;
+            detail: any;
+        };
+        ghActExtension: {
+            name: any;
+            available: any;
+            detail: any;
+        };
+        dockerDaemon: {
+            name: any;
+            available: any;
+            detail: any;
+        };
+        actVerificationReady: any;
+        remediation: string[];
+    };
+    result: {
+        scopes: string[];
+        updated: never[];
+        synced: {};
+        initialized: never[];
+        connectionChecks: never[];
+    };
+    state: import("../workflow-state.ts").TreeseedWorkflowState;
+    readiness: {
+        local: {
+            ready: boolean;
+            blockers: string[];
+            warnings: string[];
+        };
+        staging: {
+            ready: boolean;
+            blockers: string[];
+            warnings: string[];
+        };
+        prod: {
+            ready: boolean;
+            blockers: string[];
+            warnings: string[];
+        };
+    };
+} & {
+    finalState: WorkflowStatePayload;
+}> | {
     ok: true;
     operation: "config";
     payload: {
@@ -78,9 +147,6 @@ export declare function workflowConfig(helpers: WorkflowOperationHelpers, input?
             remediation: string[];
         };
         keyPath?: undefined;
-        configPath?: undefined;
-        result?: undefined;
-        state?: undefined;
     };
     nextSteps: TreeseedWorkflowNextStep[];
 } | {
@@ -128,189 +194,195 @@ export declare function workflowConfig(helpers: WorkflowOperationHelpers, input?
         };
         secretsRevealed?: undefined;
         reports?: undefined;
-        configPath?: undefined;
-        result?: undefined;
-        state?: undefined;
     };
     nextSteps: TreeseedWorkflowNextStep[];
-} | {
-    ok: true;
-    operation: "config";
-    payload: {
+}>;
+export declare function workflowSwitch(helpers: WorkflowOperationHelpers, input: TreeseedSwitchInput): Promise<TreeseedWorkflowResult<{
+    branchName: string;
+    created: boolean;
+    resumed: boolean;
+    previewRequested: boolean;
+    preview: {
+        enabled: boolean;
+        url: string | null;
+        lastDeploymentTimestamp: string | null;
+    };
+    previewResult: Record<string, unknown> | null;
+    preconditions: {
+        cleanWorktreeRequired: boolean;
+        baseBranch: string;
+    };
+} & {
+    finalState: WorkflowStatePayload;
+}>>;
+export declare function workflowDev(helpers: WorkflowOperationHelpers, input?: TreeseedWorkflowDevInput): Promise<TreeseedWorkflowResult<{
+    watch: boolean;
+    background: boolean;
+    command: string;
+    args: string[];
+    cwd: string;
+    pid: number | null;
+    exitCode: null;
+    runtime: {
         mode: string;
-        scopes: ("local" | "staging" | "prod")[];
-        sync: "all" | "cloudflare" | "railway" | "none" | "github";
-        configPath: string;
-        keyPath: string;
-        repairs: TreeseedRepairAction[];
-        preflight: {
-            ok: boolean;
-            requireAuth: boolean;
-            missingCommands: string[];
-            failingAuth: string[];
-            checks: {
-                commands: {
-                    [k: string]: {
-                        installed: boolean;
-                        path: string | null;
-                    };
-                };
-                auth: {};
-            };
-        };
-        toolHealth: {
-            githubCli: {
-                name: any;
-                available: any;
-                detail: any;
-            };
-            ghActExtension: {
-                name: any;
-                available: any;
-                detail: any;
-            };
-            dockerDaemon: {
-                name: any;
-                available: any;
-                detail: any;
-            };
-            actVerificationReady: any;
-            remediation: string[];
-        };
-        result: {
-            scopes: string[];
-            updated: never[];
-            synced: {};
-            initialized: never[];
-            connectionChecks: never[];
-        };
-        state: import("../workflow-state.ts").TreeseedWorkflowState;
-        secretsRevealed?: undefined;
-        reports?: undefined;
+        apiBaseUrl: string;
+        webUrl: string;
     };
-    nextSteps: TreeseedWorkflowNextStep[];
-}>;
-export declare function workflowSwitch(helpers: WorkflowOperationHelpers, input: TreeseedSwitchInput): Promise<{
-    ok: boolean;
-    operation: string;
-    payload: {
-        branchName: string;
-        created: boolean;
-        resumed: boolean;
-        previewRequested: boolean;
-        preview: {
-            enabled: boolean;
-            url: string | null;
-            lastDeploymentTimestamp: string | null;
-        };
-        previewResult: Record<string, unknown> | null;
-        state: import("../workflow-state.ts").TreeseedWorkflowState;
+    readiness: {
+        ready: boolean;
+        blockers: string[];
+        warnings: string[];
     };
-    nextSteps: TreeseedWorkflowNextStep[];
-}>;
-export declare function workflowDev(helpers: WorkflowOperationHelpers, input?: TreeseedWorkflowDevInput): Promise<{
-    ok: true;
-    operation: "dev";
-    payload: {
-        watch: boolean;
-        background: boolean;
-        command: string;
-        args: string[];
-        cwd: string;
-        pid: number | null;
-        exitCode: null;
+} & {
+    finalState: WorkflowStatePayload;
+}> | TreeseedWorkflowResult<{
+    watch: boolean;
+    background: boolean;
+    command: string;
+    args: string[];
+    cwd: string;
+    pid: null;
+    exitCode: number;
+    runtime: {
+        mode: string;
+        apiBaseUrl: string;
+        webUrl: string;
     };
-} | {
-    ok: boolean;
-    operation: "dev";
-    payload: {
-        watch: boolean;
-        background: boolean;
-        command: string;
-        args: string[];
-        cwd: string;
-        pid: null;
-        exitCode: number;
+    readiness: {
+        ready: boolean;
+        blockers: string[];
+        warnings: string[];
     };
-}>;
-export declare function workflowSave(helpers: WorkflowOperationHelpers, input: TreeseedSaveInput): Promise<{
-    ok: boolean;
-    operation: string;
-    payload: {
+} & {
+    finalState: WorkflowStatePayload;
+}>>;
+export declare function workflowSave(helpers: WorkflowOperationHelpers, input: TreeseedSaveInput): Promise<TreeseedWorkflowResult<{
+    branch: string;
+    scope: string;
+    hotfix: boolean;
+    message: string;
+    commitSha: string;
+    commitCreated: boolean;
+    noChanges: boolean;
+    branchSync: {
+        remoteBranchExisted: boolean;
+        pulledRebase: boolean;
+        pushed: boolean;
+        createdRemoteBranch: boolean;
+        conflicts: boolean;
+    };
+    previewAction: Record<string, unknown>;
+    mergeConflict: null;
+} & {
+    finalState: WorkflowStatePayload;
+}>>;
+export declare function workflowClose(helpers: WorkflowOperationHelpers, input: TreeseedCloseInput): Promise<TreeseedWorkflowResult<{
+    branchName: string;
+    message: string;
+    autoSaved: boolean;
+    autoSaveResult: ({
         branch: string;
         scope: string;
         hotfix: boolean;
         message: string;
         commitSha: string;
-        previewRefresh: Record<string, unknown> | null;
-    };
-    nextSteps: TreeseedWorkflowNextStep[];
-}>;
-export declare function workflowClose(helpers: WorkflowOperationHelpers, input: TreeseedCloseInput): Promise<{
-    ok: boolean;
-    operation: string;
-    payload: {
-        branchName: string;
-        message: string;
-        deprecatedTag: {
-            tagName: string;
-            head: string;
-        };
-        previewCleanup: {
-            performed: boolean;
-            state: any;
-        } | {
-            performed: boolean;
+        commitCreated: boolean;
+        noChanges: boolean;
+        branchSync: {
+            remoteBranchExisted: boolean;
+            pulledRebase: boolean;
+            pushed: boolean;
+            createdRemoteBranch: boolean;
+            conflicts: boolean;
         };
-        remoteDeleted: boolean;
-        localDeleted: boolean;
+        previewAction: Record<string, unknown>;
+        mergeConflict: null;
+    } & {
+        finalState: WorkflowStatePayload;
+    }) | null;
+    deprecatedTag: {
+        tagName: string;
+        head: string;
     };
-    nextSteps: TreeseedWorkflowNextStep[];
-}>;
-export declare function workflowStage(helpers: WorkflowOperationHelpers, input: TreeseedStageInput): Promise<{
-    ok: boolean;
-    operation: string;
-    payload: {
-        branchName: string;
-        mergeTarget: string;
+    previewCleanup: {
+        performed: boolean;
+        state: any;
+    } | {
+        performed: boolean;
+    };
+    remoteDeleted: boolean;
+    localDeleted: boolean;
+    finalBranch: string;
+} & {
+    finalState: WorkflowStatePayload;
+}>>;
+export declare function workflowStage(helpers: WorkflowOperationHelpers, input: TreeseedStageInput): Promise<TreeseedWorkflowResult<{
+    branchName: string;
+    mergeTarget: string;
+    message: string;
+    autoSaved: boolean;
+    autoSaveResult: ({
+        branch: string;
+        scope: string;
+        hotfix: boolean;
         message: string;
-        deprecatedTag: {
-            tagName: string;
-            head: string;
-        };
-        stagingWait: {
-            status: string;
-            reason: string;
-            branch?: undefined;
-        } | {
-            status: string;
-            branch: string;
-            reason?: undefined;
-        };
-        previewCleanup: {
-            performed: boolean;
-            state: any;
-        } | {
-            performed: boolean;
+        commitSha: string;
+        commitCreated: boolean;
+        noChanges: boolean;
+        branchSync: {
+            remoteBranchExisted: boolean;
+            pulledRebase: boolean;
+            pushed: boolean;
+            createdRemoteBranch: boolean;
+            conflicts: boolean;
         };
-        remoteDeleted: boolean;
-        localDeleted: boolean;
+        previewAction: Record<string, unknown>;
+        mergeConflict: null;
+    } & {
+        finalState: WorkflowStatePayload;
+    }) | null;
+    deprecatedTag: {
+        tagName: string;
+        head: string;
     };
-    nextSteps: TreeseedWorkflowNextStep[];
-}>;
-export declare function workflowRelease(helpers: WorkflowOperationHelpers, input: TreeseedReleaseInput): Promise<{
-    ok: boolean;
-    operation: string;
-    payload: {
-        level: "patch" | "major" | "minor";
-        rootVersion: string;
-        releaseTag: string;
-        stagingBranch: string;
-        productionBranch: string;
-        touchedPackages: unknown[];
+    stagingWait: {
+        status: string;
+        reason: string;
+        branch?: undefined;
+    } | {
+        status: string;
+        branch: string;
+        reason?: undefined;
     };
-    nextSteps: TreeseedWorkflowNextStep[];
-}>;
+    previewCleanup: {
+        performed: boolean;
+        state: any;
+    } | {
+        performed: boolean;
+    };
+    remoteDeleted: boolean;
+    localDeleted: boolean;
+    finalBranch: string;
+} & {
+    finalState: WorkflowStatePayload;
+}>>;
+export declare function workflowRelease(helpers: WorkflowOperationHelpers, input: TreeseedReleaseInput): Promise<TreeseedWorkflowResult<{
+    level: "patch" | "major" | "minor";
+    rootVersion: string;
+    releaseTag: string;
+    releasedCommit: string;
+    stagingBranch: string;
+    productionBranch: string;
+    touchedPackages: unknown[];
+    finalBranch: string;
+    pushStatus: {
+        stagingPushed: boolean;
+        productionPushed: boolean;
+        tagPushed: boolean;
+    };
+} & {
+    finalState: WorkflowStatePayload;
+}>>;
 export declare function workflowDestroy(helpers: WorkflowOperationHelpers, input: TreeseedDestroyInput): Promise<{
     ok: boolean;
     operation: string;