@treeseed/sdk 0.11.0 → 0.12.5

package/dist/reconcile/providers/docker-private.d.ts

@@ -0,0 +1,54 @@
+export type DockerCommandResult = {
+    ok: boolean;
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    args: string[];
+};
+export declare function inspectDockerAvailability(): {
+    available: boolean;
+    buildxAvailable: boolean;
+    version: string | null;
+    buildx: string | null;
+    warnings: string[];
+};
+export declare function inspectDockerImage(tag: string): Record<string, unknown> | null;
+export declare function inspectDockerManifest(ref: string): {
+    ref: string;
+    output: string;
+} | null;
+export declare function buildDockerImage(input: {
+    tenantRoot: string;
+    packageRoot: string;
+    context: string;
+    dockerfile: string;
+    target?: string | null;
+    platforms: string[];
+    tags: string[];
+    labels?: Record<string, string>;
+    buildArgs?: Record<string, string>;
+    push?: boolean;
+    load?: boolean;
+    provenance?: boolean;
+    env?: NodeJS.ProcessEnv;
+}): {
+    contextPath: string;
+    dockerfilePath: string;
+    tags: string[];
+    platforms: string[];
+    ok: boolean;
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    args: string[];
+};
+export declare function runDockerCompose(input: {
+    composeFile?: string;
+    composeFiles?: string[];
+    projectName: string;
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    profiles?: string[];
+    buildPolicy?: 'never' | 'missing' | 'always';
+    action: 'config' | 'ps' | 'up' | 'down' | 'restart' | 'logs';
+}): DockerCommandResult;

package/dist/reconcile/providers/docker-private.js

@@ -0,0 +1,101 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+function runDocker(args, options = {}) {
+  const result = spawnSync("docker", args, {
+    cwd: options.cwd,
+    env: { ...process.env, ...options.env ?? {} },
+    encoding: "utf8"
+  });
+  return {
+    ok: (result.status ?? 1) === 0,
+    status: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    args
+  };
+}
+function inspectDockerAvailability() {
+  const version = runDocker(["version", "--format", "{{.Server.Version}}"]);
+  const buildx = runDocker(["buildx", "version"]);
+  return {
+    available: version.ok,
+    buildxAvailable: buildx.ok,
+    version: version.stdout.trim() || null,
+    buildx: buildx.stdout.trim() || null,
+    warnings: [
+      ...version.ok ? [] : ["Docker is not available in this shell"],
+      ...buildx.ok ? [] : ["Docker Buildx is not available in this shell"]
+    ]
+  };
+}
+function inspectDockerImage(tag) {
+  const result = runDocker(["image", "inspect", tag]);
+  if (!result.ok) return null;
+  try {
+    const parsed = JSON.parse(result.stdout);
+    return parsed[0] ?? null;
+  } catch {
+    return { raw: result.stdout };
+  }
+}
+function inspectDockerManifest(ref) {
+  const result = runDocker(["buildx", "imagetools", "inspect", ref]);
+  return result.ok ? { ref, output: result.stdout } : null;
+}
+function buildDockerImage(input) {
+  const packageRoot = resolve(input.packageRoot);
+  const contextPath = resolve(packageRoot, input.context || ".");
+  const dockerfilePath = resolve(packageRoot, input.dockerfile || "Dockerfile");
+  if (!existsSync(dockerfilePath)) {
+    throw new Error(`Dockerfile does not exist: ${dockerfilePath}`);
+  }
+  const args = [
+    "buildx",
+    "build",
+    "--file",
+    dockerfilePath,
+    "--platform",
+    input.platforms.join(","),
+    ...input.target ? ["--target", input.target] : [],
+    ...input.tags.flatMap((tag) => ["--tag", tag]),
+    ...Object.entries(input.labels ?? {}).flatMap(([key, value]) => ["--label", `${key}=${value}`]),
+    ...Object.entries(input.buildArgs ?? {}).flatMap(([key, value]) => ["--build-arg", `${key}=${value}`]),
+    ...input.push ? ["--push"] : [],
+    ...input.load ? ["--load"] : [],
+    ...input.provenance === false ? ["--provenance=false"] : [],
+    contextPath
+  ];
+  const result = runDocker(args, { cwd: packageRoot, env: input.env });
+  if (!result.ok) {
+    throw new Error(result.stderr.trim() || result.stdout.trim() || `docker ${args.join(" ")} failed`);
+  }
+  return {
+    ...result,
+    contextPath,
+    dockerfilePath,
+    tags: input.tags,
+    platforms: input.platforms
+  };
+}
+function runDockerCompose(input) {
+  const composeFiles = input.composeFiles?.length ? input.composeFiles : input.composeFile ? [input.composeFile] : [];
+  const profileArgs = (input.profiles ?? []).flatMap((profile) => ["--profile", profile]);
+  const buildArgs = input.buildPolicy === "always" ? ["--build"] : input.buildPolicy === "never" ? ["--no-build"] : [];
+  const base = [
+    "compose",
+    ...profileArgs,
+    ...composeFiles.flatMap((composeFile) => ["-f", composeFile]),
+    "-p",
+    input.projectName
+  ];
+  const args = input.action === "config" ? [...base, "config", "--hash"] : input.action === "ps" ? [...base, "ps", "--format", "json"] : input.action === "up" ? [...base, "up", "-d", ...buildArgs] : input.action === "down" ? [...base, "down"] : input.action === "restart" ? [...base, "up", "-d", ...buildArgs, "--force-recreate"] : [...base, "logs", "--tail", "200"];
+  return runDocker(args, { cwd: input.cwd, env: input.env });
+}
+export {
+  buildDockerImage,
+  inspectDockerAvailability,
+  inspectDockerImage,
+  inspectDockerManifest,
+  runDockerCompose
+};

package/dist/reconcile/providers/github-private.d.ts

@@ -0,0 +1,65 @@
+export declare function createReconcileGitHubClient(env: NodeJS.ProcessEnv | Record<string, string | undefined>): import("@octokit/core").Octokit & {
+    paginate: import("@octokit/plugin-paginate-rest").PaginateInterface;
+} & import("@octokit/plugin-paginate-graphql").paginateGraphQLInterface & import("@octokit/plugin-rest-endpoint-methods").Api & {
+    retry: {
+        retryRequest: (error: import("octokit").RequestError, retries: number, retryAfter: number) => import("octokit").RequestError;
+    };
+};
+export declare function observeGitHubEnvironment(repository: string, environment: string, env: NodeJS.ProcessEnv | Record<string, string | undefined>): Promise<{
+    exists: boolean;
+    repository: string;
+    environment: string;
+    secretNames: string[];
+    variableNames: string[];
+    authAvailable?: undefined;
+    error?: undefined;
+} | {
+    exists: boolean;
+    authAvailable: boolean;
+    repository: string;
+    environment: string;
+    secretNames: never[];
+    variableNames: never[];
+    error: string;
+}>;
+export declare function ensureReconcileGitHubEnvironment(repository: string, environment: string, branchName: string | null, env: NodeJS.ProcessEnv | Record<string, string | undefined>): Promise<{
+    repository: string;
+    environment: string;
+}>;
+export declare function upsertReconcileGitHubSecret(repository: string, environment: string, name: string, value: string, env: NodeJS.ProcessEnv | Record<string, string | undefined>): Promise<void>;
+export declare function upsertReconcileGitHubVariable(repository: string, environment: string, name: string, value: string, env: NodeJS.ProcessEnv | Record<string, string | undefined>): Promise<void>;
+export declare function observeGitHubWorkflowRun(input: {
+    repository: string;
+    workflow: string;
+    branch?: string | null;
+    env: NodeJS.ProcessEnv | Record<string, string | undefined>;
+}): Promise<import("../../workflow-support.js").GitHubWorkflowRunSummary | {
+    authAvailable: boolean;
+    error: string;
+} | null>;
+export declare function dispatchReconcileGitHubWorkflow(input: {
+    repository: string;
+    workflow: string;
+    branch: string;
+    inputs?: Record<string, string>;
+    wait?: boolean;
+    timeoutMs?: number;
+    env: NodeJS.ProcessEnv | Record<string, string | undefined>;
+}): Promise<{
+    dispatch: import("../../workflow-support.js").GitHubWorkflowDispatchResult;
+    latest: import("../../workflow-support.js").GitHubWorkflowRunSummary | null;
+    completed: {
+        status: string;
+        repository: string;
+        workflow: string;
+        runId: number;
+        headSha: string | null;
+        branch: string | null;
+        createdAt: string | null;
+        updatedAt: string | null;
+        conclusion: string | null;
+        url: string | null;
+        jobs: import("../../operations/services/github-api.js").GitHubWorkflowJobSummary[];
+        failedJobs: import("../../operations/services/github-api.js").GitHubWorkflowJobSummary[];
+    } | null;
+}>;

package/dist/reconcile/providers/github-private.js

@@ -0,0 +1,119 @@
+import {
+  createGitHubApiClient,
+  dispatchGitHubWorkflowRun,
+  ensureGitHubActionsEnvironment,
+  getLatestGitHubWorkflowRun,
+  listGitHubEnvironmentSecretNames,
+  listGitHubEnvironmentVariableNames,
+  upsertGitHubEnvironmentSecret,
+  upsertGitHubEnvironmentVariable,
+  waitForGitHubWorkflowRunCompletion
+} from "../../operations/services/github-api.js";
+function createReconcileGitHubClient(env) {
+  return createGitHubApiClient({ env });
+}
+function isGitHubAuthError(message) {
+  return /authentication failed|bad credentials|requires authentication|401|403|forbidden/iu.test(message);
+}
+async function observeGitHubEnvironment(repository, environment, env) {
+  const client = createReconcileGitHubClient(env);
+  try {
+    const [secretNames, variableNames] = await Promise.all([
+      listGitHubEnvironmentSecretNames(repository, environment, { client }),
+      listGitHubEnvironmentVariableNames(repository, environment, { client })
+    ]);
+    return {
+      exists: true,
+      repository,
+      environment,
+      secretNames: [...secretNames].sort(),
+      variableNames: [...variableNames].sort()
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/not found|404/iu.test(message)) {
+      return {
+        exists: false,
+        authAvailable: true,
+        repository,
+        environment,
+        secretNames: [],
+        variableNames: [],
+        error: message
+      };
+    }
+    if (isGitHubAuthError(message)) {
+      return {
+        exists: false,
+        authAvailable: false,
+        repository,
+        environment,
+        secretNames: [],
+        variableNames: [],
+        error: message
+      };
+    }
+    throw error;
+  }
+}
+async function ensureReconcileGitHubEnvironment(repository, environment, branchName, env) {
+  const client = createReconcileGitHubClient(env);
+  return ensureGitHubActionsEnvironment(repository, environment, { client, branchName: branchName ?? void 0 });
+}
+async function upsertReconcileGitHubSecret(repository, environment, name, value, env) {
+  const client = createReconcileGitHubClient(env);
+  return upsertGitHubEnvironmentSecret(repository, environment, name, value, { client });
+}
+async function upsertReconcileGitHubVariable(repository, environment, name, value, env) {
+  const client = createReconcileGitHubClient(env);
+  return upsertGitHubEnvironmentVariable(repository, environment, name, value, { client });
+}
+async function observeGitHubWorkflowRun(input) {
+  const client = createReconcileGitHubClient(input.env);
+  try {
+    return await getLatestGitHubWorkflowRun(input.repository, {
+      client,
+      workflow: input.workflow,
+      branch: input.branch
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (isGitHubAuthError(message) || /not found|404/iu.test(message)) {
+      return {
+        authAvailable: false,
+        error: message
+      };
+    }
+    throw error;
+  }
+}
+async function dispatchReconcileGitHubWorkflow(input) {
+  const client = createReconcileGitHubClient(input.env);
+  const dispatch = await dispatchGitHubWorkflowRun(input.repository, {
+    client,
+    workflow: input.workflow,
+    branch: input.branch,
+    inputs: input.inputs
+  });
+  const latest = await getLatestGitHubWorkflowRun(input.repository, {
+    client,
+    workflow: input.workflow,
+    branch: input.branch
+  });
+  const completed = input.wait ? await waitForGitHubWorkflowRunCompletion(input.repository, {
+    client,
+    workflow: input.workflow,
+    branch: input.branch,
+    timeoutSeconds: input.timeoutMs ? Math.ceil(input.timeoutMs / 1e3) : void 0
+  }) : null;
+  return { dispatch, latest, completed };
+}
+export {
+  createReconcileGitHubClient,
+  dispatchReconcileGitHubWorkflow,
+  ensureReconcileGitHubEnvironment,
+  observeGitHubEnvironment,
+  observeGitHubWorkflowRun,
+  upsertReconcileGitHubSecret,
+  upsertReconcileGitHubVariable
+};

package/dist/reconcile/providers/local-private.d.ts

@@ -0,0 +1,28 @@
+import { type TreeseedManagedDevAction } from '../../local-dev/managed-dev.js';
+export declare function runManagedDevAction(input: {
+    tenantRoot: string;
+    action: TreeseedManagedDevAction;
+    surfaces: string[];
+    options?: Record<string, unknown>;
+    env?: NodeJS.ProcessEnv;
+}): Promise<{
+    ok: boolean;
+    status: number;
+    stdout: string;
+    stderr: string;
+    output: string;
+    parsed: import("../../local-dev/managed-dev.js").TreeseedManagedDevResult;
+    args: TreeseedManagedDevAction[];
+    surfaces: string[];
+}>;
+export declare function checkHttpHealth(url: string, timeoutMs?: number): Promise<{
+    ok: boolean;
+    status: number;
+    url: string;
+    error?: undefined;
+} | {
+    ok: boolean;
+    status: null;
+    url: string;
+    error: string;
+}>;

package/dist/reconcile/providers/local-private.js

@@ -0,0 +1,75 @@
+import { runTreeseedManagedDev } from "../../local-dev/managed-dev.js";
+function runManagedDevAction(input) {
+  return runTreeseedManagedDev({
+    action: input.action,
+    cwd: input.tenantRoot,
+    surfaces: input.surfaces.join(","),
+    webRuntime: input.options?.webRuntime,
+    webHost: typeof input.options?.host === "string" ? input.options.host : void 0,
+    webPort: typeof input.options?.port === "number" ? input.options.port : void 0,
+    apiHost: typeof input.options?.apiHost === "string" ? input.options.apiHost : void 0,
+    apiPort: typeof input.options?.apiPort === "number" ? input.options.apiPort : void 0,
+    force: input.options?.force === true,
+    forceConflicts: input.options?.forceConflicts === true,
+    all: input.options?.all === true,
+    follow: input.options?.follow === true,
+    env: input.env
+  }).then((result) => {
+    const safeResult = sanitizeManagedDevResult(result);
+    return {
+      ok: safeResult.ok,
+      status: safeResult.ok ? 0 : 1,
+      stdout: `${JSON.stringify(safeResult)}
+`,
+      stderr: "",
+      output: JSON.stringify(safeResult),
+      parsed: safeResult,
+      args: [input.action],
+      surfaces: input.surfaces
+    };
+  });
+}
+function sanitizeManagedDevResult(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => sanitizeManagedDevResult(entry));
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "env") {
+      continue;
+    }
+    if (key === "redactedEnv" || key === "envKeys") {
+      continue;
+    }
+    result[key] = sanitizeManagedDevResult(entry);
+  }
+  return result;
+}
+async function checkHttpHealth(url, timeoutMs = 2e3) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { signal: controller.signal });
+    return {
+      ok: response.ok,
+      status: response.status,
+      url
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      status: null,
+      url,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+export {
+  checkHttpHealth,
+  runManagedDevAction
+};

package/dist/reconcile/providers/railway-iac.d.ts

@@ -0,0 +1,66 @@
+import { type RailwayChangeSet, type RailwayIacApplyResponse, type RailwayIacPlanResponse } from 'railway/iac';
+export type TreeseedRailwayIacService = {
+    key: string;
+    serviceName: string;
+    sourceMode?: string | null;
+    sourceRepo?: string | null;
+    sourceBranch?: string | null;
+    sourceCommit?: string | null;
+    sourceRootDirectory?: string | null;
+    imageRef?: string | null;
+    dockerfilePath?: string | null;
+    buildCommand?: string | null;
+    startCommand?: string | null;
+    healthcheckPath?: string | null;
+    healthcheckTimeoutSeconds?: number | null;
+    runtimeMode?: string | null;
+    volumeMountPath?: string | null;
+    variables?: Record<string, string>;
+    secrets?: Record<string, string>;
+    detachVolumeIds?: string[];
+};
+export type TreeseedRailwayIacDatabase = {
+    serviceName: string;
+    environmentVariable: string;
+    mountPath?: string | null;
+    detachVolumeIds?: string[];
+    useNativePostgres?: boolean;
+};
+export type TreeseedRailwayIacProjectInput = {
+    tenantRoot: string;
+    projectName: string;
+    projectId: string;
+    environmentName: string;
+    environmentId: string;
+    railwayApiToken: string;
+    railwayApiUrl?: string | null;
+    services: TreeseedRailwayIacService[];
+    database: TreeseedRailwayIacDatabase | null;
+    region?: string | null;
+};
+export type TreeseedRailwayIacRenderResult = {
+    filePath: string;
+    tempDir: string;
+    projectName: string;
+    environmentName: string;
+    serviceNames: string[];
+    volumeNames: string[];
+    databaseName: string | null;
+    source: string;
+};
+export type RailwayIacValidationResult = {
+    ok: boolean;
+    destructiveChanges: string[];
+    blockedReasons: string[];
+    allowedDrift: string[];
+};
+export declare function renderRailwayIacProject(input: TreeseedRailwayIacProjectInput): TreeseedRailwayIacRenderResult;
+export declare function validateRailwayIacChangeSet(changeSet: RailwayChangeSet | undefined, desiredNames: {
+    services: string[];
+    volumes: string[];
+    database: string | null;
+    scope: string;
+}): RailwayIacValidationResult;
+export declare function planRailwayIacProject(input: TreeseedRailwayIacProjectInput, rendered?: TreeseedRailwayIacRenderResult): Promise<RailwayIacPlanResponse>;
+export declare function applyRailwayIacProject(input: TreeseedRailwayIacProjectInput, rendered?: TreeseedRailwayIacRenderResult): Promise<RailwayIacApplyResponse>;
+export declare function cleanupRailwayIacRender(rendered: Pick<TreeseedRailwayIacRenderResult, 'tempDir'>): void;