@treeseed/sdk 0.11.0 → 0.12.5

package/dist/operations/services/deployment-readiness.d.ts

@@ -1,4 +1,4 @@
-import { type TreeseedHostingEnvironment } from '../../hosting/index.ts';
+import { type TreeseedHostingEnvironment } from '../../hosting/index.js';
 export type TreeseedDeploymentReadinessStatus = 'passed' | 'failed' | 'warning' | 'skipped';
 export interface TreeseedDeploymentReadinessCheck {
     id: string;

package/dist/operations/services/deployment-readiness.js

@@ -1,5 +1,6 @@
 import { relative, resolve } from "node:path";
 import { compileTreeseedHostingGraph, serializeHostingUnit } from "../../hosting/index.js";
+import { discoverTreeseedPackageAdapters } from "./package-adapters.js";
 import { configuredRailwayServices } from "./railway-deploy.js";
 function relRoot(tenantRoot, path) {
   const value = relative(tenantRoot, path).split("\\").join("/");
@@ -42,6 +43,19 @@ function unitById(units, id) {
 function railwayServiceByKey(services, key) {
   return services.find((service) => service.key === key) ?? null;
 }
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function hasLocalDevService(adapter, serviceId) {
+  const localDev = recordValue(adapter.metadata.localDev);
+  const services = recordValue(localDev.services);
+  return Object.keys(recordValue(services[serviceId])).length > 0;
+}
+function discoveredApiPackageRoot(tenantRoot) {
+  const adapters = discoverTreeseedPackageAdapters(tenantRoot);
+  const matches = adapters.filter((adapter) => hasLocalDevService(adapter, "api") || hasLocalDevService(adapter, "operationsRunner"));
+  return matches.find((adapter) => adapter.id === "@treeseed/api")?.relativeDir ?? matches.find((adapter) => hasLocalDevService(adapter, "api"))?.relativeDir ?? matches[0]?.relativeDir ?? null;
+}
 function collectTreeseedDeploymentReadiness(options) {
   const tenantRoot = resolve(options.tenantRoot);
   const environment = options.environment;
@@ -81,7 +95,7 @@ function collectTreeseedDeploymentReadiness(options) {
         proxyPrefix: apiConnection?.proxyPrefix ?? null
       },
       message: hasApiPlane || configuredBaseUrl ? "Web app has an API app or configured API connection." : "Web app requires an API connection when no local API app manifest is present.",
-      remediation: hasApiPlane || configuredBaseUrl ? void 0 : "Add connections.api to treeseed.site.yaml or include packages/api/treeseed.site.yaml in the workspace."
+      remediation: hasApiPlane || configuredBaseUrl ? void 0 : "Add connections.api to treeseed.site.yaml or include an API package with treeseed.package.yaml localDev metadata."
     });
   }
   if (!hasApiPlane && !hasWorkspaceMarketControlPlane) {
@@ -96,8 +110,9 @@ function collectTreeseedDeploymentReadiness(options) {
   }
   const apiIsNestedApp = Boolean(api?.application?.relativeRoot && api.application.relativeRoot !== ".");
   const runnerIsNestedApp = Boolean(runner?.application?.relativeRoot && runner.application.relativeRoot !== ".");
-  const expectedApiUnitRoot = apiIsNestedApp ? "." : "packages/api";
-  const expectedRunnerUnitRoot = runnerIsNestedApp ? "." : "packages/api";
+  const apiPackageRoot = discoveredApiPackageRoot(tenantRoot) ?? "packages/api";
+  const expectedApiUnitRoot = apiIsNestedApp ? "." : apiPackageRoot;
+  const expectedRunnerUnitRoot = runnerIsNestedApp ? "." : apiPackageRoot;
   const expectedApiRailwayRoot = api?.application?.relativeRoot && api.application.relativeRoot !== "." ? api.application.relativeRoot : expectedApiUnitRoot;
   const expectedRunnerRailwayRoot = runner?.application?.relativeRoot && runner.application.relativeRoot !== "." ? runner.application.relativeRoot : expectedRunnerUnitRoot;
   if (!api) {
@@ -111,8 +126,16 @@ function collectTreeseedDeploymentReadiness(options) {
     checks.push(check("hosting:api:host", api.hostId, environment === "local" ? "local-process" : "railway", "API host matches the expected environment host.", "Set services.api.provider to railway for hosted environments.", "hostId"));
     checks.push(check("hosting:api:projectGroup", api.projectGroupId, "treeseed-control-plane", "API project group targets the Treeseed control plane.", "Bind services.api to the treeseed-control-plane project group.", "projectGroupId"));
     checks.push(check("hosting:api:rootDir", api.config?.rootDir, expectedApiUnitRoot, "API effective rootDir points at the API package.", "Set services.api.rootDir and services.api.railway.rootDir relative to the owning API manifest.", "rootDir"));
-    checks.push(check("hosting:api:buildCommand", api.config?.buildCommand, "npm run build", "API build command is package-local.", 'Set services.api.railway.buildCommand to "npm run build".', "buildCommand"));
-    checks.push(check("hosting:api:startCommand", api.config?.startCommand, "npm run start:api", "API start command is package-local.", 'Set services.api.railway.startCommand to "npm run start:api".', "startCommand"));
+    if (environment === "local") {
+      checks.push(check("hosting:api:buildCommand", api.config?.buildCommand, "npm run build", "API build command is package-local.", 'Set services.api.railway.buildCommand to "npm run build".', "buildCommand"));
+      checks.push(check("hosting:api:startCommand", api.config?.startCommand, "npm run start:api", "API start command is package-local.", 'Set services.api.railway.startCommand to "npm run start:api".', "startCommand"));
+    } else if (environment === "staging") {
+      checks.push(check("hosting:api:sourceMode", api.config?.sourceMode, "git", "API staging deploy uses Railway Git source builds.", "Set services.api.railway.sourceMode to git.", "sourceMode"));
+      checks.push(check("hosting:api:sourceRepo", Boolean(api.config?.sourceRepo), true, "API staging source repository is resolved.", "Set services.api.railway.sourceRepo or package repository metadata.", "sourceRepo"));
+      checks.push(check("hosting:api:dockerfilePath", api.config?.dockerfilePath, "/Dockerfile.api", "API staging deploy uses a Dockerfile build.", "Set services.api.railway.dockerfilePath to /Dockerfile.api.", "dockerfilePath"));
+    } else {
+      checks.push(check("hosting:api:imageRefEnv", api.config?.imageRefEnv, "TREESEED_API_IMAGE_REF", "API Railway deploy uses a Docker image reference.", "Set services.api.railway.imageRef or inject TREESEED_API_IMAGE_REF.", "imageRefEnv"));
+    }
     checks.push(check("hosting:api:healthcheckPath", api.config?.healthcheckPath, "/healthz", "API healthcheck path is /healthz.", "Set services.api.railway.healthcheckPath to /healthz.", "healthcheckPath"));
   }
   if (railwayApi) {
@@ -130,8 +153,16 @@ function collectTreeseedDeploymentReadiness(options) {
     checks.push(check("hosting:operationsRunner:host", runner.hostId, environment === "local" ? "local-docker" : "railway", "Runner host matches the expected environment host.", "Set services.operationsRunner.provider to railway for hosted environments.", "hostId"));
     checks.push(check("hosting:operationsRunner:projectGroup", runner.projectGroupId, "treeseed-control-plane", "Runner project group targets the Treeseed control plane.", "Bind services.operationsRunner to the treeseed-control-plane project group.", "projectGroupId"));
     checks.push(check("hosting:operationsRunner:rootDir", runner.config?.rootDir, expectedRunnerUnitRoot, "Runner effective rootDir points at the API package.", "Set services.operationsRunner.rootDir and services.operationsRunner.railway.rootDir relative to the owning API manifest.", "rootDir"));
-    checks.push(check("hosting:operationsRunner:buildCommand", runner.config?.buildCommand, "npm run build", "Runner build command is package-local.", 'Set services.operationsRunner.railway.buildCommand to "npm run build".', "buildCommand"));
-    checks.push(check("hosting:operationsRunner:startCommand", runner.config?.startCommand, "npm run start:runner", "Runner start command is package-local.", 'Set services.operationsRunner.railway.startCommand to "npm run start:runner".', "startCommand"));
+    if (environment === "local") {
+      checks.push(check("hosting:operationsRunner:buildCommand", runner.config?.buildCommand, "npm run build", "Runner build command is package-local.", 'Set services.operationsRunner.railway.buildCommand to "npm run build".', "buildCommand"));
+      checks.push(check("hosting:operationsRunner:startCommand", runner.config?.startCommand, "npm run start:runner", "Runner start command is package-local.", 'Set services.operationsRunner.railway.startCommand to "npm run start:runner".', "startCommand"));
+    } else if (environment === "staging") {
+      checks.push(check("hosting:operationsRunner:sourceMode", runner.config?.sourceMode, "git", "Runner staging deploy uses Railway Git source builds.", "Set services.operationsRunner.railway.sourceMode to git.", "sourceMode"));
+      checks.push(check("hosting:operationsRunner:sourceRepo", Boolean(runner.config?.sourceRepo), true, "Runner staging source repository is resolved.", "Set services.operationsRunner.railway.sourceRepo or package repository metadata.", "sourceRepo"));
+      checks.push(check("hosting:operationsRunner:dockerfilePath", runner.config?.dockerfilePath, "/Dockerfile.operations-runner", "Runner staging deploy uses a Dockerfile build.", "Set services.operationsRunner.railway.dockerfilePath to /Dockerfile.operations-runner.", "dockerfilePath"));
+    } else {
+      checks.push(check("hosting:operationsRunner:imageRefEnv", runner.config?.imageRefEnv, "TREESEED_OPERATIONS_RUNNER_IMAGE_REF", "Runner Railway deploy uses a Docker image reference.", "Set services.operationsRunner.railway.imageRef or inject TREESEED_OPERATIONS_RUNNER_IMAGE_REF.", "imageRefEnv"));
+    }
     checks.push(check("hosting:operationsRunner:healthcheckPath", runner.config?.healthcheckPath, "/healthz", "Runner healthcheck path is /healthz.", "Set services.operationsRunner.railway.healthcheckPath to /healthz.", "healthcheckPath"));
     checks.push(check("hosting:operationsRunner:runtimeMode", runner.config?.runtimeMode, "service", "Runner runtime mode is a long-running service.", "Set services.operationsRunner.railway.runtimeMode to service.", "runtimeMode"));
     checks.push(check("hosting:operationsRunner:volumeMountPath", runner.config?.volumeMountPath, "/data", "Runner volume mount path is stable.", "Set services.operationsRunner.railway.volumeMountPath to /data.", "volumeMountPath"));

package/dist/operations/services/git-remote-policy.js

@@ -1,4 +1,12 @@
-import { run } from "./workspace-tools.js";
+import { classifyTreeseedGitMode, runTreeseedGitText } from "./git-runner.js";
+function runGit(args, options) {
+  return runTreeseedGitText(args, {
+    cwd: options.cwd,
+    mode: classifyTreeseedGitMode(args),
+    timeoutMs: options.timeoutMs,
+    maxBuffer: options.maxBuffer
+  });
+}
 function normalizeRemote(remoteUrl) {
   return String(remoteUrl ?? "").trim();
 }
@@ -18,7 +26,7 @@ function sshPushUrlForRemote(remoteUrl) {
 }
 function configuredPushUrl(repoDir, remoteName = "origin") {
   try {
-    return run("git", ["config", "--get", `remote.${remoteName}.pushurl`], { cwd: repoDir, capture: true }).trim() || null;
+    return runGit(["config", "--get", `remote.${remoteName}.pushurl`], { cwd: repoDir, capture: true }).trim() || null;
   } catch {
     return null;
   }
@@ -27,7 +35,7 @@ function remoteWriteUrl(repoDir, remoteName = "origin") {
   const pushUrl = configuredPushUrl(repoDir, remoteName);
   if (pushUrl) return pushUrl;
   try {
-    return run("git", ["remote", "get-url", remoteName], { cwd: repoDir, capture: true }).trim() || null;
+    return runGit(["remote", "get-url", remoteName], { cwd: repoDir, capture: true }).trim() || null;
   } catch {
     return null;
   }
@@ -44,7 +52,7 @@ function ensureSshPushUrlForOrigin(repoDir, remoteUrl, mode = "ssh-pushurl") {
   if (currentPushUrl === nextPushUrl) {
     return { changed: false, pushUrl: currentPushUrl, reason: "already-configured" };
   }
-  run("git", ["remote", "set-url", "--push", "origin", nextPushUrl], { cwd: repoDir });
+  runGit(["remote", "set-url", "--push", "origin", nextPushUrl], { cwd: repoDir });
   return { changed: true, pushUrl: nextPushUrl, reason: currentPushUrl ? "updated" : "configured" };
 }
 export {

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

@@ -0,0 +1,66 @@
+export type TreeseedGitRunnerMode = 'read' | 'mutate';
+export type TreeseedGitRunnerResult = {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+};
+export type TreeseedGitLockKind = 'index' | 'ref' | 'packed-refs' | 'head' | 'treeseed-mutation' | 'unknown';
+export type TreeseedGitLockProcessHint = {
+    pid: number;
+    command: string;
+};
+export type TreeseedGitLockDiagnostic = {
+    repoRoot: string;
+    commonGitDir: string | null;
+    lockPath: string | null;
+    relativeLockPath: string | null;
+    kind: TreeseedGitLockKind;
+    exists: boolean;
+    indexLockPath: string | null;
+    indexLockExists: boolean;
+    safeToRepair: boolean;
+    reason: string;
+    removed: boolean;
+    ageMs: number | null;
+    activeGitProcessHints: TreeseedGitLockProcessHint[];
+};
+export type TreeseedGitWorkspaceLockDiagnostics = {
+    root: TreeseedGitLockDiagnostic | TreeseedGitLockDiagnostic[];
+    repositories: Array<TreeseedGitLockDiagnostic | {
+        repoRoot: string;
+        locks: TreeseedGitLockDiagnostic[];
+    }>;
+    summary?: {
+        repositoriesChecked: number;
+        locksPresent: number;
+        safeToRepair: number;
+        unsafe: number;
+        removed: number;
+    };
+};
+type RunOptions = {
+    cwd: string;
+    mode?: TreeseedGitRunnerMode;
+    allowFailure?: boolean;
+    timeoutMs?: number;
+    maxBuffer?: number;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+};
+export type TreeseedGitBatchOperation = RunOptions & {
+    args: string[];
+};
+export declare function classifyTreeseedGitMode(args: string[]): TreeseedGitRunnerMode;
+export declare function inspectTreeseedGitLocks(cwd: string): TreeseedGitLockDiagnostic;
+export declare function inspectTreeseedGitLockSet(cwd: string): TreeseedGitLockDiagnostic[];
+export declare function inspectTreeseedWorkspaceGitLocks(cwd: string): TreeseedGitWorkspaceLockDiagnostics;
+export declare function recoverTreeseedGitLocks(cwd: string, { execute, all }?: {
+    execute?: boolean;
+    all?: boolean;
+}): TreeseedGitLockDiagnostic | TreeseedGitWorkspaceLockDiagnostics;
+export declare function runTreeseedGit(args: string[], options: RunOptions): TreeseedGitRunnerResult;
+export declare function runTreeseedGitText(args: string[], options: RunOptions): string;
+export declare function runTreeseedGitOk(args: string[], options: Omit<RunOptions, 'allowFailure'>): boolean;
+export declare function runTreeseedGitBatch(operations: TreeseedGitBatchOperation[], _options?: {
+    repoSerialization?: boolean;
+}): Promise<TreeseedGitRunnerResult[]>;
+export {};