@tomflow/proflow-platform-cli 0.1.1 → 0.1.2

package/dist/src/errors.js

@@ -11,6 +11,18 @@ export const platformErrorCodes = [
     "PLAN_NOT_FOUND",
     "PLAN_INVALID",
     "WORKSPACE_LOCKED",
+    "WORKSPACE_NOT_FOUND",
+    "WORKSPACE_NOT_WRITABLE",
+    "WORKSPACE_NOT_BOUND",
+    "WORKSPACE_ALREADY_BOUND",
+    "BOUND_WORKSPACE_MISSING",
+    "WORKSPACE_INSTANCE_INVALID",
+    "GLOBAL_BINDING_INVALID",
+    "GLOBAL_BINDING_LOCKED",
+    "GLOBAL_OPERATION_LOCKED",
+    "PACKAGE_MANAGER_UNSUPPORTED",
+    "PACKAGE_MANAGER_CONFLICT",
+    "PACKAGE_MANAGER_UNAVAILABLE",
     "LIFECYCLE_UNSUPPORTED",
     "SECRET_LEAK",
     "APPLY_FAILED",

package/dist/src/install/environment.d.ts

@@ -1,5 +1,5 @@
 import { type NpmCommandRunner } from "../registry/index.ts";
-import { type SupportedWorkspacePackageManager } from "./package-manager.ts";
+import { type PackageManagerSelectionSource, type SupportedWorkspacePackageManager } from "./package-manager.ts";
 export declare const PLATFORM_INSTALL_NODE_RANGE = ">=24.19.0";
 export type InstallerPreflightStatus = "READY" | "ACTION_REQUIRED" | "BLOCKED";
 export type InstallerFindingSeverity = "info" | "action" | "error";
@@ -17,6 +17,7 @@ export interface InstallerEnvironmentPreflightResult {
     npmVersion?: string;
     packageManager?: {
         name: SupportedWorkspacePackageManager;
+        source: PackageManagerSelectionSource;
         declared?: string;
         version?: string;
     };

package/dist/src/install/environment.js

@@ -48,51 +48,55 @@ export async function preflightInstallerEnvironment(options) {
             findings.push(platformErrorFinding(error, "NPM_UNAVAILABLE"));
         }
     }
-    const packageManager = await readWorkspacePackageManagerSelection(options.workspaceRoot);
+    let packageManager;
     let packageManagerVersion;
-    if (packageManager === undefined) {
-        findings.push({
-            code: "PACKAGE_MANAGER_UNSUPPORTED",
-            severity: "action",
-            message: `unsupported packageManager declaration: ${workspace.packageManager ?? "<unknown>"}`,
-        });
-    }
-    else if (packageManager.name === "pnpm") {
-        if (!findExecutable("pnpm")) {
+    try {
+        packageManager = await readWorkspacePackageManagerSelection(options.workspaceRoot);
+        if (!findExecutable(packageManager.name)) {
             findings.push({
-                code: "PNPM_REQUIRED",
+                code: "PACKAGE_MANAGER_UNAVAILABLE",
                 severity: "action",
-                message: `workspace declares ${packageManager.declared}; install/enable pnpm before applying package changes`,
+                message: `workspace selects ${packageManager.name}, but that executable is not available on PATH`,
             });
         }
+        else if (packageManager.name === "npm" && npmVersion !== undefined) {
+            packageManagerVersion = npmVersion;
+        }
         else {
             try {
-                const result = (await systemPackageCommandRunner().run("pnpm", ["--version"], options.workspaceRoot)).trim();
-                packageManagerVersion = result;
-                findings.push({
-                    code: "PNPM_READY",
-                    severity: "info",
-                    message: `pnpm ${result} is available for this workspace`,
-                });
+                packageManagerVersion = (await systemPackageCommandRunner().run(packageManager.name, ["--version"], options.workspaceRoot)).trim();
             }
             catch (error) {
                 findings.push({
-                    code: "PNPM_REQUIRED",
+                    code: "PACKAGE_MANAGER_UNAVAILABLE",
                     severity: "action",
                     message: error instanceof Error ? error.message : String(error),
                 });
             }
         }
+        if (packageManagerVersion !== undefined) {
+            findings.push({
+                code: "PACKAGE_MANAGER_READY",
+                severity: "info",
+                message: `${packageManager.name} ${packageManagerVersion} is selected via ${packageManager.source}`,
+            });
+        }
     }
-    else if (npmVersion !== undefined) {
-        packageManagerVersion = npmVersion;
-        findings.push({
-            code: "PACKAGE_MANAGER_READY",
-            severity: "info",
-            message: packageManager.declared === undefined
-                ? "workspace does not declare packageManager; npm will be used for bootstrap package operations"
-                : `workspace declares ${packageManager.declared}`,
-        });
+    catch (error) {
+        if (error instanceof PlatformError) {
+            findings.push({
+                code: error.code,
+                severity: error.code === "PACKAGE_MANAGER_CONFLICT" ? "error" : "action",
+                message: error.message,
+            });
+        }
+        else {
+            findings.push({
+                code: "PACKAGE_MANAGER_UNAVAILABLE",
+                severity: "action",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
     }
     let registry;
     if (npmVersion !== undefined) {

package/dist/src/install/package-manager.d.ts

@@ -1,11 +1,13 @@
-export type SupportedWorkspacePackageManager = "npm" | "pnpm";
+export type SupportedWorkspacePackageManager = "npm" | "yarn" | "pnpm";
+export type PackageManagerSelectionSource = "declared" | "lockfile" | "bootstrap-default";
 export interface WorkspacePackageManagerSelection {
     name: SupportedWorkspacePackageManager;
+    source: PackageManagerSelectionSource;
     declared?: string;
 }
 export interface PackageCommandRunner {
     run(command: string, args: readonly string[], cwd: string): Promise<string>;
 }
 export declare function systemPackageCommandRunner(): PackageCommandRunner;
-export declare function readWorkspacePackageManagerSelection(workspaceRoot: string): Promise<WorkspacePackageManagerSelection | undefined>;
+export declare function readWorkspacePackageManagerSelection(workspaceRoot: string): Promise<WorkspacePackageManagerSelection>;
 export declare function findExecutable(command: string): boolean;

package/dist/src/install/package-manager.js

@@ -1,8 +1,9 @@
 import { execFile } from "node:child_process";
 import { accessSync, constants } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { access, readFile } from "node:fs/promises";
 import { delimiter, join } from "node:path";
 import { promisify } from "node:util";
+import { PlatformError } from "../errors.js";
 const execFileAsync = promisify(execFile);
 export function systemPackageCommandRunner() {
     return {
@@ -17,25 +18,27 @@ export function systemPackageCommandRunner() {
     };
 }
 export async function readWorkspacePackageManagerSelection(workspaceRoot) {
-    let declared;
-    try {
-        const raw = await readFile(join(workspaceRoot, "package.json"), "utf8");
-        const parsed = JSON.parse(raw);
-        if (isRecord(parsed) && typeof parsed.packageManager === "string") {
-            declared = parsed.packageManager;
+    const declared = await readDeclaredPackageManager(workspaceRoot);
+    const lockManagers = await detectLockfileManagers(workspaceRoot);
+    if (declared !== undefined) {
+        const name = packageManagerName(declared);
+        if (name === undefined) {
+            throw new PlatformError("PACKAGE_MANAGER_UNSUPPORTED", `unsupported packageManager declaration: ${declared}; expected npm, yarn, or pnpm`);
+        }
+        const conflicts = [...lockManagers].filter((manager) => manager !== name);
+        if (conflicts.length > 0) {
+            throw new PlatformError("PACKAGE_MANAGER_CONFLICT", `packageManager declares ${declared}, but conflicting lockfiles indicate ${conflicts.join(", ")}`);
         }
+        return { name, source: "declared", declared };
     }
-    catch {
-        // A Fresh Workspace without package.json uses npm for bootstrap. Invalid
-        // package.json is rejected earlier by installer preflight.
+    if (lockManagers.size > 1) {
+        throw new PlatformError("PACKAGE_MANAGER_CONFLICT", `multiple package-manager lockfiles are present: ${[...lockManagers].sort().join(", ")}`);
     }
-    if (declared === undefined)
-        return { name: "npm" };
-    const separator = declared.lastIndexOf("@");
-    const name = separator > 0 ? declared.slice(0, separator) : declared;
-    if (name !== "npm" && name !== "pnpm")
-        return undefined;
-    return { name, declared };
+    const [fromLockfile] = lockManagers;
+    if (fromLockfile !== undefined) {
+        return { name: fromLockfile, source: "lockfile" };
+    }
+    return { name: "npm", source: "bootstrap-default" };
 }
 export function findExecutable(command) {
     const path = process.env.PATH ?? "";
@@ -53,6 +56,59 @@ export function findExecutable(command) {
     }
     return false;
 }
+async function readDeclaredPackageManager(workspaceRoot) {
+    try {
+        const raw = await readFile(join(workspaceRoot, "package.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed)) {
+            throw new PlatformError("PACKAGE_MANAGER_CONFLICT", "workspace package.json root must be an object");
+        }
+        return typeof parsed.packageManager === "string"
+            ? parsed.packageManager
+            : undefined;
+    }
+    catch (error) {
+        if (isMissingFile(error))
+            return undefined;
+        if (error instanceof PlatformError)
+            throw error;
+        throw new PlatformError("PACKAGE_MANAGER_CONFLICT", `cannot inspect workspace package.json: ${errorMessage(error)}`);
+    }
+}
+async function detectLockfileManagers(workspaceRoot) {
+    const managers = new Set();
+    if ((await pathExists(join(workspaceRoot, "package-lock.json"))) ||
+        (await pathExists(join(workspaceRoot, "npm-shrinkwrap.json")))) {
+        managers.add("npm");
+    }
+    if (await pathExists(join(workspaceRoot, "yarn.lock")))
+        managers.add("yarn");
+    if (await pathExists(join(workspaceRoot, "pnpm-lock.yaml")))
+        managers.add("pnpm");
+    return managers;
+}
+function packageManagerName(declared) {
+    const separator = declared.lastIndexOf("@");
+    const name = separator > 0 ? declared.slice(0, separator) : declared;
+    return name === "npm" || name === "yarn" || name === "pnpm"
+        ? name
+        : undefined;
+}
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isMissingFile(error) {
+    return isRecord(error) && error.code === "ENOENT";
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/src/planner/plan.d.ts

@@ -9,6 +9,7 @@ export interface PlanInput {
     currentDescriptors?: readonly ModuleDescriptor[];
     targetDescriptors?: readonly ModuleDescriptor[];
     facts?: readonly RepairFact[];
+    uninstallScope?: "module" | "platform-instance";
     now?: Date;
 }
 export declare function planDeployment(input: PlanInput): DeploymentPlan;

package/dist/src/planner/plan.js

@@ -128,7 +128,7 @@ function planUninstall(input) {
         throw new PlatformError("INVALID_REQUEST", "uninstall requires modules");
     }
     const core = modules.find((module) => module.installClass === "core");
-    if (core !== undefined) {
+    if (core !== undefined && input.uninstallScope !== "platform-instance") {
         throw new PlatformError("CORE_PACKAGE_REQUIRED", `core module ${core.moduleRef} cannot be individually uninstalled`);
     }
     const graph = buildDependencyGraph(modules);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomflow/proflow-platform-cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -21,11 +21,11 @@
     "README.md"
   ],
   "dependencies": {
-    "@tomflow/proflow-module-contract": "^0.1.0"
+    "@tomflow/proflow-module-contract": "^0.1.1"
   },
   "devDependencies": {
-    "@tomflow/proflow-deployment-conformance": "^0.1.1",
-    "@tomflow/proflow-module-template": "^0.1.1"
+    "@tomflow/proflow-module-template": "^0.1.2",
+    "@tomflow/proflow-deployment-conformance": "^0.1.2"
   },
   "description": "Deterministic platform-level deployment discovery, planning, lifecycle and verification CLI.",
   "keywords": [

package/proflow.module.json

@@ -3,7 +3,7 @@
 	"contractVersion": "1.0.0",
 	"moduleRef": "platform-cli",
 	"packageName": "@tomflow/proflow-platform-cli",
-	"moduleVersion": "0.1.1",
+	"moduleVersion": "0.1.2",
 	"kind": "cli",
 	"templateVersion": "1.0.0",
 	"platformCompatibility": ">=1.0.0 <2.0.0",