@mean-weasel/lineage 0.1.16 → 0.1.17

package/dist/cli/lineage.js

@@ -645,6 +645,7 @@ import { dirname as dirname3, isAbsolute, join as join4, relative as relative2,
 
 // src/shared/lineageProfileTypes.ts
 var lineageProfileSchemaVersion = "lineage.profile.v1";
+var lineageProfileInitSchemaVersion = "lineage.profile_init.v1";
 var lineageProfileDoctorSchemaVersion = "lineage.profile_doctor.v1";
 var lineageProfileCloneReceiptSchemaVersion = "lineage.profile_clone_receipt.v1";
 var lineageProfileAssetsCloneReceiptSchemaVersion = "lineage.profile_assets_clone_receipt.v1";
@@ -793,6 +794,120 @@ function lineageProfileFingerprint(profile) {
     service_origin: profile.service_origin
   })).digest("hex");
 }
+function initializeLineageProfile(profileId, serviceOrigin, runtime, confirmWrite, withWriterLease) {
+  if (!confirmWrite) throw new Error("Profile init requires --confirm-write");
+  if (!profileIdPattern.test(profileId)) throw new Error(`Invalid profile ID: ${profileId}`);
+  if (!runtime.code?.verified) throw new Error("Profile init requires a verified runtime code identity");
+  if (runtime.code.origin !== "checkout" && runtime.code.origin !== "package") {
+    throw new Error(`Profile init requires checkout or package code, not ${runtime.code.origin}`);
+  }
+  if (!runtime.code.fingerprint || !/^[a-f0-9]{64}$/i.test(runtime.code.fingerprint)) {
+    throw new Error("Profile init requires a valid executing code fingerprint");
+  }
+  const validatedServiceOrigin = validateServiceOrigin(serviceOrigin);
+  const root = lineageProfileRoot();
+  mkdirSync3(root, { recursive: true, mode: 448 });
+  const profileDirectory = join4(root, profileId);
+  try {
+    mkdirSync3(profileDirectory, { mode: 448 });
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "EEXIST") {
+      const doctor = doctorLineageProfile(profileId, runtime);
+      if (doctor.ok) {
+        throw new Error(`Profile ${profileId} already exists and passes doctor. No files were changed. Reuse it with \`start --profile ${profileId}\`; verify it first with \`profile doctor --profile ${profileId} --json\`.`, { cause: error });
+      }
+      const failures = doctor.checks.filter((check) => check.status === "fail").map((check) => `${check.id}: ${check.message}`).join("; ");
+      throw new Error(`Profile ${profileId} already exists but did not pass doctor. No files were changed. Run \`profile doctor --profile ${profileId} --json\`, then inspect ${profileDirectory} manually before retrying. ${failures}`, { cause: error });
+    }
+    throw error;
+  }
+  const manifestPath = join4(profileDirectory, "profile.json");
+  const databasePath = join4(profileDirectory, "lineage.sqlite");
+  const assetRoot = join4(profileDirectory, "media");
+  const environment = channelEnvironment(runtime.channel);
+  const manifest = {
+    asset_root: assetRoot,
+    database_path: databasePath,
+    environment,
+    expected_runtime: {
+      channel: runtime.channel,
+      code_fingerprint: runtime.code.fingerprint.toLowerCase(),
+      code_origin: runtime.code.origin
+    },
+    profile_id: profileId,
+    schema_version: lineageProfileSchemaVersion,
+    service_origin: validatedServiceOrigin
+  };
+  const profile = {
+    ...manifest,
+    manifest_path: manifestPath,
+    profile_fingerprint: lineageProfileFingerprint(manifest)
+  };
+  try {
+    assertProfileChannel(profile, runtime.channel);
+    assertProfileRuntimePin(profile, runtime);
+    const identity = withWriterLease(profile, () => {
+      mkdirSync3(assetRoot, { mode: 448 });
+      const databaseFd = openSync(databasePath, fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_RDWR, 384);
+      closeSync(databaseFd);
+      const { DatabaseSync } = require2("node:sqlite");
+      const database = new DatabaseSync(databasePath);
+      let boundIdentity;
+      try {
+        boundIdentity = bindOpenDatabase(database, profile, false);
+      } finally {
+        database.close();
+      }
+      const manifestPayload = {
+        asset_root: "./media",
+        database_path: "./lineage.sqlite",
+        environment: profile.environment,
+        expected_runtime: profile.expected_runtime,
+        profile_id: profile.profile_id,
+        schema_version: profile.schema_version,
+        service_origin: profile.service_origin
+      };
+      writeFileSync2(manifestPath, `${JSON.stringify(manifestPayload, null, 2)}
+`, { encoding: "utf8", flag: "wx", mode: 384 });
+      const manifestFd = openSync(manifestPath, "r");
+      try {
+        fsyncSync(manifestFd);
+      } finally {
+        closeSync(manifestFd);
+      }
+      const directoryFd = openSync(profileDirectory, "r");
+      try {
+        fsyncSync(directoryFd);
+      } finally {
+        closeSync(directoryFd);
+      }
+      const published = resolveLineageProfile(profileId);
+      if (published.profile_fingerprint !== profile.profile_fingerprint) {
+        throw new Error("Initialized profile fingerprint does not match its published manifest");
+      }
+      return boundIdentity;
+    });
+    return {
+      asset_root: profile.asset_root,
+      database_path: profile.database_path,
+      environment: profile.environment,
+      identity,
+      manifest_path: profile.manifest_path,
+      profile_fingerprint: profile.profile_fingerprint,
+      profile_id: profile.profile_id,
+      runtime: {
+        channel: runtime.channel,
+        code_fingerprint: runtime.code.fingerprint,
+        code_origin: runtime.code.origin
+      },
+      schema_version: lineageProfileInitSchemaVersion,
+      service_origin: profile.service_origin
+    };
+  } catch (error) {
+    rmSync(profileDirectory, { force: true, recursive: true });
+    throw error;
+  }
+}
 function sha256(value) {
   return createHash2("sha256").update(value).digest("hex");
 }
@@ -1524,7 +1639,7 @@ function acquireProfileWriterLease(profile, channel, role = "service") {
 }
 function assertProfileWriterLeaseHeld() {
   if (!process.env.LINEAGE_PROFILE) {
-    throw new Error("Persistent writes require a selected named Lineage profile and its writer lease; legacy-unbound access is read-only");
+    throw new Error("Persistent writes require a selected named Lineage profile and its writer lease; legacy-unbound access is read-only. Create a fresh profile with `profile init --profile <id> --confirm-write`, then pass that profile to the command");
   }
   const profileId = process.env.LINEAGE_PROFILE_ID;
   const profileFingerprint = process.env.LINEAGE_PROFILE_FINGERPRINT;
@@ -5785,6 +5900,9 @@ function getLineageRuntimeInfo(options = {}) {
   const code = options.code || getLineageCodeIdentity(channel);
   const databaseInfo = { exists: existsSync10(dbPath), path: dbPath };
   const schema = { migration_keys: [] };
+  const serviceInstanceId = process.env.LINEAGE_SERVICE_INSTANCE_ID;
+  const launcherPid = process.env.LINEAGE_LAUNCHER_PID ? Number(process.env.LINEAGE_LAUNCHER_PID) : void 0;
+  const isServiceProcess = Boolean(serviceInstanceId && Number.isInteger(launcherPid) && launcherPid > 0);
   if (databaseInfo.exists) {
     try {
       const stat = statSync6(dbPath);
@@ -5822,14 +5940,22 @@ function getLineageRuntimeInfo(options = {}) {
     git_sha: code.git_sha,
     node_env: process.env.NODE_ENV,
     package_name: info.name,
-    profile: runtimeProfileIdentity(channel),
-    schema,
-    service: {
-      instance_id: process.env.LINEAGE_SERVICE_INSTANCE_ID,
-      launcher_pid: process.env.LINEAGE_LAUNCHER_PID ? Number(process.env.LINEAGE_LAUNCHER_PID) : void 0,
+    process: {
       pid: process.pid,
+      role: isServiceProcess ? "service" : "command",
       started_at: processStartedAt
     },
+    profile: runtimeProfileIdentity(channel),
+    schema,
+    ...isServiceProcess ? {
+      service: {
+        instance_id: serviceInstanceId,
+        launcher_pid: launcherPid,
+        mode: process.env.LINEAGE_SERVICE_MODE === "managed" ? "managed" : "foreground",
+        pid: process.pid,
+        started_at: processStartedAt
+      }
+    } : {},
     version: info.version
   };
 }
@@ -5983,6 +6109,9 @@ function parentFilesOption(value) {
   return mappings;
 }
 function resolveStartOptions(config, args) {
+  if (!profileSelector(args)) {
+    throw new Error("Start requires --profile or LINEAGE_PROFILE. Create one with `profile init --profile <id> --confirm-write`, then start again with that profile");
+  }
   const profile = prepareCliProfile(config, args);
   const serviceUrl = profile ? new URL(profile.service_origin) : void 0;
   const rawPort = readOption(args, "--port") || process.env.PORT || serviceUrl?.port || String(config.defaultPort);
@@ -6062,7 +6191,8 @@ function formatLineageHelp(config) {
   return `${config.binName} ${packageVersion()}
 
 Usage:
-  ${config.binName} start [--profile <id-or-manifest>] [--port <port>] [--host <host>] [--db <path>] [--asset-root <path>] [--open] [--json]
+  ${config.binName} start --profile <id-or-manifest> [--open] [--json]
+  ${config.binName} profile init --profile <new-profile-id> [--service-origin <http-origin>] --confirm-write [--json]
   ${config.binName} profile doctor --profile <id-or-manifest> [--json]
   ${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]
@@ -6503,6 +6633,25 @@ function runLineageDbCommand(config, command, args) {
 function runLineageProfileCommand(config, command, args) {
   const runtime = getLineageRuntimeInfo({ channel: config.channel });
   const runtimeIdentity = { channel: config.channel, code: runtime.code, gitSha: runtime.git_sha, version: runtime.version };
+  if (command === "init") {
+    if (hasOption(args, "--db")) throw new Error("Profile init cannot be combined with --db");
+    if (hasOption(args, "--asset-root")) throw new Error("Profile init cannot be combined with --asset-root");
+    if (!args.includes("--confirm-write")) throw new Error("Profile init requires --confirm-write");
+    const profileId = readOption(args, "--profile");
+    if (!profileId) throw new Error("lineage profile init requires --profile");
+    if (process.env.LINEAGE_PROFILE && process.env.LINEAGE_PROFILE !== profileId) {
+      throw new Error("Profile init requires an explicit --profile that does not conflict with LINEAGE_PROFILE");
+    }
+    const serviceOrigin = readOption(args, "--service-origin") || `http://${config.defaultHost}:${config.defaultPort}`;
+    return initializeLineageProfile(profileId, serviceOrigin, runtimeIdentity, true, (profile, initialize) => {
+      const writerLease = acquireProfileWriterLease(profile, config.channel, "cli");
+      try {
+        return initialize();
+      } finally {
+        writerLease.release();
+      }
+    });
+  }
   if (command === "clone") {
     const source = readOption(args, "--source-db");
     const target = readOption(args, "--target-profile");
@@ -6561,7 +6710,10 @@ function printProfileResult(result, json) {
     console.log(JSON.stringify(result, null, 2));
     return;
   }
-  if (result.schema_version === "lineage.profile_doctor.v1") {
+  if (result.schema_version === "lineage.profile_init.v1") {
+    console.log(`Initialized ${result.profile_id} at ${result.manifest_path}`);
+    console.log(`Service: ${result.service_origin}`);
+  } else if (result.schema_version === "lineage.profile_doctor.v1") {
     console.log(`Profile doctor: ${result.ok ? "ok" : "failed"}`);
     for (const check of result.checks) console.log(`${check.status.toUpperCase()} ${check.id}: ${check.message}`);
   } else if (result.schema_version === "lineage.profile_bind.v1") {
@@ -6792,7 +6944,6 @@ function start(config, args) {
   } else {
     console.log(`${config.displayName} starting at ${url}`);
     if (options.profile) console.log(`Profile: ${options.profile.profile_id} (${options.profile.environment})`);
-    else console.warn("Warning: legacy-unbound runtime; database and asset paths are not protected by a named profile.");
     console.log(`SQLite: ${options.dbPath}`);
     console.log(`Assets: ${options.assetRoot}`);
   }
@@ -6805,7 +6956,7 @@ function start(config, args) {
       LINEAGE_ASSET_ROOT: options.assetRoot,
       LINEAGE_CHANNEL: config.channel,
       LINEAGE_DB: options.dbPath,
-      LINEAGE_PROFILE: options.profile ? process.env.LINEAGE_PROFILE : void 0,
+      LINEAGE_PROFILE: process.env.LINEAGE_PROFILE,
       LINEAGE_PROFILE_ENVIRONMENT: options.profile?.environment,
       LINEAGE_PROFILE_FINGERPRINT: options.profile?.profile_fingerprint,
       LINEAGE_PROFILE_ID: options.profile?.profile_id,
@@ -6813,7 +6964,7 @@ function start(config, args) {
       LINEAGE_PROFILE_SERVICE_ORIGIN: options.profile?.service_origin,
       LINEAGE_LAUNCHER_PID: String(process.pid),
       LINEAGE_SERVICE_INSTANCE_ID: serviceInstanceId,
-      LINEAGE_DB_ACCESS: options.profile ? void 0 : "read-only",
+      LINEAGE_DB_ACCESS: void 0,
       NODE_ENV: "production",
       PORT: String(options.port)
     },
@@ -6933,7 +7084,7 @@ async function runLineageCli(config, args = process.argv.slice(2)) {
         process.env.LINEAGE_DB_ACCESS = "read-only";
       }
     } else if (requiresWriter) {
-      throw new Error("Persistent writes require --profile; legacy-unbound access is read-only");
+      throw new Error("Persistent writes require --profile; legacy-unbound access is read-only. Create a fresh profile with `profile init --profile <id> --confirm-write`, then pass that profile to the command");
     } else {
       process.env.LINEAGE_DB_ACCESS = "read-only";
     }