@treeseed/sdk 0.6.6 → 0.6.8

package/dist/operations/services/railway-deploy.js

@@ -4,6 +4,7 @@ import { spawnSync } from "node:child_process";
 import { loadCliDeployConfig } from "./runtime-tools.js";
 import { createPersistentDeployTarget, resolveTreeseedResourceIdentity } from "./deploy.js";
 import { runPrefixedCommand, sleep } from "./bootstrap-runner.js";
+import { resolveTreeseedToolCommand } from "../../managed-dependencies.js";
 import {
   ensureRailwayEnvironment,
   ensureRailwayProject,
@@ -148,7 +149,7 @@ function isRailwayAlreadyExistsMessage(result) {
   return /already exists|already taken|duplicate|has already been taken/iu.test(railwayMessage(result));
 }
 function isRailwayTransientFailure(result) {
-  return /timed out|failed to fetch|temporarily unavailable|econnreset|etimedout/iu.test(railwayMessage(result));
+  return /timed out|failed to fetch|temporarily unavailable|econnreset|etimedout|failed to stream build logs|failed to retrieve build log/iu.test(railwayMessage(result));
 }
 function sleepSync(milliseconds) {
   if (!Number.isFinite(milliseconds) || milliseconds <= 0) {
@@ -230,7 +231,11 @@ mutation TreeseedScheduleUpdate($id: String!, $name: String!, $schedule: String!
 }
 function runRailway(args, { cwd, capture = false, allowFailure = false, input, env } = {}) {
   const effectiveEnv = buildRailwayCommandEnv({ ...process.env, ...env ?? {} });
-  const runWithEnv = (spawnEnv) => spawnSync("railway", args, {
+  const railway = resolveTreeseedToolCommand("railway", { env: effectiveEnv });
+  if (!railway) {
+    throw new Error("Railway CLI is unavailable.");
+  }
+  const runWithEnv = (spawnEnv) => spawnSync(railway.command, [...railway.argsPrefix, ...args], {
     cwd,
     stdio: input !== void 0 ? ["pipe", capture ? "pipe" : "inherit", capture ? "pipe" : "inherit"] : capture ? "pipe" : "inherit",
     encoding: "utf8",
@@ -243,34 +248,35 @@ function runRailway(args, { cwd, capture = false, allowFailure = false, input, e
   }
   return result;
 }
-function shellEscape(value) {
-  return `'${String(value).replace(/'/gu, `'\\''`)}'`;
-}
 function setRailwaySecretVariable({ cwd, service, environment, key, value, env = process.env, capture = false, allowFailure = false }) {
   const effectiveEnv = buildRailwayCommandEnv({
     ...process.env,
-    ...env ?? {},
-    TREESEED_RAILWAY_SECRET_VALUE: value
+    ...env ?? {}
   });
-  const command = [
-    'printf %s\\\\n "$TREESEED_RAILWAY_SECRET_VALUE"',
-    "|",
-    "railway variable set",
-    "--service",
-    shellEscape(service),
-    "--environment",
-    shellEscape(environment),
-    "--stdin",
-    "--skip-deploys",
-    shellEscape(key)
-  ].join(" ");
   let result = null;
   for (let attempt = 0; attempt < 3; attempt += 1) {
-    result = spawnSync("bash", ["-lc", command], {
+    const railway = resolveTreeseedToolCommand("railway", { env: effectiveEnv });
+    if (!railway) {
+      throw new Error("Railway CLI is unavailable.");
+    }
+    result = spawnSync(railway.command, [
+      ...railway.argsPrefix,
+      "variable",
+      "set",
+      "--service",
+      service,
+      "--environment",
+      environment,
+      "--stdin",
+      "--skip-deploys",
+      key
+    ], {
       cwd,
-      stdio: capture ? "pipe" : "inherit",
+      stdio: ["pipe", capture ? "pipe" : "inherit", capture ? "pipe" : "inherit"],
       encoding: "utf8",
-      env: effectiveEnv
+      env: effectiveEnv,
+      input: `${value}
+`
     });
     if (result.status === 0) {
       return result;
@@ -830,8 +836,19 @@ async function verifyRailwayScheduledJobs(tenantRoot, scope, { fetchImpl = fetch
     checks
   };
 }
-function planRailwayServiceDeploy(service) {
-  const args = ["up", "--service", service.serviceName ?? service.serviceId, "--ci"];
+function shouldAttachRailwayDeployLogs(env = process.env) {
+  return configuredEnvValue(env, "TREESEED_RAILWAY_DEPLOY_ATTACH_LOGS") === "1";
+}
+function planRailwayServiceDeploy(service, { env = process.env } = {}) {
+  const args = [
+    "up",
+    "--service",
+    service.serviceName ?? service.serviceId,
+    shouldAttachRailwayDeployLogs(env) ? "--ci" : "--detach"
+  ];
+  if (service.projectId) {
+    args.push("--project", service.projectId);
+  }
   const environmentName = normalizeRailwayEnvironmentName(service.railwayEnvironment);
   if (environmentName) {
     args.push("--environment", environmentName);
@@ -842,6 +859,24 @@ function planRailwayServiceDeploy(service) {
     cwd: service.rootDir
   };
 }
+async function resolveRailwayDeployProjectContext(service, { env = process.env } = {}) {
+  if (service.projectId) {
+    return service;
+  }
+  const workspace = await resolveRailwayWorkspaceContext({ env });
+  const { project } = await ensureRailwayProject({
+    projectId: service.projectId,
+    projectName: service.projectName,
+    defaultEnvironmentName: service.railwayEnvironment,
+    env,
+    workspace: workspace.id
+  });
+  return {
+    ...service,
+    projectId: project.id,
+    projectName: project.name ?? service.projectName
+  };
+}
 async function syncRailwayServiceRuntimeConfigurationAfterDeploy(tenantRoot, service, { env = process.env } = {}) {
   const wantsInstanceConfig = service.buildCommand || service.startCommand || service.rootDir || service.healthcheckPath || service.healthcheckTimeoutSeconds !== null || service.healthcheckTimeoutSeconds !== void 0 || service.healthcheckIntervalSeconds !== null || service.healthcheckIntervalSeconds !== void 0 || service.restartPolicy || service.runtimeMode;
   if (!wantsInstanceConfig) {
@@ -907,32 +942,34 @@ async function deployRailwayService(tenantRoot, service, {
   prefix,
   env = process.env
 } = {}) {
-  const plan = planRailwayServiceDeploy(service);
   if (dryRun) {
+    const plan2 = planRailwayServiceDeploy(service, { env });
     return {
       service: service.key,
       status: "planned",
-      command: [plan.command, ...plan.args].join(" "),
-      cwd: plan.cwd,
+      command: [plan2.command, ...plan2.args].join(" "),
+      cwd: plan2.cwd,
       publicBaseUrl: service.publicBaseUrl
     };
   }
+  const deployService = await resolveRailwayDeployProjectContext(service, { env });
+  const plan = planRailwayServiceDeploy(deployService, { env });
   const taskPrefix = prefix ?? {
-    scope: normalizeScope(service.scope ?? service.railwayEnvironment ?? "railway"),
-    system: service.key === "api" ? "api" : "agents",
-    task: `${service.key}-railway-deploy`,
+    scope: normalizeScope(deployService.scope ?? deployService.railwayEnvironment ?? "railway"),
+    system: deployService.key === "api" ? "api" : "agents",
+    task: `${deployService.key}-railway-deploy`,
     stage: "deploy"
   };
   const commandEnv = buildRailwayCommandEnv({ ...process.env, ...env });
-  if (service.buildCommand) {
-    const buildResult = await runPrefixedCommand("bash", ["-lc", service.buildCommand], {
-      cwd: service.rootDir,
+  if (deployService.buildCommand) {
+    const buildResult = await runPrefixedCommand("bash", ["-lc", deployService.buildCommand], {
+      cwd: deployService.rootDir,
       env: commandEnv,
       write,
       prefix: { ...taskPrefix, stage: "build" }
     });
     if (buildResult.status !== 0) {
-      throw new Error(`Railway ${service.key} build command failed.`);
+      throw new Error(`Railway ${deployService.key} build command failed.`);
     }
   }
   let lastFailure = null;
@@ -952,22 +989,22 @@ async function deployRailwayService(tenantRoot, service, {
       throw new Error(result.stderr?.trim() || result.stdout?.trim() || `railway ${plan.args.join(" ")} failed`);
     }
     const backoffMs = 5e3 * attempt;
-    const warning = `Railway deploy for ${service.serviceName ?? service.serviceId ?? service.key} hit a transient failure; retrying in ${Math.round(backoffMs / 1e3)}s...`;
+    const warning = `Railway deploy for ${deployService.serviceName ?? deployService.serviceId ?? deployService.key} hit a transient failure; retrying in ${Math.round(backoffMs / 1e3)}s...`;
     write ? write(`[${taskPrefix.scope}][${taskPrefix.system}][${taskPrefix.task}][retry] ${warning}`, "stderr") : console.warn(warning);
     await sleep(backoffMs);
   }
   if (lastFailure) {
     throw new Error(lastFailure.stderr?.trim() || lastFailure.stdout?.trim() || `railway ${plan.args.join(" ")} failed`);
   }
-  const runtimeConfiguration = await syncRailwayServiceRuntimeConfigurationAfterDeploy(tenantRoot, service, {
+  const runtimeConfiguration = await syncRailwayServiceRuntimeConfigurationAfterDeploy(tenantRoot, deployService, {
     env: commandEnv
   });
   return {
-    service: service.key,
+    service: deployService.key,
     status: "deployed",
     command: [plan.command, ...plan.args].join(" "),
     cwd: plan.cwd,
-    publicBaseUrl: service.publicBaseUrl,
+    publicBaseUrl: deployService.publicBaseUrl,
     runtimeConfiguration: runtimeConfiguration ? {
       updated: runtimeConfiguration.updated,
       healthcheckPath: runtimeConfiguration.instance.healthcheckPath,
@@ -986,6 +1023,7 @@ export {
   ensureRailwayProjectExists,
   ensureRailwayScheduledJobs,
   ensureRailwayServiceExists,
+  isRailwayTransientFailure,
   isUsableRailwayToken,
   planRailwayServiceDeploy,
   resolveRailwayAuthToken,

package/dist/operations/services/repository-save-orchestrator.d.ts

@@ -0,0 +1,172 @@
+import { type GitRemoteWriteMode } from './git-remote-policy.ts';
+import { type CommitMessageContext, type CommitMessageProvider, type CommitMessageProviderMode } from './commit-message-provider.ts';
+import { type DevDependencyReferenceMode, type GitDependencyProtocol } from './package-reference-policy.ts';
+export type RepoKind = 'package' | 'project';
+export type RepoBranchMode = 'package-release-main' | 'package-dev-save' | 'project-save';
+export type SaveVerifyMode = 'action-first' | 'local-only' | 'skip';
+export type SaveCommitMessageMode = CommitMessageProviderMode;
+export type SaveDevVersionStrategy = 'prerelease';
+export type ReleaseBumpLevel = 'major' | 'minor' | 'patch';
+export type RepositorySaveNode = {
+    id: string;
+    name: string;
+    path: string;
+    relativePath: string;
+    kind: RepoKind;
+    branch: string | null;
+    branchMode: RepoBranchMode;
+    packageJsonPath: string | null;
+    packageJson: Record<string, unknown> | null;
+    scripts: Record<string, string>;
+    remoteUrl: string | null;
+    dependencies: string[];
+    dependents: string[];
+    submoduleDependencies: string[];
+    plannedVersion: string | null;
+    plannedTag: string | null;
+    plannedDependencySpec: string | null;
+};
+export type RepositorySaveReport = {
+    name: string;
+    path: string;
+    branch: string | null;
+    dirty: boolean;
+    created: boolean;
+    resumed: boolean;
+    merged: boolean;
+    verified: boolean;
+    committed: boolean;
+    pushed: boolean;
+    deletedLocal: boolean;
+    deletedRemote: boolean;
+    tagName: string | null;
+    commitSha: string | null;
+    skippedReason: string | null;
+    publishWait: Record<string, unknown> | null;
+    version: string | null;
+    dependencySpec: string | null;
+    devTagMetadata: string | null;
+    replacedDevTags: string[];
+    branchMode: RepoBranchMode;
+    verification: RepositoryVerificationResult | null;
+    install: RepositoryInstallResult | null;
+    lockfileValidation: RepositoryLockfileValidationResult | null;
+    commitMessage: string | null;
+    commitMessageProvider: 'cloudflare-workers-ai' | 'fallback' | null;
+    commitMessageFallbackUsed: boolean;
+    commitMessageError: string | null;
+};
+export type RepositoryVerificationResult = {
+    mode: SaveVerifyMode;
+    status: 'passed' | 'failed' | 'skipped';
+    primary: 'verify:action' | 'verify:local' | null;
+    fallbackUsed: boolean;
+    error: string | null;
+};
+export type RepositoryInstallResult = {
+    status: 'completed' | 'skipped';
+    attempts: number;
+    reason: string | null;
+};
+export type RepositoryLockfileValidationResult = {
+    status: 'passed' | 'failed' | 'skipped';
+    command: string | null;
+    issues: string[];
+    error: string | null;
+};
+export type RepositoryCommitMessageContext = CommitMessageContext;
+export type RepositoryCommitMessageProvider = CommitMessageProvider;
+export type RepositorySaveResult = {
+    mode: 'root-only' | 'recursive-workspace';
+    branch: string;
+    scope: 'local' | 'staging' | 'prod';
+    repos: RepositorySaveReport[];
+    rootRepo: RepositorySaveReport;
+    waves: string[][];
+    plannedVersions: Record<string, string>;
+};
+export type RepositorySavePlanRepo = {
+    id: string;
+    name: string;
+    path: string;
+    relativePath: string;
+    kind: RepoKind;
+    currentBranch: string | null;
+    targetBranch: string;
+    branchMode: RepoBranchMode;
+    dirty: boolean;
+    dependencies: string[];
+    dependents: string[];
+    submoduleDependencies: string[];
+    currentVersion: string | null;
+    plannedVersion: string | null;
+    plannedTag: string | null;
+    plannedDependencySpec: string | null;
+    remoteUrl: string | null;
+    commands: string[];
+    notes: string[];
+};
+export type RepositorySavePlanWave = {
+    index: number;
+    parallel: boolean;
+    repos: string[];
+    commands: Array<{
+        repo: string;
+        commands: string[];
+    }>;
+};
+export type RepositorySavePlan = {
+    mode: 'root-only' | 'recursive-workspace';
+    branch: string;
+    scope: 'local' | 'staging' | 'prod';
+    devDependencyReferenceMode: DevDependencyReferenceMode;
+    gitDependencyProtocol: GitDependencyProtocol;
+    verifyMode: SaveVerifyMode;
+    commitMessageMode: SaveCommitMessageMode;
+    repos: RepositorySavePlanRepo[];
+    rootRepo: RepositorySavePlanRepo;
+    waves: RepositorySavePlanWave[];
+    plannedVersions: Record<string, string>;
+    plannedSteps: Array<{
+        id: string;
+        description: string;
+    }>;
+};
+export type RepositorySaveOptions = {
+    root: string;
+    gitRoot: string;
+    branch: string;
+    message?: string;
+    bump?: ReleaseBumpLevel;
+    devVersionStrategy?: SaveDevVersionStrategy;
+    devDependencyReferenceMode?: DevDependencyReferenceMode;
+    gitDependencyProtocol?: GitDependencyProtocol;
+    gitRemoteWriteMode?: GitRemoteWriteMode;
+    verifyMode?: SaveVerifyMode;
+    commitMessageMode?: SaveCommitMessageMode;
+    commitMessageProvider?: RepositoryCommitMessageProvider;
+    workflowRunId?: string | null;
+    includeRoot?: boolean;
+    stablePackageRelease?: boolean;
+    onProgress?: (message: string, stream?: 'stdout' | 'stderr') => void;
+};
+export declare function nextDevVersion(version: string, branch: string, date?: Date): string;
+export declare function discoverRepositorySaveNodes(root: string, gitRoot?: string, branch?: string, options?: {
+    stablePackageRelease?: boolean;
+}): RepositorySaveNode[];
+export declare function repositorySaveWaves(nodes: RepositorySaveNode[]): RepositorySaveNode[][];
+export declare function planRepositorySave(options: RepositorySaveOptions): RepositorySavePlan;
+export declare function refreshAndValidateRootWorkspaceLockfileForSave(options: {
+    root: string;
+    gitRoot?: string;
+    branch?: string | null;
+    onProgress?: (message: string, stream?: 'stdout' | 'stderr') => void;
+}): Promise<{
+    install: RepositoryInstallResult | null;
+    lockfileValidation: RepositoryLockfileValidationResult | null;
+}>;
+export declare function runRepositorySaveOrchestrator(options: RepositorySaveOptions): Promise<RepositorySaveResult>;
+export declare function repositorySaveErrorDetails(error: unknown): {
+    exitCode: number | undefined;
+    details: Record<string, unknown> | undefined;
+};