@treeseed/sdk 0.6.1 → 0.6.3

package/dist/operations/services/bootstrap-runner.d.ts

@@ -0,0 +1,33 @@
+export type TreeseedBootstrapExecution = 'parallel' | 'sequential';
+export type TreeseedBootstrapStream = 'stdout' | 'stderr';
+export type TreeseedBootstrapWriter = (line: string, stream?: TreeseedBootstrapStream) => void;
+export type TreeseedBootstrapTaskPrefix = {
+    scope: string;
+    system: string;
+    task: string;
+    stage: string;
+};
+export type TreeseedBootstrapDagNode<TResult = unknown> = {
+    id: string;
+    dependencies?: string[];
+    run: () => Promise<TResult> | TResult;
+};
+export declare function formatTreeseedBootstrapPrefix(prefix: TreeseedBootstrapTaskPrefix): string;
+export declare function formatTreeseedBootstrapLine(prefix: TreeseedBootstrapTaskPrefix, line: string): string;
+export declare function writeTreeseedBootstrapLine(write: TreeseedBootstrapWriter | undefined, prefix: TreeseedBootstrapTaskPrefix, line: string, stream?: TreeseedBootstrapStream): void;
+export declare function runTreeseedBootstrapDag<TResult = unknown>({ nodes, execution, }: {
+    nodes: Array<TreeseedBootstrapDagNode<TResult>>;
+    execution?: TreeseedBootstrapExecution;
+}): Promise<Map<string, TResult>>;
+export declare function sleep(milliseconds: number): Promise<void>;
+export declare function runPrefixedCommand(command: string, args: string[], { cwd, env, input, write, prefix, }: {
+    cwd: string;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    input?: string;
+    write?: TreeseedBootstrapWriter;
+    prefix: TreeseedBootstrapTaskPrefix;
+}): Promise<{
+    status: number | null;
+    stdout: string;
+    stderr: string;
+}>;

package/dist/operations/services/bootstrap-runner.js

@@ -0,0 +1,136 @@
+import { spawn } from "node:child_process";
+function formatTreeseedBootstrapPrefix(prefix) {
+  return `[${prefix.scope}][${prefix.system}][${prefix.task}][${prefix.stage}]`;
+}
+function formatTreeseedBootstrapLine(prefix, line) {
+  return `${formatTreeseedBootstrapPrefix(prefix)} ${line}`;
+}
+function writeTreeseedBootstrapLine(write, prefix, line, stream = "stdout") {
+  const formatted = formatTreeseedBootstrapLine(prefix, line);
+  if (write) {
+    write(formatted, stream);
+    return;
+  }
+  (stream === "stderr" ? process.stderr : process.stdout).write(`${formatted}
+`);
+}
+function dependencyLevels(nodes) {
+  const byId = new Map(nodes.map((node) => [node.id, node]));
+  const remaining = new Map(byId);
+  const completed = /* @__PURE__ */ new Set();
+  const levels = [];
+  for (const node of nodes) {
+    for (const dependency of node.dependencies ?? []) {
+      if (!byId.has(dependency)) {
+        throw new Error(`Bootstrap DAG node "${node.id}" depends on missing node "${dependency}".`);
+      }
+    }
+  }
+  while (remaining.size > 0) {
+    const ready = [...remaining.values()].filter(
+      (node) => (node.dependencies ?? []).every((dependency) => completed.has(dependency))
+    );
+    if (ready.length === 0) {
+      throw new Error("Bootstrap DAG contains a dependency cycle.");
+    }
+    for (const node of ready) {
+      remaining.delete(node.id);
+      completed.add(node.id);
+    }
+    levels.push(ready);
+  }
+  return levels;
+}
+async function runTreeseedBootstrapDag({
+  nodes,
+  execution = "parallel"
+}) {
+  const results = /* @__PURE__ */ new Map();
+  for (const level of dependencyLevels(nodes)) {
+    if (execution === "sequential") {
+      for (const node of level) {
+        results.set(node.id, await Promise.resolve(node.run()));
+      }
+      continue;
+    }
+    await Promise.all(level.map(async (node) => {
+      results.set(node.id, await Promise.resolve(node.run()));
+    }));
+  }
+  return results;
+}
+async function sleep(milliseconds) {
+  if (!Number.isFinite(milliseconds) || milliseconds <= 0) {
+    return;
+  }
+  await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+async function runPrefixedCommand(command, args, {
+  cwd,
+  env = process.env,
+  input,
+  write,
+  prefix
+}) {
+  return await new Promise((resolvePromise, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env: { ...process.env, ...env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let stdoutBuffer = "";
+    let stderrBuffer = "";
+    const flush = (stream, force = false) => {
+      let buffer = stream === "stdout" ? stdoutBuffer : stderrBuffer;
+      let newlineIndex = buffer.search(/\r?\n/u);
+      while (newlineIndex >= 0) {
+        const line = buffer.slice(0, newlineIndex).replace(/\r$/u, "");
+        writeTreeseedBootstrapLine(write, prefix, line, stream);
+        buffer = buffer.slice(buffer[newlineIndex] === "\r" && buffer[newlineIndex + 1] === "\n" ? newlineIndex + 2 : newlineIndex + 1);
+        newlineIndex = buffer.search(/\r?\n/u);
+      }
+      if (force && buffer.length > 0) {
+        writeTreeseedBootstrapLine(write, prefix, buffer.replace(/\r$/u, ""), stream);
+        buffer = "";
+      }
+      if (stream === "stdout") {
+        stdoutBuffer = buffer;
+      } else {
+        stderrBuffer = buffer;
+      }
+    };
+    child.stdout.on("data", (chunk) => {
+      const text = String(chunk);
+      stdout += text;
+      stdoutBuffer += text;
+      flush("stdout");
+    });
+    child.stderr.on("data", (chunk) => {
+      const text = String(chunk);
+      stderr += text;
+      stderrBuffer += text;
+      flush("stderr");
+    });
+    child.on("error", reject);
+    child.on("close", (status) => {
+      flush("stdout", true);
+      flush("stderr", true);
+      resolvePromise({ status, stdout, stderr });
+    });
+    if (input !== void 0) {
+      child.stdin.end(input);
+    } else {
+      child.stdin.end();
+    }
+  });
+}
+export {
+  formatTreeseedBootstrapLine,
+  formatTreeseedBootstrapPrefix,
+  runPrefixedCommand,
+  runTreeseedBootstrapDag,
+  sleep,
+  writeTreeseedBootstrapLine
+};

package/dist/operations/services/config-runtime.d.ts

@@ -1,5 +1,6 @@
 import type { RemoteTreeseedConfig } from '../../remote.ts';
 import { TREESEED_ENVIRONMENT_SCOPES, type TreeseedEnvironmentValidation, validateTreeseedEnvironmentValues } from '../../platform/environment.ts';
+import { resolveTreeseedBootstrapSelection, type TreeseedBootstrapSystem } from '../../reconcile/index.ts';
 import { type TreeseedKeyAgentStatus } from './key-agent.ts';
 export { TREESEED_MACHINE_KEY_PASSPHRASE_ENV, TreeseedKeyAgentError } from './key-agent.ts';
 export declare const DEFAULT_TREESEED_API_BASE_URL = "https://api.treeseed.ai";
@@ -312,14 +313,26 @@ export declare function checkTreeseedProviderConnections({ tenantRoot, scope, en
     issues: any[];
 }>;
 export declare function formatTreeseedProviderConnectionReport(report: any): string;
-export declare function syncTreeseedGitHubEnvironment({ tenantRoot, scope, dryRun }?: {
-    scope?: string | undefined;
-    dryRun?: boolean | undefined;
+export declare function syncTreeseedGitHubEnvironment({ tenantRoot, scope, dryRun, repository: repositoryInput, execution, concurrency, onProgress, }: {
+    tenantRoot: string;
+    scope?: TreeseedConfigScope;
+    dryRun?: boolean;
+    repository?: string | null;
+    execution?: 'parallel' | 'sequential';
+    concurrency?: number;
+    onProgress?: (message: string, stream?: 'stdout' | 'stderr') => void;
 }): Promise<{
-    secrets: never[];
-    variables: never[];
+    secrets: Array<{
+        name: string;
+        existed: boolean;
+    }>;
+    variables: Array<{
+        name: string;
+        existed: boolean;
+    }>;
     repository: string;
-    scope: string;
+    scope: "local" | "staging" | "prod";
+    environment: string;
 }>;
 export declare function syncTreeseedCloudflareEnvironment({ tenantRoot, scope, dryRun }?: {
     scope?: string | undefined;
@@ -404,14 +417,17 @@ export declare function applyTreeseedConfigValues({ tenantRoot, updates, applyLo
     }[];
     sharedStorageMigrations: TreeseedSharedStorageMigrationNotice[];
 };
-export declare function finalizeTreeseedConfig({ tenantRoot, scopes, sync, env, checkConnections, initializePersistent, onProgress, }: {
+export declare function finalizeTreeseedConfig({ tenantRoot, scopes, sync, env, checkConnections, initializePersistent, systems, skipUnavailable, bootstrapExecution, onProgress, }: {
     tenantRoot: string;
     scopes?: TreeseedConfigScope[];
     sync?: 'none' | 'github' | 'cloudflare' | 'railway' | 'all';
     env?: NodeJS.ProcessEnv;
     checkConnections?: boolean;
     initializePersistent?: boolean;
-    onProgress?: (message: string) => void;
+    systems?: TreeseedBootstrapSystem[] | TreeseedBootstrapSystem;
+    skipUnavailable?: boolean;
+    bootstrapExecution?: 'parallel' | 'sequential';
+    onProgress?: (message: string, stream?: 'stdout' | 'stderr') => void;
 }): Promise<{
     scopes: ("local" | "staging" | "prod")[];
     synced: Record<string, unknown>;
@@ -437,6 +453,8 @@ export declare function finalizeTreeseedConfig({ tenantRoot, scopes, sync, env,
     resourceInventoryByScope: Record<TreeseedConfigScope, Record<string, unknown>>;
     connectionChecks: ReturnType<typeof checkTreeseedProviderConnections>[];
     validationByScope: Record<TreeseedConfigScope, ReturnType<typeof validateTreeseedEnvironmentValues>>;
+    bootstrapSystemsByScope: Record<TreeseedConfigScope, ReturnType<typeof resolveTreeseedBootstrapSelection>>;
+    githubRepository: Record<string, unknown> | null;
     readinessByScope: Record<TreeseedConfigScope, {
         phase: string;
         configured: boolean;
@@ -446,6 +464,7 @@ export declare function finalizeTreeseedConfig({ tenantRoot, scopes, sync, env,
         warnings: string[];
         checks: Record<string, unknown>;
     }>;
+    bootstrapExecution: "parallel" | "sequential";
 }>;
 export declare function collectTreeseedPrintEnvReport({ tenantRoot, scope, env, revealSecrets, }: {
     tenantRoot: string;