@treeseed/sdk 0.1.2 → 0.3.0

package/dist/workflow-state.d.ts

@@ -0,0 +1,56 @@
+import type { TreeseedWorkflowNextStep } from './workflow.ts';
+export type TreeseedBranchRole = 'feature' | 'staging' | 'main' | 'detached' | 'none';
+export type TreeseedWorkflowRecommendation = TreeseedWorkflowNextStep;
+export type TreeseedWorkflowState = {
+    cwd: string;
+    workspaceRoot: boolean;
+    tenantRoot: boolean;
+    deployConfigPresent: boolean;
+    repoRoot: string | null;
+    branchName: string | null;
+    branchRole: TreeseedBranchRole;
+    environment: 'local' | 'staging' | 'prod' | 'none';
+    dirtyWorktree: boolean;
+    preview: {
+        enabled: boolean;
+        url: string | null;
+        lastDeploymentTimestamp: string | null;
+    };
+    persistentEnvironments: Record<string, {
+        initialized: boolean;
+        lastValidatedAt: string | null;
+        lastDeploymentTimestamp: string | null;
+        lastDeployedUrl: string | null;
+    }>;
+    auth: {
+        gh: boolean;
+        wrangler: boolean;
+        railway: boolean;
+        copilot: boolean;
+        remoteApi: boolean;
+    };
+    managedServices: Record<string, {
+        enabled: boolean;
+        initialized: boolean;
+        lastDeploymentTimestamp: string | null;
+        lastDeployedUrl: string | null;
+        provider: string | null;
+    }>;
+    files: {
+        treeseedConfig: boolean;
+        machineConfig: boolean;
+        machineKey: boolean;
+        envLocal: boolean;
+        devVars: boolean;
+    };
+    releaseReady: boolean;
+    rollbackCandidates: Array<{
+        scope: 'staging' | 'prod';
+        commit: string | null;
+        timestamp: string | null;
+        url: string | null;
+    }>;
+    recommendations: TreeseedWorkflowRecommendation[];
+};
+export declare function resolveTreeseedWorkflowState(cwd: string): TreeseedWorkflowState;
+export declare function recommendTreeseedNextSteps(state: TreeseedWorkflowState): TreeseedWorkflowRecommendation[];

package/dist/workflow-state.js

@@ -0,0 +1,195 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { getTreeseedMachineConfigPaths, resolveTreeseedRemoteSession } from "./operations/services/config-runtime.js";
+import {
+  createBranchPreviewDeployTarget,
+  createPersistentDeployTarget,
+  loadDeployState
+} from "./operations/services/deploy.js";
+import { PRODUCTION_BRANCH, STAGING_BRANCH } from "./operations/services/git-workflow.js";
+import { loadCliDeployConfig } from "./operations/services/runtime-tools.js";
+import { collectCliPreflight } from "./operations/services/workspace-preflight.js";
+import { currentBranch, gitStatusPorcelain, repoRoot } from "./operations/services/workspace-save.js";
+import { isWorkspaceRoot } from "./operations/services/workspace-tools.js";
+function safeResolveRepoRoot(cwd) {
+  try {
+    return repoRoot(cwd);
+  } catch {
+    return null;
+  }
+}
+function branchRoleFor(branchName) {
+  if (!branchName) return "none";
+  if (branchName === STAGING_BRANCH) return "staging";
+  if (branchName === PRODUCTION_BRANCH) return "main";
+  return "feature";
+}
+function environmentForBranchRole(branchRole) {
+  if (branchRole === "staging") return "staging";
+  if (branchRole === "main") return "prod";
+  if (branchRole === "feature") return "local";
+  return "none";
+}
+function emptyPersistentEnvironments() {
+  return {
+    local: { initialized: false, lastValidatedAt: null, lastDeploymentTimestamp: null, lastDeployedUrl: null },
+    staging: { initialized: false, lastValidatedAt: null, lastDeploymentTimestamp: null, lastDeployedUrl: null },
+    prod: { initialized: false, lastValidatedAt: null, lastDeploymentTimestamp: null, lastDeployedUrl: null }
+  };
+}
+function resolveTreeseedWorkflowState(cwd) {
+  const workspaceRoot = isWorkspaceRoot(cwd);
+  const treeseedConfigPath = resolve(cwd, "treeseed.site.yaml");
+  const tenantRoot = existsSync(treeseedConfigPath);
+  const root = safeResolveRepoRoot(cwd);
+  const branchName = root ? currentBranch(root) || null : null;
+  const branchRole = branchRoleFor(branchName);
+  const dirtyWorktree = root ? gitStatusPorcelain(root).length > 0 : false;
+  const preflight = collectCliPreflight({ cwd, requireAuth: false });
+  const { configPath, keyPath } = getTreeseedMachineConfigPaths(cwd);
+  const state = {
+    cwd,
+    workspaceRoot,
+    tenantRoot,
+    deployConfigPresent: tenantRoot,
+    repoRoot: root,
+    branchName,
+    branchRole,
+    environment: environmentForBranchRole(branchRole),
+    dirtyWorktree,
+    preview: {
+      enabled: false,
+      url: null,
+      lastDeploymentTimestamp: null
+    },
+    persistentEnvironments: emptyPersistentEnvironments(),
+    auth: {
+      gh: preflight.checks.auth.gh?.authenticated === true,
+      wrangler: preflight.checks.auth.wrangler?.authenticated === true,
+      railway: preflight.checks.auth.railway?.authenticated === true,
+      copilot: preflight.checks.auth.copilot?.configured === true,
+      remoteApi: Boolean(resolveTreeseedRemoteSession(cwd))
+    },
+    managedServices: {
+      api: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null },
+      agents: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null },
+      manager: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null },
+      worker: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null },
+      workdayStart: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null },
+      workdayReport: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null }
+    },
+    files: {
+      treeseedConfig: tenantRoot,
+      machineConfig: existsSync(configPath),
+      machineKey: existsSync(keyPath),
+      envLocal: existsSync(resolve(cwd, ".env.local")),
+      devVars: existsSync(resolve(cwd, ".dev.vars"))
+    },
+    releaseReady: branchRole === "staging" && !dirtyWorktree,
+    rollbackCandidates: [],
+    recommendations: []
+  };
+  if (tenantRoot) {
+    try {
+      const deployConfig = loadCliDeployConfig(cwd);
+      for (const scope of ["local", "staging", "prod"]) {
+        const deployState = loadDeployState(cwd, deployConfig, { target: createPersistentDeployTarget(scope) });
+        state.persistentEnvironments[scope] = {
+          initialized: deployState.readiness?.initialized === true || scope === "local",
+          lastValidatedAt: deployState.readiness?.lastValidatedAt ?? deployState.readiness?.initializedAt ?? null,
+          lastDeploymentTimestamp: deployState.lastDeploymentTimestamp ?? null,
+          lastDeployedUrl: deployState.lastDeployedUrl ?? null
+        };
+        if (scope !== "local") {
+          const history = Array.isArray(deployState.deploymentHistory) ? deployState.deploymentHistory ?? [] : [];
+          const latestHistory = history.at(-1) ?? null;
+          state.rollbackCandidates.push({
+            scope,
+            commit: typeof latestHistory?.commit === "string" ? latestHistory.commit : deployState.lastDeployedCommit ?? null,
+            timestamp: typeof latestHistory?.timestamp === "string" ? latestHistory.timestamp : deployState.lastDeploymentTimestamp ?? null,
+            url: typeof latestHistory?.url === "string" ? latestHistory.url : deployState.lastDeployedUrl ?? null
+          });
+        }
+        for (const serviceKey of ["api", "agents", "manager", "worker", "workdayStart", "workdayReport"]) {
+          const service = deployState.services?.[serviceKey];
+          if (!service) continue;
+          state.managedServices[serviceKey] = {
+            enabled: service.enabled === true,
+            initialized: service.initialized === true,
+            lastDeploymentTimestamp: service.lastDeploymentTimestamp ?? null,
+            lastDeployedUrl: service.lastDeployedUrl ?? service.publicBaseUrl ?? null,
+            provider: service.provider ?? null
+          };
+        }
+      }
+      if (branchRole === "feature" && branchName) {
+        const previewState = loadDeployState(cwd, deployConfig, { target: createBranchPreviewDeployTarget(branchName) });
+        state.preview = {
+          enabled: previewState.previewEnabled === true || previewState.readiness?.initialized === true,
+          url: previewState.lastDeployedUrl ?? null,
+          lastDeploymentTimestamp: previewState.lastDeploymentTimestamp ?? null
+        };
+      }
+    } catch {
+    }
+  }
+  state.recommendations = recommendTreeseedNextSteps(state);
+  return state;
+}
+function recommendTreeseedNextSteps(state) {
+  const recommendations = [];
+  if (!state.workspaceRoot) {
+    return [{ operation: "status", reason: "Run this from inside a Treeseed workspace so the project root can be resolved." }];
+  }
+  if (!state.deployConfigPresent) {
+    return [{ operation: "init", reason: "Create a new Treeseed tenant before configuring or releasing anything.", input: { directory: "<directory>" } }];
+  }
+  if (!state.files.machineConfig) {
+    recommendations.push({ operation: "status", reason: "Validate tooling, auth, and repository readiness first." });
+    recommendations.push({ operation: "config", reason: "Bootstrap the local machine config and local environment files." });
+    return recommendations;
+  }
+  if (state.branchRole === "feature") {
+    if (state.dirtyWorktree) {
+      recommendations.push({ operation: "save", reason: "Persist, verify, and push the current task branch before staging or closing it.", input: { message: "describe your change" } });
+    } else {
+      recommendations.push({ operation: "stage", reason: "Merge this task branch into staging and clean up branch artifacts.", input: { message: "describe the resolution" } });
+    }
+    if (state.preview.enabled && state.branchName) {
+      recommendations.push({ operation: "save", reason: "Save refreshes the branch preview deployment when one is enabled.", input: { message: "describe your change" } });
+    } else {
+      recommendations.push({ operation: "dev", reason: "Use the local environment for iterative work on this feature branch." });
+    }
+    recommendations.push({ operation: "close", reason: "Archive this task without merging if it should be abandoned.", input: { message: "reason" } });
+    return recommendations.slice(0, 3);
+  }
+  if (state.branchRole === "staging") {
+    if (!state.persistentEnvironments.staging.initialized) {
+      recommendations.push({ operation: "config", reason: "Initialize the staging environment before releasing.", input: { environment: ["staging"] } });
+    } else {
+      recommendations.push({ operation: "release", reason: "Promote staging into main when the integration branch is ready for production.", input: { bump: "patch" } });
+      if (state.managedServices.api.enabled || state.managedServices.agents.enabled) {
+        recommendations.push({ operation: "auth:login", reason: "Keep the local runtime authenticated to the remote API used by managed services." });
+      }
+    }
+    return recommendations.slice(0, 3);
+  }
+  if (state.branchRole === "main") {
+    if (state.dirtyWorktree) {
+      recommendations.push({ operation: "save", reason: "Only explicit hotfix saves are allowed on main.", input: { message: "describe the hotfix", hotfix: true } });
+    } else if (!state.persistentEnvironments.prod.initialized) {
+      recommendations.push({ operation: "config", reason: "Initialize production before a release requires it.", input: { environment: ["prod"] } });
+    } else {
+      recommendations.push({ operation: "status", reason: "Inspect production state and release readiness." });
+      recommendations.push({ operation: "rollback", reason: "Roll back production to the previous recorded deployment if needed.", input: { environment: "prod" } });
+    }
+    return recommendations.slice(0, 3);
+  }
+  recommendations.push({ operation: "dev", reason: "Start the local Treeseed development environment." });
+  recommendations.push({ operation: "switch", reason: "Create a task branch from the latest staging commit.", input: { branch: "feature/my-change" } });
+  return recommendations.slice(0, 3);
+}
+export {
+  recommendTreeseedNextSteps,
+  resolveTreeseedWorkflowState
+};

package/dist/workflow-support.d.ts

@@ -0,0 +1,9 @@
+export { applyTreeseedEnvironmentToProcess, assertTreeseedCommandEnvironment, checkTreeseedProviderConnections, clearTreeseedRemoteSession, createDefaultTreeseedMachineConfig, ensureTreeseedGitignoreEntries, formatTreeseedConfigEnvironmentReport, formatTreeseedProviderConnectionReport, getTreeseedMachineConfigPaths, loadTreeseedMachineConfig, resolveTreeseedMachineEnvironmentValues, resolveTreeseedRemoteConfig, resolveTreeseedRemoteSession, rotateTreeseedMachineKey, runTreeseedConfigWizard, setTreeseedRemoteSession, writeTreeseedLocalEnvironmentFiles, writeTreeseedMachineConfig, } from './operations/services/config-runtime.ts';
+export { assertDeploymentInitialized, cleanupDestroyedState, createBranchPreviewDeployTarget, createPersistentDeployTarget, deployTargetLabel, destroyCloudflareResources, ensureGeneratedWranglerConfig, finalizeDeploymentState, loadDeployState, printDeploySummary, printDestroySummary, provisionCloudflareResources, runRemoteD1Migrations, syncCloudflareSecrets, validateDeployPrerequisites, validateDestroyPrerequisites, } from './operations/services/deploy.ts';
+export { assertCleanWorktree, assertFeatureBranch, branchExists, checkoutBranch, createDeprecatedTaskTag, createFeatureBranchFromStaging, currentManagedBranch, deleteLocalBranch, deleteRemoteBranch, ensureLocalBranchTracking, gitWorkflowRoot, listTaskBranches, mergeCurrentBranchIntoStaging, mergeStagingIntoMain, prepareReleaseBranches, PRODUCTION_BRANCH, pushBranch, remoteBranchExists, STAGING_BRANCH, syncBranchWithOrigin, waitForStagingAutomation, } from './operations/services/git-workflow.ts';
+export { loadCliDeployConfig, packageScriptPath, resolveWranglerBin, } from './operations/services/runtime-tools.ts';
+export { configuredRailwayServices, deployRailwayService, validateRailwayDeployPrerequisites, } from './operations/services/railway-deploy.ts';
+export { runTenantDeployPreflight, runWorkspaceSavePreflight, } from './operations/services/save-deploy-preflight.ts';
+export { collectCliPreflight } from './operations/services/workspace-preflight.ts';
+export { applyWorkspaceVersionChanges, collectMergeConflictReport, currentBranch, formatMergeConflictReport, gitStatusPorcelain, hasMeaningfulChanges, incrementVersion, originRemoteUrl, planWorkspaceReleaseBump, repoRoot, } from './operations/services/workspace-save.ts';
+export { findNearestTreeseedRoot, findNearestTreeseedWorkspaceRoot, isWorkspaceRoot, run, workspaceRoot, } from './operations/services/workspace-tools.ts';

package/dist/workflow-support.js

@@ -0,0 +1,176 @@
+import {
+  applyTreeseedEnvironmentToProcess,
+  assertTreeseedCommandEnvironment,
+  checkTreeseedProviderConnections,
+  clearTreeseedRemoteSession,
+  createDefaultTreeseedMachineConfig,
+  ensureTreeseedGitignoreEntries,
+  formatTreeseedConfigEnvironmentReport,
+  formatTreeseedProviderConnectionReport,
+  getTreeseedMachineConfigPaths,
+  loadTreeseedMachineConfig,
+  resolveTreeseedMachineEnvironmentValues,
+  resolveTreeseedRemoteConfig,
+  resolveTreeseedRemoteSession,
+  rotateTreeseedMachineKey,
+  runTreeseedConfigWizard,
+  setTreeseedRemoteSession,
+  writeTreeseedLocalEnvironmentFiles,
+  writeTreeseedMachineConfig
+} from "./operations/services/config-runtime.js";
+import {
+  assertDeploymentInitialized,
+  cleanupDestroyedState,
+  createBranchPreviewDeployTarget,
+  createPersistentDeployTarget,
+  deployTargetLabel,
+  destroyCloudflareResources,
+  ensureGeneratedWranglerConfig,
+  finalizeDeploymentState,
+  loadDeployState,
+  printDeploySummary,
+  printDestroySummary,
+  provisionCloudflareResources,
+  runRemoteD1Migrations,
+  syncCloudflareSecrets,
+  validateDeployPrerequisites,
+  validateDestroyPrerequisites
+} from "./operations/services/deploy.js";
+import {
+  assertCleanWorktree,
+  assertFeatureBranch,
+  branchExists,
+  checkoutBranch,
+  createDeprecatedTaskTag,
+  createFeatureBranchFromStaging,
+  currentManagedBranch,
+  deleteLocalBranch,
+  deleteRemoteBranch,
+  ensureLocalBranchTracking,
+  gitWorkflowRoot,
+  listTaskBranches,
+  mergeCurrentBranchIntoStaging,
+  mergeStagingIntoMain,
+  prepareReleaseBranches,
+  PRODUCTION_BRANCH,
+  pushBranch,
+  remoteBranchExists,
+  STAGING_BRANCH,
+  syncBranchWithOrigin,
+  waitForStagingAutomation
+} from "./operations/services/git-workflow.js";
+import {
+  loadCliDeployConfig,
+  packageScriptPath,
+  resolveWranglerBin
+} from "./operations/services/runtime-tools.js";
+import {
+  configuredRailwayServices,
+  deployRailwayService,
+  validateRailwayDeployPrerequisites
+} from "./operations/services/railway-deploy.js";
+import {
+  runTenantDeployPreflight,
+  runWorkspaceSavePreflight
+} from "./operations/services/save-deploy-preflight.js";
+import { collectCliPreflight } from "./operations/services/workspace-preflight.js";
+import {
+  applyWorkspaceVersionChanges,
+  collectMergeConflictReport,
+  currentBranch,
+  formatMergeConflictReport,
+  gitStatusPorcelain,
+  hasMeaningfulChanges,
+  incrementVersion,
+  originRemoteUrl,
+  planWorkspaceReleaseBump,
+  repoRoot
+} from "./operations/services/workspace-save.js";
+import {
+  findNearestTreeseedRoot,
+  findNearestTreeseedWorkspaceRoot,
+  isWorkspaceRoot,
+  run,
+  workspaceRoot
+} from "./operations/services/workspace-tools.js";
+export {
+  PRODUCTION_BRANCH,
+  STAGING_BRANCH,
+  applyTreeseedEnvironmentToProcess,
+  applyWorkspaceVersionChanges,
+  assertCleanWorktree,
+  assertDeploymentInitialized,
+  assertFeatureBranch,
+  assertTreeseedCommandEnvironment,
+  branchExists,
+  checkTreeseedProviderConnections,
+  checkoutBranch,
+  cleanupDestroyedState,
+  clearTreeseedRemoteSession,
+  collectCliPreflight,
+  collectMergeConflictReport,
+  configuredRailwayServices,
+  createBranchPreviewDeployTarget,
+  createDefaultTreeseedMachineConfig,
+  createDeprecatedTaskTag,
+  createFeatureBranchFromStaging,
+  createPersistentDeployTarget,
+  currentBranch,
+  currentManagedBranch,
+  deleteLocalBranch,
+  deleteRemoteBranch,
+  deployRailwayService,
+  deployTargetLabel,
+  destroyCloudflareResources,
+  ensureGeneratedWranglerConfig,
+  ensureLocalBranchTracking,
+  ensureTreeseedGitignoreEntries,
+  finalizeDeploymentState,
+  findNearestTreeseedRoot,
+  findNearestTreeseedWorkspaceRoot,
+  formatMergeConflictReport,
+  formatTreeseedConfigEnvironmentReport,
+  formatTreeseedProviderConnectionReport,
+  getTreeseedMachineConfigPaths,
+  gitStatusPorcelain,
+  gitWorkflowRoot,
+  hasMeaningfulChanges,
+  incrementVersion,
+  isWorkspaceRoot,
+  listTaskBranches,
+  loadCliDeployConfig,
+  loadDeployState,
+  loadTreeseedMachineConfig,
+  mergeCurrentBranchIntoStaging,
+  mergeStagingIntoMain,
+  originRemoteUrl,
+  packageScriptPath,
+  planWorkspaceReleaseBump,
+  prepareReleaseBranches,
+  printDeploySummary,
+  printDestroySummary,
+  provisionCloudflareResources,
+  pushBranch,
+  remoteBranchExists,
+  repoRoot,
+  resolveTreeseedMachineEnvironmentValues,
+  resolveTreeseedRemoteConfig,
+  resolveTreeseedRemoteSession,
+  resolveWranglerBin,
+  rotateTreeseedMachineKey,
+  run,
+  runRemoteD1Migrations,
+  runTenantDeployPreflight,
+  runTreeseedConfigWizard,
+  runWorkspaceSavePreflight,
+  setTreeseedRemoteSession,
+  syncBranchWithOrigin,
+  syncCloudflareSecrets,
+  validateDeployPrerequisites,
+  validateDestroyPrerequisites,
+  validateRailwayDeployPrerequisites,
+  waitForStagingAutomation,
+  workspaceRoot,
+  writeTreeseedLocalEnvironmentFiles,
+  writeTreeseedMachineConfig
+};

package/dist/workflow.d.ts

@@ -0,0 +1,111 @@
+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 type TreeseedWorkflowNextStep = {
+    operation: string;
+    reason?: string;
+    input?: Record<string, unknown>;
+};
+export type TreeseedWorkflowContext = {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    write?: (output: string, stream?: 'stdout' | 'stderr') => void;
+    prompt?: (message: string) => Promise<string> | string;
+    confirm?: (message: string, expected: string) => Promise<boolean> | boolean;
+    transport?: 'sdk' | 'cli' | 'api';
+};
+export type TreeseedWorkflowResult<TPayload = Record<string, unknown>> = {
+    ok: boolean;
+    operation: TreeseedWorkflowOperationId;
+    payload: TPayload;
+    nextSteps?: TreeseedWorkflowNextStep[];
+};
+export type TreeseedTaskBranchMetadata = ReturnType<typeof listTaskBranches>[number] & {
+    ageDays: number | null;
+    dirtyCurrent: boolean;
+    preview: {
+        enabled: boolean;
+        url: string | null;
+        lastDeploymentTimestamp: string | null;
+    };
+};
+export type TreeseedSaveInput = {
+    message: string;
+    hotfix?: boolean;
+    verify?: boolean;
+    refreshPreview?: boolean;
+    rebase?: boolean;
+};
+export type TreeseedCloseInput = {
+    message: string;
+    deletePreview?: boolean;
+    deleteBranch?: boolean;
+};
+export type TreeseedStageInput = {
+    message: string;
+    waitForStaging?: boolean;
+    deletePreview?: boolean;
+    deleteBranch?: boolean;
+};
+export type TreeseedSwitchInput = {
+    branch?: string;
+    branchName?: string;
+    preview?: boolean;
+    createIfMissing?: boolean;
+    baseBranch?: string;
+};
+export type TreeseedConfigScope = 'all' | 'local' | 'staging' | 'prod';
+export type TreeseedConfigInput = {
+    target?: TreeseedConfigScope[] | TreeseedConfigScope;
+    environment?: TreeseedConfigScope[] | TreeseedConfigScope;
+    syncProviders?: 'none' | 'github' | 'cloudflare' | 'railway' | 'all';
+    sync?: 'none' | 'github' | 'cloudflare' | 'railway' | 'all';
+    repair?: boolean;
+    printEnv?: boolean;
+    printEnvOnly?: boolean;
+    showSecrets?: boolean;
+    rotateMachineKey?: boolean;
+    nonInteractive?: boolean;
+};
+export type TreeseedReleaseInput = {
+    bump: 'major' | 'minor' | 'patch';
+};
+export type TreeseedDestroyInput = {
+    target?: 'local' | 'staging' | 'prod';
+    environment?: 'local' | 'staging' | 'prod';
+    confirm?: boolean | string;
+    dryRun?: boolean;
+    destroyRemote?: boolean;
+    destroyLocal?: boolean;
+    force?: boolean;
+    removeBuildArtifacts?: boolean;
+};
+export type TreeseedWorkflowDevInput = {
+    watch?: boolean;
+    port?: number | string;
+    background?: boolean;
+    stdio?: 'inherit' | 'pipe';
+};
+export { TreeseedWorkflowError };
+export type { TreeseedWorkflowErrorCode };
+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<{
+        tasks: TreeseedTaskBranchMetadata[];
+    }>>;
+    status(): Promise<TreeseedWorkflowResult<ReturnType<typeof resolveTreeseedWorkflowState>>>;
+    tasks(): Promise<TreeseedWorkflowResult<{
+        tasks: TreeseedTaskBranchMetadata[];
+    }>>;
+    config(input?: TreeseedConfigInput): Promise<TreeseedWorkflowResult>;
+    switchTask(input: TreeseedSwitchInput): Promise<TreeseedWorkflowResult>;
+    dev(input?: TreeseedWorkflowDevInput): Promise<TreeseedWorkflowResult>;
+    save(input: TreeseedSaveInput): Promise<TreeseedWorkflowResult>;
+    close(input: TreeseedCloseInput): Promise<TreeseedWorkflowResult>;
+    stage(input: TreeseedStageInput): Promise<TreeseedWorkflowResult>;
+    release(input: TreeseedReleaseInput): Promise<TreeseedWorkflowResult>;
+    destroy(input: TreeseedDestroyInput): Promise<TreeseedWorkflowResult>;
+}

package/dist/workflow.js

@@ -0,0 +1,97 @@
+import {
+  TreeseedWorkflowError,
+  workflowClose,
+  workflowConfig,
+  workflowDestroy,
+  workflowDev,
+  workflowRelease,
+  workflowSave,
+  workflowStage,
+  workflowStatus,
+  workflowSwitch,
+  workflowTasks
+} from "./workflow/operations.js";
+function defaultWrite(output, stream = "stdout") {
+  if (!output) return;
+  (stream === "stderr" ? process.stderr : process.stdout).write(`${output}
+`);
+}
+class TreeseedWorkflowSdk {
+  constructor(context = {}) {
+    this.context = context;
+  }
+  context;
+  helpers() {
+    const context = {
+      transport: "sdk",
+      ...this.context
+    };
+    return {
+      context,
+      cwd: () => context.cwd ?? process.cwd(),
+      write: context.write ?? defaultWrite,
+      runStatus: async () => this.status(),
+      runTasks: async () => this.tasks()
+    };
+  }
+  async execute(operation, input = {}) {
+    switch (operation) {
+      case "status":
+        return this.status();
+      case "tasks":
+        return this.tasks();
+      case "config":
+        return this.config(input);
+      case "switch":
+        return this.switchTask(input);
+      case "dev":
+        return this.dev(input);
+      case "save":
+        return this.save(input);
+      case "close":
+        return this.close(input);
+      case "stage":
+        return this.stage(input);
+      case "release":
+        return this.release(input);
+      case "destroy":
+        return this.destroy(input);
+      default:
+        throw new Error(`Unsupported workflow operation "${operation}".`);
+    }
+  }
+  async status() {
+    return workflowStatus(this.helpers());
+  }
+  async tasks() {
+    return workflowTasks(this.helpers());
+  }
+  async config(input = {}) {
+    return workflowConfig(this.helpers(), input);
+  }
+  async switchTask(input) {
+    return workflowSwitch(this.helpers(), input);
+  }
+  async dev(input = {}) {
+    return workflowDev(this.helpers(), input);
+  }
+  async save(input) {
+    return workflowSave(this.helpers(), input);
+  }
+  async close(input) {
+    return workflowClose(this.helpers(), input);
+  }
+  async stage(input) {
+    return workflowStage(this.helpers(), input);
+  }
+  async release(input) {
+    return workflowRelease(this.helpers(), input);
+  }
+  async destroy(input) {
+    return workflowDestroy(this.helpers(), input);
+  }
+}
+export {
+  TreeseedWorkflowError,
+  TreeseedWorkflowSdk
+};