@treeseed/sdk 0.4.12 → 0.5.0

package/dist/workflow.d.ts

@@ -1,12 +1,31 @@
 import { resolveTreeseedWorkflowState } from './workflow-state.ts';
 import { listTaskBranches } from './operations/services/git-workflow.ts';
 import { TreeseedWorkflowError, type TreeseedWorkflowErrorCode } from './workflow/operations.ts';
-export type TreeseedWorkflowOperationId = 'status' | 'config' | 'tasks' | 'switch' | 'dev' | 'save' | 'close' | 'stage' | 'release' | 'destroy' | 'export';
+export type TreeseedWorkflowOperationId = 'status' | 'config' | 'tasks' | 'switch' | 'dev' | 'save' | 'close' | 'stage' | 'release' | 'resume' | 'recover' | 'destroy' | 'export';
 export type TreeseedWorkflowNextStep = {
     operation: string;
     reason?: string;
     input?: Record<string, unknown>;
 };
+export type TreeseedWorkflowFact = {
+    label: string;
+    value: string | number | boolean | null;
+};
+export type TreeseedWorkflowErrorDetail = {
+    code: string;
+    message: string;
+    details?: Record<string, unknown> | null;
+};
+export type TreeseedWorkflowRecovery = {
+    resumable: boolean;
+    runId?: string | null;
+    command?: string | null;
+    message?: string | null;
+    recoverCommand?: string | null;
+    resumeCommand?: string | null;
+    lock?: Record<string, unknown> | null;
+};
+export type TreeseedWorkflowExecutionMode = 'execute' | 'plan';
 export type TreeseedWorkflowContext = {
     cwd?: string;
     env?: NodeJS.ProcessEnv;
@@ -14,12 +33,25 @@ export type TreeseedWorkflowContext = {
     prompt?: (message: string) => Promise<string> | string;
     confirm?: (message: string, expected: string) => Promise<boolean> | boolean;
     transport?: 'sdk' | 'cli' | 'api';
+    workflow?: {
+        resumeRunId?: string;
+    };
 };
 export type TreeseedWorkflowResult<TPayload = Record<string, unknown>> = {
+    schemaVersion: 1;
+    kind: 'treeseed.workflow.result';
+    command: TreeseedWorkflowOperationId;
+    executionMode: TreeseedWorkflowExecutionMode;
+    runId: string | null;
     ok: boolean;
     operation: TreeseedWorkflowOperationId;
+    summary?: string;
+    facts?: TreeseedWorkflowFact[];
     payload: TPayload;
+    result: TPayload;
     nextSteps?: TreeseedWorkflowNextStep[];
+    recovery?: TreeseedWorkflowRecovery | null;
+    errors?: TreeseedWorkflowErrorDetail[];
 };
 export type TreeseedTaskBranchMetadata = ReturnType<typeof listTaskBranches>[number] & {
     ageDays: number | null;
@@ -29,6 +61,33 @@ export type TreeseedTaskBranchMetadata = ReturnType<typeof listTaskBranches>[num
         url: string | null;
         lastDeploymentTimestamp: string | null;
     };
+    packages?: Array<{
+        name: string;
+        path: string;
+        local: boolean;
+        remote: boolean;
+        current: boolean;
+        head: string | null;
+        pointer: string | null;
+        aligned: boolean;
+    }>;
+};
+export type TreeseedWorkflowWorkstreamSummary = {
+    id: string;
+    title: string;
+    linkedDirectRefs: Array<{
+        model: 'objective' | 'question' | 'note';
+        id: string;
+    }>;
+    branch: string;
+    local: boolean;
+    remote: boolean;
+    current: boolean;
+    previewUrl: string | null;
+    lastSaveAt: string | null;
+    verificationResult: 'ready' | 'needs_attention' | 'unknown';
+    stagingCandidate: boolean;
+    archived: boolean;
 };
 export type TreeseedSaveInput = {
     message: string;
@@ -37,12 +96,16 @@ export type TreeseedSaveInput = {
     refreshPreview?: boolean;
     preview?: boolean;
     rebase?: boolean;
+    plan?: boolean;
+    dryRun?: boolean;
 };
 export type TreeseedCloseInput = {
     message: string;
     deletePreview?: boolean;
     deleteBranch?: boolean;
     autoSave?: boolean;
+    plan?: boolean;
+    dryRun?: boolean;
 };
 export type TreeseedStageInput = {
     message: string;
@@ -50,6 +113,8 @@ export type TreeseedStageInput = {
     deletePreview?: boolean;
     deleteBranch?: boolean;
     autoSave?: boolean;
+    plan?: boolean;
+    dryRun?: boolean;
 };
 export type TreeseedSwitchInput = {
     branch?: string;
@@ -57,6 +122,8 @@ export type TreeseedSwitchInput = {
     preview?: boolean;
     createIfMissing?: boolean;
     baseBranch?: string;
+    plan?: boolean;
+    dryRun?: boolean;
 };
 export type TreeseedConfigScope = 'all' | 'local' | 'staging' | 'prod';
 export type TreeseedConfigInput = {
@@ -75,6 +142,16 @@ export type TreeseedConfigInput = {
     printEnvOnly?: boolean;
     showSecrets?: boolean;
     rotateMachineKey?: boolean;
+    connectMarket?: boolean;
+    marketBaseUrl?: string;
+    marketTeamId?: string;
+    marketTeamSlug?: string;
+    marketProjectId?: string;
+    marketProjectSlug?: string;
+    marketProjectApiBaseUrl?: string;
+    marketAccessToken?: string;
+    rotateRunnerToken?: boolean;
+    installMissingTooling?: boolean;
     nonInteractive?: boolean;
 };
 export type TreeseedExportInput = {
@@ -82,12 +159,21 @@ export type TreeseedExportInput = {
 };
 export type TreeseedReleaseInput = {
     bump: 'major' | 'minor' | 'patch';
+    plan?: boolean;
+    dryRun?: boolean;
+};
+export type TreeseedResumeInput = {
+    runId: string;
+};
+export type TreeseedRecoverInput = {
+    runId?: string;
 };
 export type TreeseedDestroyInput = {
     target?: 'local' | 'staging' | 'prod';
     environment?: 'local' | 'staging' | 'prod';
     confirm?: boolean | string;
     dryRun?: boolean;
+    plan?: boolean;
     destroyRemote?: boolean;
     destroyLocal?: boolean;
     force?: boolean;
@@ -105,12 +191,14 @@ export declare class TreeseedWorkflowSdk {
     private readonly context;
     constructor(context?: TreeseedWorkflowContext);
     private helpers;
-    execute(operation: TreeseedWorkflowOperationId, input?: Record<string, unknown>): Promise<TreeseedWorkflowResult<import("./workflow-state.ts").TreeseedWorkflowState> | TreeseedWorkflowResult<Record<string, unknown>> | TreeseedWorkflowResult<{
+    execute(operation: TreeseedWorkflowOperationId, input?: Record<string, unknown>): Promise<TreeseedWorkflowResult<import("./workflow-state.ts").TreeseedWorkflowState> | TreeseedWorkflowResult<{
         tasks: TreeseedTaskBranchMetadata[];
-    }>>;
+        workstreams: TreeseedWorkflowWorkstreamSummary[];
+    }> | TreeseedWorkflowResult<Record<string, unknown>>>;
     status(): Promise<TreeseedWorkflowResult<ReturnType<typeof resolveTreeseedWorkflowState>>>;
     tasks(): Promise<TreeseedWorkflowResult<{
         tasks: TreeseedTaskBranchMetadata[];
+        workstreams: TreeseedWorkflowWorkstreamSummary[];
     }>>;
     config(input?: TreeseedConfigInput): Promise<TreeseedWorkflowResult>;
     switchTask(input: TreeseedSwitchInput): Promise<TreeseedWorkflowResult>;
@@ -119,6 +207,8 @@ export declare class TreeseedWorkflowSdk {
     close(input: TreeseedCloseInput): Promise<TreeseedWorkflowResult>;
     stage(input: TreeseedStageInput): Promise<TreeseedWorkflowResult>;
     release(input: TreeseedReleaseInput): Promise<TreeseedWorkflowResult>;
+    resume(input: TreeseedResumeInput): Promise<TreeseedWorkflowResult>;
+    recover(input?: TreeseedRecoverInput): Promise<TreeseedWorkflowResult>;
     destroy(input: TreeseedDestroyInput): Promise<TreeseedWorkflowResult>;
     export(input?: TreeseedExportInput): Promise<TreeseedWorkflowResult>;
 }

package/dist/workflow.js

@@ -6,7 +6,9 @@ import {
   workflowDestroy,
   workflowDev,
   workflowExport,
+  workflowRecover,
   workflowRelease,
+  workflowResume,
   workflowSave,
   workflowStage,
   workflowStatus,
@@ -56,6 +58,10 @@ class TreeseedWorkflowSdk {
         return this.stage(input);
       case "release":
         return this.release(input);
+      case "resume":
+        return this.resume(input);
+      case "recover":
+        return this.recover(input);
       case "destroy":
         return this.destroy(input);
       case "export":
@@ -91,6 +97,12 @@ class TreeseedWorkflowSdk {
   async release(input) {
     return workflowRelease(this.helpers(), input);
   }
+  async resume(input) {
+    return workflowResume(this.helpers(), input);
+  }
+  async recover(input = {}) {
+    return workflowRecover(this.helpers(), input);
+  }
   async destroy(input) {
     return workflowDestroy(this.helpers(), input);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.4.12",
+  "version": "0.5.0",
   "description": "Shared Treeseed SDK for content-backed and D1-backed object models.",
   "license": "AGPL-3.0-only",
   "repository": {

package/templates/github/deploy.workflow.yml

@@ -98,7 +98,7 @@ jobs:
               while IFS= read -r path; do
                 [[ -z "${path}" ]] && continue
                 case "${path}" in
-                  src/content/*|content/*|books/*|docs/*|public/books/*|migrations/*)
+                  src/content/*|content/*|books/*|docs/*|migrations/*)
                     content_changed="true"
                     ;;
                   *)
@@ -287,6 +287,7 @@ __WORKING_DIRECTORY_BLOCK__
       TREESEED_RAILWAY_PROJECT_ID: ${{ vars.TREESEED_RAILWAY_PROJECT_ID }}
       TREESEED_RAILWAY_ENVIRONMENT_ID: ${{ vars.TREESEED_RAILWAY_ENVIRONMENT_ID }}
       TREESEED_RAILWAY_WORKER_SERVICE_ID: ${{ vars.TREESEED_RAILWAY_WORKER_SERVICE_ID }}
+      TREESEED_CONTENT_SERVING_MODE: published_runtime
       TREESEED_WORKFLOW_ACTION: deploy_code
       TREESEED_WORKFLOW_ENVIRONMENT: ${{ needs.classify.outputs.scope }}
       TREESEED_WORKFLOW_PROJECT: ${{ inputs.project_id || vars.TREESEED_PROJECT_ID }}
@@ -294,6 +295,15 @@ __WORKING_DIRECTORY_BLOCK__
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+        with:
+          submodules: false
+          sparse-checkout: |
+            /*
+            !/src/content/
+            !/src/content/**
+            !/public/books/
+            !/public/books/**
+          sparse-checkout-cone-mode: false
 
       - name: Setup Node
         uses: actions/setup-node@v4

package/dist/scripts/sync-dev-vars.js

@@ -1,6 +0,0 @@
-import { applyTreeseedEnvironmentToProcess, writeTreeseedLocalEnvironmentFiles } from '../operations/services/config-runtime.js';
-const tenantRoot = process.cwd();
-applyTreeseedEnvironmentToProcess({ tenantRoot, scope: 'local', override: true });
-const result = writeTreeseedLocalEnvironmentFiles(tenantRoot);
-console.log(`Wrote ${result.envLocalPath}`);
-console.log(`Wrote ${result.devVarsPath}`);

package/dist/scripts/workspace-close.js

@@ -1,24 +0,0 @@
-#!/usr/bin/env node
-import { applyTreeseedEnvironmentToProcess } from '../operations/services/config-runtime.js';
-import { cleanupDestroyedState, createBranchPreviewDeployTarget, destroyCloudflareResources, loadDeployState, printDestroySummary, validateDestroyPrerequisites, } from '../operations/services/deploy.js';
-import { assertFeatureBranch, deleteLocalBranch, deleteRemoteBranch, mergeCurrentBranchIntoStaging, } from '../operations/services/git-workflow.js';
-import { loadCliDeployConfig } from '../operations/services/runtime-tools.js';
-import { runWorkspaceSavePreflight } from '../operations/services/save-deploy-preflight.js';
-const tenantRoot = process.cwd();
-const featureBranch = assertFeatureBranch(tenantRoot);
-const previewTarget = createBranchPreviewDeployTarget(featureBranch);
-const deployConfig = loadCliDeployConfig(tenantRoot);
-const previewState = loadDeployState(tenantRoot, deployConfig, { target: previewTarget });
-runWorkspaceSavePreflight({ cwd: tenantRoot });
-const repoDir = mergeCurrentBranchIntoStaging(tenantRoot, featureBranch);
-if (previewState.readiness?.initialized) {
-    applyTreeseedEnvironmentToProcess({ tenantRoot, scope: 'staging', override: true });
-    validateDestroyPrerequisites(tenantRoot, { requireRemote: true });
-    const result = destroyCloudflareResources(tenantRoot, { target: previewTarget });
-    printDestroySummary(result);
-}
-cleanupDestroyedState(tenantRoot, { target: previewTarget });
-deleteRemoteBranch(repoDir, featureBranch);
-deleteLocalBranch(repoDir, featureBranch);
-console.log('Treeseed close completed successfully.');
-console.log(`Merged ${featureBranch} into staging and removed branch artifacts.`);

package/dist/scripts/workspace-release.js

@@ -1,42 +0,0 @@
-#!/usr/bin/env node
-import { readFileSync, writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { applyTreeseedEnvironmentToProcess } from '../operations/services/config-runtime.js';
-import { PRODUCTION_BRANCH, STAGING_BRANCH, mergeStagingIntoMain, prepareReleaseBranches, pushBranch } from '../operations/services/git-workflow.js';
-import { incrementVersion, planWorkspaceReleaseBump, applyWorkspaceVersionChanges, repoRoot } from '../operations/services/workspace-save.js';
-import { run, workspaceRoot } from '../operations/services/workspace-tools.js';
-import { runWorkspaceSavePreflight } from '../operations/services/save-deploy-preflight.js';
-function parseArgs(argv) {
-    const flags = new Set(argv);
-    const selected = ['major', 'minor', 'patch'].filter((level) => flags.has(`--${level}`));
-    if (selected.length !== 1) {
-        throw new Error('Treeseed release requires exactly one version bump flag: --major, --minor, or --patch.');
-    }
-    return { level: selected[0] };
-}
-function bumpRootPackageJson(root, level) {
-    const packageJsonPath = resolve(root, 'package.json');
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-    packageJson.version = incrementVersion(packageJson.version, level);
-    writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8');
-    return packageJson.version;
-}
-const { level } = parseArgs(process.argv.slice(2));
-const root = workspaceRoot();
-const gitRoot = repoRoot(root);
-prepareReleaseBranches(root);
-applyTreeseedEnvironmentToProcess({ tenantRoot: root, scope: 'staging', override: true });
-runWorkspaceSavePreflight({ cwd: root });
-const plan = planWorkspaceReleaseBump(level, root);
-applyWorkspaceVersionChanges(plan);
-const rootVersion = bumpRootPackageJson(root, level);
-run('git', ['checkout', STAGING_BRANCH], { cwd: gitRoot });
-run('git', ['add', '-A'], { cwd: gitRoot });
-run('git', ['commit', '-m', `release: ${level} bump`], { cwd: gitRoot });
-pushBranch(gitRoot, STAGING_BRANCH);
-mergeStagingIntoMain(root);
-console.log('Treeseed release completed successfully.');
-console.log(`Staging branch: ${STAGING_BRANCH}`);
-console.log(`Production branch: ${PRODUCTION_BRANCH}`);
-console.log(`Release level: ${level}`);
-console.log(`Root version: ${rootVersion}`);

package/dist/scripts/workspace-start.js

@@ -1,71 +0,0 @@
-#!/usr/bin/env node
-import { spawnSync } from 'node:child_process';
-import { applyTreeseedEnvironmentToProcess, assertTreeseedCommandEnvironment } from '../operations/services/config-runtime.js';
-import { createBranchPreviewDeployTarget, deployTargetLabel, ensureGeneratedWranglerConfig, finalizeDeploymentState, printDeploySummary, provisionCloudflareResources, runRemoteD1Migrations, syncCloudflareSecrets, validateDeployPrerequisites, } from '../operations/services/deploy.js';
-import { createFeatureBranchFromStaging, pushBranch } from '../operations/services/git-workflow.js';
-import { packageScriptPath, resolveWranglerBin } from '../operations/services/runtime-tools.js';
-function parseArgs(argv) {
-    const parsed = {
-        branchName: null,
-        preview: false,
-    };
-    for (const current of argv) {
-        if (current === '--preview') {
-            parsed.preview = true;
-            continue;
-        }
-        if (!parsed.branchName) {
-            parsed.branchName = current;
-            continue;
-        }
-        throw new Error(`Unknown start argument: ${current}`);
-    }
-    if (!parsed.branchName) {
-        throw new Error('Usage: treeseed start <branch-name> [--preview]');
-    }
-    return parsed;
-}
-function runNodeScript(scriptPath, scriptArgs = [], cwd) {
-    const result = spawnSync(process.execPath, [scriptPath, ...scriptArgs], {
-        stdio: 'inherit',
-        cwd,
-        env: { ...process.env },
-    });
-    if (result.status !== 0) {
-        process.exit(result.status ?? 1);
-    }
-}
-function runWranglerDeploy(configPath, cwd) {
-    const result = spawnSync(process.execPath, [resolveWranglerBin(), 'deploy', '--config', configPath], {
-        stdio: 'inherit',
-        cwd,
-        env: { ...process.env },
-    });
-    if (result.status !== 0) {
-        process.exit(result.status ?? 1);
-    }
-}
-const options = parseArgs(process.argv.slice(2));
-const tenantRoot = process.cwd();
-const result = createFeatureBranchFromStaging(tenantRoot, options.branchName);
-pushBranch(result.repoDir, options.branchName, { setUpstream: true });
-if (!options.preview) {
-    console.log(`Created feature branch ${options.branchName} from staging.`);
-    console.log('Preview mode is disabled. Use local development for this branch.');
-    process.exit(0);
-}
-applyTreeseedEnvironmentToProcess({ tenantRoot, scope: 'staging', override: true });
-assertTreeseedCommandEnvironment({ tenantRoot, scope: 'staging', purpose: 'deploy' });
-validateDeployPrerequisites(tenantRoot, { requireRemote: true });
-const target = createBranchPreviewDeployTarget(options.branchName);
-const summary = provisionCloudflareResources(tenantRoot, { target });
-printDeploySummary(summary);
-const { wranglerPath } = ensureGeneratedWranglerConfig(tenantRoot, { target });
-syncCloudflareSecrets(tenantRoot, { target });
-runRemoteD1Migrations(tenantRoot, { target });
-runNodeScript(packageScriptPath('tenant-build'), [], tenantRoot);
-runWranglerDeploy(wranglerPath, tenantRoot);
-const state = finalizeDeploymentState(tenantRoot, { target });
-console.log(`Treeseed start preview completed for ${options.branchName}.`);
-console.log(`Target: ${deployTargetLabel(target)}`);
-console.log(`Preview URL: ${state.lastDeployedUrl}`);