@mean-weasel/lineage 0.1.13 → 0.1.15

package/dist/cli/lineage-preview.js

@@ -17,7 +17,7 @@ import { existsSync as existsSync6, mkdirSync as mkdirSync5 } from "node:fs";
 import { join as join6 } from "node:path";
 
 // src/server/assetCore.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "node:fs";
 import { dirname as dirname2, join as join3, resolve as resolve2 } from "node:path";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
@@ -590,21 +590,26 @@ function validateProject(project = defaultProject) {
 
 // src/server/profileWriterLease.ts
 import { createHash as createHash3, randomUUID as randomUUID2, timingSafeEqual } from "node:crypto";
-import { existsSync as existsSync5, lstatSync, mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync5, lstatSync as lstatSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
 import { dirname as dirname4, join as join5, resolve as resolve4 } from "node:path";
 
 // src/server/lineageProfiles.ts
 import { createHash as createHash2, randomUUID } from "node:crypto";
 import { createRequire } from "node:module";
 import {
-  chmodSync,
+  chmodSync as chmodSync2,
+  closeSync,
   constants as fsConstants,
   copyFileSync as copyFileSync2,
   existsSync as existsSync4,
+  fsyncSync,
   linkSync,
+  lstatSync,
   mkdirSync as mkdirSync3,
+  openSync,
   readFileSync as readFileSync3,
   realpathSync,
+  renameSync,
   rmSync,
   statSync as statSync3,
   writeFileSync as writeFileSync2
@@ -617,6 +622,7 @@ var lineageProfileSchemaVersion = "lineage.profile.v1";
 var lineageProfileDoctorSchemaVersion = "lineage.profile_doctor.v1";
 var lineageProfileCloneReceiptSchemaVersion = "lineage.profile_clone_receipt.v1";
 var lineageProfileAssetsCloneReceiptSchemaVersion = "lineage.profile_assets_clone_receipt.v1";
+var lineageProfileRuntimeRepinReceiptSchemaVersion = "lineage.profile_runtime_repin_receipt.v1";
 
 // src/server/lineageProfiles.ts
 var require2 = createRequire(import.meta.url);
@@ -761,6 +767,129 @@ function lineageProfileFingerprint(profile) {
     service_origin: profile.service_origin
   })).digest("hex");
 }
+function sha256(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+function assertOwnerOnlyPath(path, kind) {
+  const stats = lstatSync(path);
+  const expectedType = kind === "manifest" ? stats.isFile() : stats.isDirectory();
+  if (!expectedType || stats.isSymbolicLink()) throw new Error(`Profile ${kind} must be a nonsymlink ${kind === "manifest" ? "regular file" : "directory"}: ${path}`);
+  if ((stats.mode & 63) !== 0) throw new Error(`Profile ${kind} must be owner-only: ${path}`);
+  if (typeof process.getuid === "function" && stats.uid !== process.getuid()) throw new Error(`Profile ${kind} must be owned by the current user: ${path}`);
+  return stats;
+}
+function runtimeRepinInvariant(profile) {
+  return JSON.stringify({
+    asset_root: profile.asset_root,
+    database_path: profile.database_path,
+    environment: profile.environment,
+    profile_fingerprint: profile.profile_fingerprint,
+    profile_id: profile.profile_id,
+    required_schema_migrations: profile.required_schema_migrations || [],
+    schema_version: profile.schema_version,
+    service_origin: profile.service_origin
+  });
+}
+function sameFileIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
+}
+function repinLineageDevelopmentProfileRuntime(selector, checkoutRoot, runtime, confirmWrite) {
+  if (!confirmWrite) throw new Error("Profile runtime repin requires --confirm-write");
+  if (runtime.channel !== "dev") throw new Error(`Profile runtime repin requires dev code, not ${runtime.channel}`);
+  if (!runtime.code?.verified) throw new Error("Profile runtime repin requires a verified checkout runtime");
+  if (runtime.code.origin !== "checkout") throw new Error(`Profile runtime repin requires checkout code, not ${runtime.code.origin}`);
+  if (!runtime.code.fingerprint || !/^[a-f0-9]{64}$/i.test(runtime.code.fingerprint)) {
+    throw new Error("Profile runtime repin requires a valid executing code fingerprint");
+  }
+  if (!checkoutRoot.trim()) throw new Error("Profile runtime repin requires --checkout-root");
+  const intendedRoot = realpathSync(resolve3(checkoutRoot));
+  if (!statSync3(intendedRoot).isDirectory()) throw new Error(`Profile runtime repin checkout root is not a directory: ${intendedRoot}`);
+  const executingRoot = realpathSync(runtime.code.root);
+  if (intendedRoot !== executingRoot) {
+    throw new Error(`Profile runtime repin checkout root ${intendedRoot} does not match executing code root ${executingRoot}`);
+  }
+  const profile = resolveLineageProfile(selector);
+  if (profile.environment !== "development") throw new Error(`Profile runtime repin requires a development profile, not ${profile.environment}`);
+  if (profile.expected_runtime?.channel !== "dev") throw new Error("Development profile runtime repin requires an existing dev channel pin");
+  if (profile.expected_runtime.code_origin !== "checkout") throw new Error("Development profile runtime repin requires an existing checkout origin pin");
+  if (!profile.expected_runtime.code_fingerprint) throw new Error("Development profile runtime repin requires an existing code fingerprint pin");
+  const manifestPath = profile.manifest_path;
+  assertOwnerOnlyPath(dirname3(manifestPath), "profile directory");
+  const beforeStats = assertOwnerOnlyPath(manifestPath, "manifest");
+  const beforeText = readFileSync3(manifestPath, "utf8");
+  const beforeHash = sha256(beforeText);
+  let raw;
+  try {
+    raw = JSON.parse(beforeText);
+  } catch (error) {
+    throw new Error(`Could not parse profile manifest ${manifestPath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("Profile manifest must be a JSON object");
+  const previousFingerprint = profile.expected_runtime.code_fingerprint;
+  const nextExpectedRuntime = {
+    channel: "dev",
+    code_fingerprint: runtime.code.fingerprint,
+    code_origin: "checkout",
+    ...runtime.gitSha ? { git_sha: runtime.gitSha } : {},
+    version: runtime.version
+  };
+  const updated = { ...raw, expected_runtime: nextExpectedRuntime };
+  const afterText = `${JSON.stringify(updated, null, 2)}
+`;
+  const afterHash = sha256(afterText);
+  const result = {
+    changed: beforeText !== afterText,
+    checkout_root: intendedRoot,
+    manifest_after_sha256: afterHash,
+    manifest_before_sha256: beforeHash,
+    manifest_path: manifestPath,
+    new_code_fingerprint: runtime.code.fingerprint,
+    previous_code_fingerprint: previousFingerprint,
+    profile_fingerprint: profile.profile_fingerprint,
+    profile_id: profile.profile_id,
+    schema_version: lineageProfileRuntimeRepinReceiptSchemaVersion
+  };
+  if (!result.changed) return result;
+  const temporaryPath = join4(dirname3(manifestPath), `.profile.runtime-repin-${randomUUID()}.tmp`);
+  let temporaryExists = false;
+  try {
+    writeFileSync2(temporaryPath, afterText, { encoding: "utf8", flag: "wx", mode: 384 });
+    temporaryExists = true;
+    chmodSync2(temporaryPath, 384);
+    const temporaryFd = openSync(temporaryPath, "r");
+    try {
+      fsyncSync(temporaryFd);
+    } finally {
+      closeSync(temporaryFd);
+    }
+    const preparedReplacement = resolveLineageProfile(temporaryPath);
+    if (runtimeRepinInvariant(preparedReplacement) !== runtimeRepinInvariant(profile)) {
+      throw new Error("Profile runtime repin would change immutable profile routing identity");
+    }
+    const currentStats = assertOwnerOnlyPath(manifestPath, "manifest");
+    const currentText = readFileSync3(manifestPath, "utf8");
+    if (!sameFileIdentity(beforeStats, currentStats) || sha256(currentText) !== beforeHash) {
+      throw new Error("Profile manifest changed while runtime repin was being prepared; refusing replacement");
+    }
+    renameSync(temporaryPath, manifestPath);
+    temporaryExists = false;
+    chmodSync2(manifestPath, 384);
+    const directoryFd = openSync(dirname3(manifestPath), "r");
+    try {
+      fsyncSync(directoryFd);
+    } finally {
+      closeSync(directoryFd);
+    }
+    const replacement = resolveLineageProfile(manifestPath);
+    if (runtimeRepinInvariant(replacement) !== runtimeRepinInvariant(profile)) {
+      throw new Error("Profile runtime repin changed immutable profile routing identity");
+    }
+    if (readFileSync3(manifestPath, "utf8") !== afterText) throw new Error("Profile runtime repin replacement bytes do not match the prepared manifest");
+    return result;
+  } finally {
+    if (temporaryExists) rmSync(temporaryPath, { force: true });
+  }
+}
 function assertProfileRuntimePin(profile, runtime) {
   if (!profile.expected_runtime?.code_fingerprint || !profile.expected_runtime.code_origin) {
     throw new Error(`Profile ${profile.profile_id} must pin expected_runtime.code_fingerprint and expected_runtime.code_origin before binding or writing`);
@@ -1051,6 +1180,7 @@ async function cloneLineageProfileDatabase(sourceDatabasePath, targetSelector, r
   const source = new DatabaseSync(sourcePath, { readOnly: true });
   try {
     const pagesCopied = await backup(source, temporaryPath);
+    chmodSync2(temporaryPath, 384);
     const cloned = new DatabaseSync(temporaryPath);
     let identity;
     try {
@@ -1188,7 +1318,7 @@ function cloneLineageProfileAssets(sourceAssetRoot, targetSelector, runtime, con
       const destinationPath = join4(targetRoot, relativePath);
       mkdirSync3(dirname3(destinationPath), { recursive: true, mode: 448 });
       copyFileSync2(sourcePath, destinationPath, fsConstants.COPYFILE_EXCL);
-      chmodSync(destinationPath, 384);
+      chmodSync2(destinationPath, 384);
       const sourceHash = fileSha2562(sourcePath);
       const destinationHash = fileSha2562(destinationPath);
       if (sourceHash !== destinationHash) throw new Error("A source asset changed or failed checksum verification during clone");
@@ -1198,7 +1328,7 @@ function cloneLineageProfileAssets(sourceAssetRoot, targetSelector, runtime, con
       treeHash.update(destinationHash);
       treeHash.update("\0");
     }
-    chmodSync(targetRoot, 448);
+    chmodSync2(targetRoot, 448);
     const receiptPath = join4(targetRoot, ".lineage-profile-assets.json");
     const result = {
       asset_root: targetRoot,
@@ -1251,7 +1381,7 @@ function errorCode(error) {
   return error && typeof error === "object" && "code" in error ? String(error.code) : void 0;
 }
 function readOwner(lockPath) {
-  const stat = lstatSync(lockPath);
+  const stat = lstatSync2(lockPath);
   if (!stat.isDirectory() || stat.isSymbolicLink()) {
     throw new Error(`Writer lease path is not a safe directory: ${lockPath}; manual inspection is required`);
   }
@@ -1300,7 +1430,7 @@ function reclaimDeadOwner(lockPath, owner) {
   const tokenFence = createHash3("sha256").update(owner.token).digest("hex").slice(0, 24);
   const tombstone = `${lockPath}.stale-${owner.pid}-${tokenFence}`;
   try {
-    renameSync(lockPath, tombstone);
+    renameSync2(lockPath, tombstone);
   } catch (error) {
     if (errorCode(error) === "ENOENT") return;
     throw error;
@@ -4783,7 +4913,7 @@ function getLineageSelectionPacket(project, options = {}) {
 import { createHash as createHash6 } from "node:crypto";
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { createRequire as createRequire4 } from "node:module";
-import { existsSync as existsSync10, lstatSync as lstatSync2, readFileSync as readFileSync5, readdirSync as readdirSync3, readlinkSync, realpathSync as realpathSync3, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync10, lstatSync as lstatSync3, readFileSync as readFileSync5, readdirSync as readdirSync3, readlinkSync, realpathSync as realpathSync3, statSync as statSync6 } from "node:fs";
 import { dirname as dirname5, isAbsolute as isAbsolute3, join as join9, resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -4810,7 +4940,7 @@ function executingCodeRoot() {
   return canonicalRoot(root);
 }
 var codeRoot = executingCodeRoot();
-function sha256(value) {
+function sha2562(value) {
   return createHash6("sha256").update(value).digest("hex");
 }
 function canonicalRoot(root) {
@@ -4849,7 +4979,7 @@ function untrackedFingerprint(root, status) {
     hash.update(relativePath);
     const path = join9(root, relativePath);
     try {
-      const stat = lstatSync2(path);
+      const stat = lstatSync3(path);
       if (stat.isSymbolicLink()) hash.update(readlinkSync(path));
       else if (stat.isFile()) hash.update(readFileSync5(path));
       else hash.update(`[${stat.mode}:${stat.size}]`);
@@ -4871,12 +5001,12 @@ function checkoutCodeIdentity(root, channel, version) {
   if (status === void 0 || diff === void 0) errors.push("Checkout dirty state could not be inspected");
   if (channel !== "dev") errors.push(`Checkout code may run only as dev, not ${channel}`);
   const dirty = Boolean(status);
-  const sourceFingerprint = sha256(`${gitSha || "unknown"}\0${sha256(diff || "")}\0${untrackedFingerprint(root, status || "")}`);
+  const sourceFingerprint = sha2562(`${gitSha || "unknown"}\0${sha2562(diff || "")}\0${untrackedFingerprint(root, status || "")}`);
   return {
     channel,
     dirty,
     errors,
-    fingerprint: sha256(JSON.stringify({ channel, dirty, git_sha: gitSha, origin: "checkout", root, source_fingerprint: sourceFingerprint, version })),
+    fingerprint: sha2562(JSON.stringify({ channel, dirty, git_sha: gitSha, origin: "checkout", root, source_fingerprint: sourceFingerprint, version })),
     git_sha: gitSha,
     origin: "checkout",
     package_version: version,
@@ -4886,7 +5016,7 @@ function checkoutCodeIdentity(root, channel, version) {
   };
 }
 function buildFingerprint(build) {
-  return sha256(JSON.stringify({
+  return sha2562(JSON.stringify({
     package_name: build.package_name,
     package_version: build.package_version,
     schema_version: build.schema_version,
@@ -4986,7 +5116,7 @@ function packageCodeIdentity(root, channel, info, receiptPath) {
     channel,
     dirty: build?.source_dirty,
     errors,
-    fingerprint: sha256(JSON.stringify({
+    fingerprint: sha2562(JSON.stringify({
       build_fingerprint: build?.build_fingerprint,
       channel,
       install_integrity: install?.package_integrity,
@@ -5014,7 +5144,7 @@ function getLineageCodeIdentity(channel, options = {}) {
   return {
     channel,
     errors,
-    fingerprint: sha256(JSON.stringify({ channel, origin: "unknown", root, version: info.version })),
+    fingerprint: sha2562(JSON.stringify({ channel, origin: "unknown", root, version: info.version })),
     origin: "unknown",
     package_version: info.version,
     root,
@@ -5309,6 +5439,7 @@ Usage:
   ${config.binName} profile bind --profile <id-or-manifest> --confirm-write [--json]
   ${config.binName} profile clone --source-db <snapshot-source> --target-profile <id-or-manifest> --confirm-write [--json]
   ${config.binName} profile clone-assets --source-asset-root <path> --target-profile <id-or-manifest> --confirm-write [--json]
+  ${config.binName} profile repin-runtime --profile <development-profile> --checkout-root <path> --confirm-write [--json]
   ${config.binName} runtime info [--json]
   ${config.binName} runtime doctor [--json]
   ${config.binName} next [--project <project>] [--root <asset-id>] [--db <path>] [--json]
@@ -5715,6 +5846,18 @@ function runLineageProfileCommand(config, command, args) {
   const selector = profileSelector(args);
   if (!selector) throw new Error(`lineage profile ${command} requires --profile or LINEAGE_PROFILE`);
   if (command === "doctor") return doctorLineageProfile(selector, runtimeIdentity);
+  if (command === "repin-runtime") {
+    const checkoutRoot = readOption(args, "--checkout-root");
+    if (!checkoutRoot) throw new Error("Profile runtime repin requires --checkout-root");
+    if (!args.includes("--confirm-write")) throw new Error("Profile runtime repin requires --confirm-write");
+    const profile = resolveLineageProfile(selector);
+    const writerLease = acquireProfileWriterLease(profile, config.channel, "cli");
+    try {
+      return repinLineageDevelopmentProfileRuntime(selector, checkoutRoot, runtimeIdentity, true);
+    } finally {
+      writerLease.release();
+    }
+  }
   if (command === "bind") {
     if (!args.includes("--confirm-write")) throw new Error("Profile bind requires --confirm-write");
     const profile = resolveLineageProfile(selector);
@@ -5740,6 +5883,9 @@ function printProfileResult(result, json) {
   } else if (result.schema_version === "lineage.profile_clone_receipt.v1") {
     console.log(`Cloned ${result.source_database_path} to ${result.database_path} for ${result.target_identity.profile_id}`);
     console.log(`Receipt: ${result.receipt_path}`);
+  } else if (result.schema_version === "lineage.profile_runtime_repin_receipt.v1") {
+    console.log(`${result.changed ? "Repinned" : "Already pinned"} ${result.profile_id} to checkout ${result.checkout_root}`);
+    console.log(`Code fingerprint: ${result.new_code_fingerprint}`);
   } else {
     console.log(`Cloned ${result.files_copied} referenced asset file(s) into ${result.asset_root}`);
     console.log(`Receipt: ${result.receipt_path}`);