@treeseed/sdk 0.12.45 → 0.12.46

package/dist/operations/services/live-hosted-service-checks.js

@@ -19,7 +19,7 @@ import {
 } from "./hosted-service-checks.js";
 const DEFAULT_RETRY_ATTEMPTS = 3;
 const DEFAULT_RETRY_INTERVAL_MS = 1500;
-const DEFAULT_RAILWAY_DEPLOYMENT_SETTLE_ATTEMPTS = 60;
+const DEFAULT_RAILWAY_DEPLOYMENT_SETTLE_ATTEMPTS = 120;
 const DEFAULT_RAILWAY_DEPLOYMENT_SETTLE_INTERVAL_MS = 5e3;
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));

package/dist/operations/services/repository-save-orchestrator.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { basename, resolve, relative } from "node:path";
 import { spawn, spawnSync } from "node:child_process";
 import { tmpdir } from "node:os";
@@ -731,18 +731,28 @@ function syncDirectGitDependencyLockfileEntries(node, options, references) {
   let changed = false;
   for (const reference of references) {
     const manifestSpec = reference.manifestSpec ?? reference.spec;
-    for (const field of dependencyFields(rootPackage)) {
-      const values = rootPackage[field];
-      if (!values || typeof values !== "object" || Array.isArray(values)) continue;
-      const dependencies = values;
-      if (reference.packageName in dependencies && dependencies[reference.packageName] !== manifestSpec) {
-        dependencies[reference.packageName] = manifestSpec;
-        changed = true;
+    const visitDependencyMaps = (value) => {
+      if (!value || typeof value !== "object") return;
+      if (Array.isArray(value)) {
+        for (const item of value) visitDependencyMaps(item);
+        return;
       }
-    }
-    const entryKey = `node_modules/${reference.packageName}`;
-    const entry = packageEntries[entryKey];
-    if (entry) {
+      const record = value;
+      for (const field of ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"]) {
+        const dependencies = record[field];
+        if (!dependencies || typeof dependencies !== "object" || Array.isArray(dependencies)) continue;
+        const dependencyMap = dependencies;
+        const current = dependencyMap[reference.packageName];
+        if (typeof current === "string" && /(?:git|github:|#[0-9a-f]{7,40}$)/iu.test(current) && current !== manifestSpec) {
+          dependencyMap[reference.packageName] = manifestSpec;
+          changed = true;
+        }
+      }
+      for (const nested of Object.values(record)) visitDependencyMaps(nested);
+    };
+    visitDependencyMaps(lockfile);
+    for (const [entryKey, entry] of Object.entries(packageEntries)) {
+      if (entryKey !== `node_modules/${reference.packageName}` && !entryKey.endsWith(`/node_modules/${reference.packageName}`)) continue;
       const nextResolved = normalizeGitRemoteForDependency(reference.remoteUrl ?? "", "ssh");
       const resolved = nextResolved ? `${nextResolved}#${manifestSpec.slice(manifestSpec.lastIndexOf("#") + 1)}` : manifestSpec;
       if (entry.resolved !== resolved) {
@@ -764,6 +774,51 @@ function syncDirectGitDependencyLockfileEntries(node, options, references) {
   emitProgress(options, node, "lockfile", "Synchronized direct internal Git dependency lockfile entries without npm git preparation.");
   return true;
 }
+function validateStandaloneGitDependencyLockfile(node, options) {
+  const lockfilePath = resolve(node.path, "package-lock.json");
+  const lockfileExists = existsSync(lockfilePath);
+  const validateArgs = [
+    "ci",
+    "--package-lock-only",
+    "--ignore-scripts",
+    "--workspaces=false",
+    "--no-audit",
+    "--no-fund"
+  ];
+  try {
+    if (!lockfileExists) throw new Error("standalone lockfile missing");
+    runCapturedCommand(node, options, "lockfile", "npm", validateArgs, { timeoutMs: 5 * 6e4 });
+  } catch (validationError) {
+    const previousLockfile = lockfileExists ? readFileSync(lockfilePath, "utf8") : null;
+    const isolatedRoot = mkdtempSync(resolve(tmpdir(), "treeseed-lockfile-"));
+    try {
+      copyFileSync(resolve(node.path, "package.json"), resolve(isolatedRoot, "package.json"));
+      runCapturedCommand(node, options, "lockfile", "npm", [
+        "install",
+        "--package-lock-only",
+        "--ignore-scripts",
+        "--workspaces=false",
+        "--no-audit",
+        "--no-fund"
+      ], {
+        cwd: isolatedRoot,
+        timeoutMs: 15 * 6e4
+      });
+      runCapturedCommand(node, options, "lockfile", "npm", validateArgs, {
+        cwd: isolatedRoot,
+        timeoutMs: 5 * 6e4
+      });
+      copyFileSync(resolve(isolatedRoot, "package-lock.json"), lockfilePath);
+    } catch (regenerationError) {
+      if (previousLockfile !== null) writeFileSync(lockfilePath, previousLockfile, "utf8");
+      throw regenerationError instanceof Error ? regenerationError : validationError;
+    } finally {
+      rmSync(isolatedRoot, { recursive: true, force: true });
+    }
+  }
+  emitProgress(options, node, "lockfile", "Validated the standalone lockfile for exact internal Git refs.");
+  return true;
+}
 function planPackageVersion(node, options) {
   if (!node.packageJson || !node.packageJsonPath) return null;
   const current = String(node.packageJson.version ?? "0.0.0");
@@ -827,7 +882,7 @@ function syncRootWorkspaceLockfileMetadata(node, options) {
       const mergedDeps = { ...currentDeps };
       let fieldChanged = false;
       for (const [dependencyName, dependencySpec] of Object.entries(nextValue)) {
-        if (mergedDeps[dependencyName] != null) continue;
+        if (mergedDeps[dependencyName] === dependencySpec) continue;
         mergedDeps[dependencyName] = dependencySpec;
         fieldChanged = true;
       }
@@ -1711,8 +1766,15 @@ async function saveOneRepository(node, options, state) {
   ensureWritableRemote(node, options);
   const dependencyUpdates = isRootWorkspaceRepository(node, options) ? [] : updateDependencyReferences(node, state.finalizedReferences);
   const dependencyChanged = dependencyUpdates.length > 0;
-  const gitDependencyRefreshReferences = dependencyUpdates.map((update) => state.finalizedReferences.get(update.packageName)).filter((reference) => Boolean(reference) && reference.mode === "dev-git-commit");
+  const directDependencyNames = new Set(dependencyFields(node.packageJson ?? {}).flatMap((field) => {
+    const value = node.packageJson?.[field];
+    return value && typeof value === "object" && !Array.isArray(value) ? Object.keys(value) : [];
+  }));
+  const gitDependencyRefreshReferences = [...state.finalizedReferences.values()].filter((reference) => reference.mode === "dev-git-commit" && directDependencyNames.has(reference.packageName));
   const lockfileGitDependenciesSynced = syncDirectGitDependencyLockfileEntries(node, options, gitDependencyRefreshReferences);
+  if (!isRootWorkspaceRepository(node, options) && (lockfileGitDependenciesSynced || gitDependencyRefreshReferences.length > 0 && !existsSync(resolve(node.path, "package-lock.json")))) {
+    validateStandaloneGitDependencyLockfile(node, options);
+  }
   const gitDependencyRefreshSpecs = lockfileGitDependenciesSynced ? [] : gitDependencyRefreshReferences.map((reference) => `${reference.packageName}@${reference.installSpec ?? reference.spec}`);
   const submodulePointers = collectSubmodulePointerChanges(node, state.finalizedCommits);
   const submodulesChanged = submodulePointers.length > 0;

package/dist/operations/services/workspace-dependency-mode.js

@@ -274,6 +274,10 @@ function removeLinkCandidate(link, managedLinks) {
     unlinkSync(link.linkPath);
     return true;
   }
+  if (managed) {
+    rmSync(link.linkPath, { recursive: true, force: true });
+    return true;
+  }
   if (isInstalledTreeseedPackage(link.linkPath, link.packageName)) {
     rmSync(link.linkPath, { recursive: true, force: true });
     return true;

package/dist/platform/desired-state.js

@@ -62,6 +62,7 @@ function environmentFromTarget(target) {
   return "staging";
 }
 function packageReleaseCapability(adapter) {
+  if (!adapter.capabilities.publish) return adapter.releaseChecks.length > 0 ? "deploy-only" : "none";
   if (adapter.artifacts.some((artifact) => artifact.provider === "docker")) return "image";
   if (adapter.artifacts.some((artifact) => artifact.provider === "npm")) return "npm";
   if (adapter.releaseChecks.length > 0) return "deploy-only";

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

@@ -11,6 +11,7 @@ export declare function runReleaseVerifyCommand(input: {
     status?: undefined;
     signal?: undefined;
     command?: undefined;
+    dependencies?: undefined;
     stdout?: undefined;
     stderr?: undefined;
 } | {
@@ -18,6 +19,15 @@ export declare function runReleaseVerifyCommand(input: {
     status: number | null;
     signal: NodeJS.Signals | null;
     command: import("../../index.js").TreeseedPackageCommand;
+    dependencies: {
+        status: "not-applicable";
+    } | {
+        status: "ready";
+    } | {
+        status: "restored";
+    } | {
+        status: "workspace-linked";
+    };
     stdout: string;
     stderr: string;
     skipped?: undefined;

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

@@ -1,9 +1,43 @@
 import { spawn, spawnSync } from "node:child_process";
-import { mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { findTreeseedPackageAdapter } from "../../operations/services/package-adapters.js";
 import { checkedOutTemplateRepositories } from "../../operations/services/managed-repositories.js";
 import { runTreeseedGitText } from "../../operations/services/git-runner.js";
+import { ensureLocalWorkspaceLinks } from "../../operations/services/workspace-dependency-mode.js";
+function ensureReleaseVerifyDependencies(input) {
+  if (!existsSync(resolve(input.packageDir, "package.json")) || !existsSync(resolve(input.packageDir, "package-lock.json"))) {
+    return { status: "not-applicable" };
+  }
+  const env = { ...process.env, ...input.env ?? {} };
+  const inspection = spawnSync("npm", ["ls", "--depth=0", "--workspaces=false"], {
+    cwd: input.packageDir,
+    env,
+    encoding: "utf8"
+  });
+  if (inspection.status === 0) return { status: "ready" };
+  input.onProgress?.("Package dependencies are incomplete; restoring the standalone lockfile installation.");
+  const install = spawnSync("npm", [
+    "ci",
+    "--ignore-scripts",
+    "--workspaces=false",
+    "--no-audit",
+    "--no-fund"
+  ], {
+    cwd: input.packageDir,
+    env,
+    encoding: "utf8"
+  });
+  if (install.status !== 0) {
+    throw new Error([
+      "Standalone package dependency hydration failed before release verification.",
+      install.stderr,
+      install.stdout
+    ].filter(Boolean).join("\n").trim());
+  }
+  ensureLocalWorkspaceLinks(input.tenantRoot, { env: input.env });
+  return { status: "restored" };
+}
 async function runReleaseVerifyCommand(input) {
   const adapter = findTreeseedPackageAdapter(input.tenantRoot, input.packageId);
   if (!adapter) {
@@ -17,6 +51,15 @@ async function runReleaseVerifyCommand(input) {
       reason: `${input.packageId} has no release verify command.`
     };
   }
+  const dependencies = adapter.capabilities.localOnly ? (() => {
+    ensureLocalWorkspaceLinks(input.tenantRoot, { env: input.env });
+    return { status: "workspace-linked" };
+  })() : ensureReleaseVerifyDependencies({
+    tenantRoot: input.tenantRoot,
+    packageDir: adapter.dir,
+    env: input.env,
+    onProgress: input.onProgress
+  });
   const renderedCommand = [command.command, ...command.args].join(" ");
   input.onProgress?.(`Running ${input.packageId} release verification: ${renderedCommand}`);
   const started = Date.now();
@@ -53,6 +96,7 @@ async function runReleaseVerifyCommand(input) {
     status: result.status,
     signal: result.signal,
     command,
+    dependencies,
     stdout,
     stderr
   };

package/dist/workflow/operations.js

@@ -1222,6 +1222,14 @@ function remoteTagCommit(repoDir, tagName) {
   const direct = output.split("\n").find((line) => line.endsWith(`refs/tags/${tagName}`));
   return (peeled ?? direct)?.split(/\s+/u)[0] ?? null;
 }
+function releaseTagExists(repoDir, tagName) {
+  if (gitObjectCommit(repoDir, tagName)) return true;
+  try {
+    return remoteTagCommit(repoDir, tagName) !== null;
+  } catch {
+    return false;
+  }
+}
 function ensureReleaseTag(repoDir, tagName, commitSha, message) {
   const localCommit = gitObjectCommit(repoDir, tagName);
   if (localCommit && localCommit !== commitSha) {
@@ -2629,6 +2637,14 @@ function buildReleasePlanSnapshot(input) {
       versionPlan.versions.set(adapter.id, incrementVersion(adapter.version, input.level));
     }
   }
+  for (const adapter of discoverTreeseedPackageAdapters(input.root)) {
+    let version = versionPlan.versions.get(adapter.id);
+    if (!version) continue;
+    while (releaseTagExists(adapter.dir, version)) {
+      version = incrementVersion(version, input.level);
+    }
+    versionPlan.versions.set(adapter.id, version);
+  }
   const plannedSelected = orderReleasePackageNames([...versionPlan.selected].filter((name) => versionPlan.versions.has(name)));
   const plannedChanged = input.repairVersionLine === true ? plannedSelected : Array.from(new Set(publishablePackageSelection.changed.filter((name) => plannedSelected.includes(name))));
   const plannedDependents = plannedSelected.filter((name) => !plannedChanged.includes(name));
@@ -4633,7 +4649,7 @@ async function workflowSave(helpers, input) {
               verifyMode: normalizeSaveVerifyMode(effectiveInput.verify === false ? "skip" : effectiveInput.verifyMode),
               commitMessageMode: effectiveInput.commitMessageMode ?? "auto",
               workflowRunId: workflowRun.runId,
-              deferPushUntilVerified: true,
+              deferPushUntilVerified: false,
               onProgress: (line, stream) => helpers.write(line, stream),
               onWaveSaved: branch === STAGING_BRANCH && shouldUseHostedSaveCi(effectiveInput, branch, saveLane) ? async ({ nodes, reports, rootRepo: waveRootRepo }) => {
                 const nonRootReportsForWave = reports.filter((repo, index) => nodes[index]?.id !== ".");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.12.45",
+  "version": "0.12.46",
   "description": "Shared Treeseed SDK for content-backed and D1-backed object models.",
   "license": "AGPL-3.0-only",
   "repository": {