@tomflow/proflow-platform-cli 0.1.0

package/dist/src/contracts.d.ts

@@ -0,0 +1,113 @@
+import type { ConfigSlot, DeploymentEffect, HumanAction, ModuleDescriptor, ModuleRequirement } from "@tomflow/proflow-module-contract";
+export type DeploymentIntent = "install" | "configure" | "upgrade" | "uninstall" | "repair";
+export interface ModuleTarget {
+    moduleRef: string;
+    targetVersion?: string;
+    config?: Record<string, string>;
+}
+export interface ResolvedModule {
+    moduleRef: string;
+    packageName: string;
+    moduleVersion: string;
+    kind: ModuleDescriptor["kind"] | "registry-package";
+    installClass: ModuleDescriptor["installClass"];
+    identity?: ModuleDescriptor["identity"];
+    documentation: ModuleDescriptor["documentation"];
+    provides: ModuleDescriptor["provides"];
+    requires: ModuleDescriptor["requires"];
+    requirements: ModuleRequirement[];
+    configSlots: ConfigSlot[];
+    lifecycle: string[];
+    verification: ModuleDescriptor["verification"];
+    effects: DeploymentEffect[];
+    source: {
+        type: "workspace" | "installed" | "registry";
+        path?: string;
+    };
+}
+export interface DeploymentStep {
+    stepRef: string;
+    moduleRef: string;
+    kind: "config" | "package" | "lifecycle" | "external-resource" | "human";
+    preconditions: string[];
+    expectedEffect: string;
+    checkStrategy: string;
+    executeStrategy?: string;
+    postcondition: string;
+}
+export interface VerificationStep {
+    moduleRef: string;
+    checks: string[];
+}
+export interface DeploymentPlan {
+    planRef: string;
+    intent: DeploymentIntent;
+    moduleTargets: ModuleTarget[];
+    resolvedModules: ResolvedModule[];
+    targetDescriptors?: ModuleDescriptor[];
+    steps: DeploymentStep[];
+    effects: DeploymentEffect[];
+    humanActions: HumanAction[];
+    verification: VerificationStep[];
+    fingerprint: string;
+    createdAt: string;
+}
+export interface VerificationRecord {
+    verificationRef: string;
+    moduleRef: string;
+    moduleVersion: string;
+    resourceIdentity?: string;
+    resourceVersion?: string;
+    result: "PASS" | "FAIL";
+    summary: string;
+    evidenceRefs: string[];
+    verifiedAt: string;
+}
+export type PlatformState = "READY" | "DEGRADED" | "ACTION_REQUIRED" | "NOT_READY";
+export interface SelectedModuleFact {
+    moduleRef: string;
+    moduleVersion: string;
+}
+export interface DeploymentState {
+    contract: "proflow.deployment-state.v1";
+    selectedModules: SelectedModuleFact[];
+    lastAppliedPlans: {
+        planRef: string;
+        intent: DeploymentIntent;
+        appliedAt: string;
+    }[];
+    verificationIndex: {
+        moduleRef: string;
+        latestRef: string;
+    }[];
+    pendingActions: PendingActionRecord[];
+    updatedAt: string;
+}
+export interface PendingActionRecord {
+    planRef: string;
+    stepRef: string;
+    moduleRef: string;
+    action: string;
+    description?: string;
+    createdAt: string;
+}
+export interface LockRecord {
+    pid: number;
+    createdAt: string;
+    planRef: string;
+    workspaceFingerprint: string;
+}
+export type ApplyStepStatus = "SKIP" | "EXECUTED" | "ACTION_REQUIRED" | "FAILED";
+export interface ApplyStepResult {
+    stepRef: string;
+    moduleRef: string;
+    status: ApplyStepStatus;
+    message: string;
+}
+export type ApplyOutcome = "COMPLETE" | "ACTION_REQUIRED" | "FAILED" | "BLOCKED";
+export interface ApplyResult {
+    planRef: string;
+    outcome: ApplyOutcome;
+    stepResults: ApplyStepResult[];
+    completedAt: string;
+}

package/dist/src/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/src/discovery/catalog.d.ts

@@ -0,0 +1,10 @@
+import type { ModuleCatalog, ModuleSource } from "../modules.ts";
+export declare class WorkspaceModuleCatalog implements ModuleCatalog {
+    readonly root: string;
+    constructor(root?: string);
+    sources(): Promise<ModuleSource[]>;
+    loadDescriptor(source: ModuleSource): Promise<unknown>;
+    loadAdapter(source: ModuleSource): Promise<unknown>;
+    private loadModule;
+    private resolveUrl;
+}

package/dist/src/discovery/catalog.js

@@ -0,0 +1,76 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { proflowPackageMetadataSchema } from "@tomflow/proflow-module-contract";
+import { PlatformError } from "../errors.js";
+import { expandPackageDirs, findWorkspaceRoot, hasDeploymentArtifacts, readPackageJson, readWorkspaceGlobs, } from "./workspace.js";
+export class WorkspaceModuleCatalog {
+    root;
+    constructor(root) {
+        this.root = root ?? findWorkspaceRoot();
+    }
+    async sources() {
+        const globs = await readWorkspaceGlobs(this.root);
+        const directories = await expandPackageDirs(this.root, globs);
+        const sources = [];
+        for (const directory of directories) {
+            if (!hasDeploymentArtifacts(directory))
+                continue;
+            const packageJson = await readPackageJson(directory);
+            if (packageJson.name === undefined)
+                continue;
+            if (!packageJson.name.startsWith("@tomflow/proflow-"))
+                continue;
+            if (!proflowPackageMetadataSchema.safeParse(packageJson.proflow).success)
+                continue;
+            sources.push({
+                type: "workspace",
+                packageName: packageJson.name,
+                path: directory,
+            });
+        }
+        return sources;
+    }
+    async loadDescriptor(source) {
+        const namespace = await this.loadModule(source, "descriptor");
+        const descriptor = namespace.descriptor;
+        if (descriptor === undefined) {
+            throw new PlatformError("DESCRIPTOR_INVALID", `deployment descriptor export missing for ${source.packageName}`);
+        }
+        return descriptor;
+    }
+    async loadAdapter(source) {
+        return this.loadModule(source, "adapter");
+    }
+    async loadModule(source, artifact) {
+        let url;
+        try {
+            url = this.resolveUrl(source, artifact);
+            const namespace = await import(__rewriteRelativeImportExtension(url));
+            return namespace;
+        }
+        catch (error) {
+            throw new PlatformError("DESCRIPTOR_INVALID", `failed to load ${artifact} for ${source.packageName}: ${errorMessage(error)}`);
+        }
+    }
+    resolveUrl(source, artifact) {
+        if (source.type === "workspace") {
+            if (source.path === undefined) {
+                throw new PlatformError("DESCRIPTOR_INVALID", `workspace source missing path for ${source.packageName}`);
+            }
+            return pathToFileURL(join(source.path, "deployment", `${artifact}.ts`))
+                .href;
+        }
+        return import.meta.resolve(`${source.packageName}/deployment/${artifact}`);
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/src/discovery/discover.d.ts

@@ -0,0 +1,19 @@
+import type { DeploymentAdapterBinding } from "../binding/production-bindings.ts";
+import type { ResolvedModule } from "../contracts.ts";
+import type { ModuleCatalog, ModuleSource } from "../modules.ts";
+export interface DiscoverOptions {
+    workspaceRoot?: string;
+    catalog?: ModuleCatalog;
+    sources?: ModuleSource[];
+}
+export declare class AutoModuleCatalog implements ModuleCatalog {
+    private readonly workspace;
+    private readonly installed;
+    private readonly bindings;
+    constructor(root?: string, bindings?: ReadonlyMap<string, DeploymentAdapterBinding>);
+    sources(): Promise<ModuleSource[]>;
+    loadDescriptor(source: ModuleSource): Promise<unknown>;
+    loadAdapter(source: ModuleSource): Promise<unknown>;
+}
+export declare function discoverModules(options?: DiscoverOptions): Promise<ResolvedModule[]>;
+export declare function resolveModules(catalog: Pick<ModuleCatalog, "loadDescriptor">, sources: readonly ModuleSource[]): Promise<ResolvedModule[]>;

package/dist/src/discovery/discover.js

@@ -0,0 +1,124 @@
+import { parseModuleDescriptor, } from "@tomflow/proflow-module-contract";
+import { PlatformError } from "../errors.js";
+import { WorkspaceModuleCatalog } from "./catalog.js";
+import { InstalledModuleCatalog } from "./installed.js";
+import { readPackageJson } from "./workspace.js";
+// Workspace sources win over installed dependencies on a packageName collision.
+export class AutoModuleCatalog {
+    workspace;
+    installed;
+    bindings;
+    constructor(root, bindings) {
+        this.workspace = new WorkspaceModuleCatalog(root);
+        this.installed = new InstalledModuleCatalog(root);
+        this.bindings = bindings ?? new Map();
+    }
+    async sources() {
+        const workspaceSources = await this.workspace.sources();
+        const installedSources = await this.installed.sources();
+        const merged = [...workspaceSources];
+        const seen = new Set(workspaceSources.map((source) => source.packageName));
+        for (const source of installedSources) {
+            if (seen.has(source.packageName))
+                continue;
+            seen.add(source.packageName);
+            merged.push(source);
+        }
+        return merged;
+    }
+    async loadDescriptor(source) {
+        return source.type === "workspace"
+            ? this.workspace.loadDescriptor(source)
+            : this.installed.loadDescriptor(source);
+    }
+    async loadAdapter(source) {
+        // A production binder may supply a bound adapter for a service module
+        // (createBehaviorAdapter(realService)); it wins over the unbound default.
+        const binding = this.bindings.get(source.packageName);
+        if (binding !== undefined)
+            return binding;
+        return source.type === "workspace"
+            ? this.workspace.loadAdapter(source)
+            : this.installed.loadAdapter(source);
+    }
+}
+export async function discoverModules(options = {}) {
+    const catalog = options.catalog ?? new AutoModuleCatalog(options.workspaceRoot);
+    const sources = options.sources ?? (await catalog.sources());
+    return resolveModules(catalog, sources);
+}
+export async function resolveModules(catalog, sources) {
+    const modules = [];
+    for (const source of sources) {
+        modules.push(await resolveModule(catalog, source));
+    }
+    enforceIdentityInvariants(modules);
+    return modules;
+}
+async function resolveModule(catalog, source) {
+    let raw;
+    try {
+        raw = await catalog.loadDescriptor(source);
+    }
+    catch (error) {
+        if (error instanceof PlatformError)
+            throw error;
+        throw new PlatformError("DESCRIPTOR_INVALID", `failed to load descriptor for ${source.packageName}: ${errorMessage(error)}`);
+    }
+    let descriptor;
+    try {
+        descriptor = parseModuleDescriptor(raw);
+    }
+    catch (error) {
+        throw new PlatformError("DESCRIPTOR_INVALID", `invalid descriptor for ${source.packageName}: ${errorMessage(error)}`);
+    }
+    if (source.type === "workspace" && source.path !== undefined) {
+        const packageJson = await readPackageJson(source.path);
+        if (packageJson.version !== undefined &&
+            packageJson.version !== descriptor.moduleVersion) {
+            throw new PlatformError("DESCRIPTOR_INVALID", `moduleVersion ${descriptor.moduleVersion} does not match package.json version ${packageJson.version} for ${descriptor.moduleRef}`);
+        }
+    }
+    return toResolvedModule(descriptor, source);
+}
+function toResolvedModule(descriptor, source) {
+    const resolvedSource = source.path === undefined
+        ? { type: source.type }
+        : { type: source.type, path: source.path };
+    return {
+        moduleRef: descriptor.moduleRef,
+        packageName: descriptor.packageName,
+        moduleVersion: descriptor.moduleVersion,
+        kind: descriptor.kind,
+        installClass: descriptor.installClass,
+        identity: descriptor.identity,
+        documentation: descriptor.documentation,
+        provides: descriptor.provides,
+        requires: descriptor.requires,
+        requirements: descriptor.requirements,
+        configSlots: descriptor.configSlots,
+        lifecycle: descriptor.lifecycle.supported,
+        verification: descriptor.verification,
+        effects: descriptor.effects,
+        source: resolvedSource,
+    };
+}
+function enforceIdentityInvariants(modules) {
+    const byRef = new Map();
+    const byPackage = new Map();
+    for (const module of modules) {
+        const existingRef = byRef.get(module.moduleRef);
+        if (existingRef !== undefined) {
+            throw new PlatformError("DUPLICATE_IDENTITY", `duplicate moduleRef "${module.moduleRef}" (${existingRef} and ${module.packageName})`);
+        }
+        const existingPackage = byPackage.get(module.packageName);
+        if (existingPackage !== undefined) {
+            throw new PlatformError("DUPLICATE_IDENTITY", `duplicate packageName "${module.packageName}" (${existingPackage} and ${module.moduleRef})`);
+        }
+        byRef.set(module.moduleRef, module.packageName);
+        byPackage.set(module.packageName, module.moduleRef);
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/src/discovery/index.d.ts

@@ -0,0 +1,5 @@
+export { WorkspaceModuleCatalog } from "./catalog.ts";
+export type { DiscoverOptions } from "./discover.ts";
+export { AutoModuleCatalog, discoverModules, resolveModules, } from "./discover.ts";
+export { InstalledModuleCatalog } from "./installed.ts";
+export { expandPackageDirs, findWorkspaceRoot, hasDeploymentArtifacts, readWorkspaceGlobs, } from "./workspace.ts";

package/dist/src/discovery/index.js

@@ -0,0 +1,4 @@
+export { WorkspaceModuleCatalog } from "./catalog.js";
+export { AutoModuleCatalog, discoverModules, resolveModules, } from "./discover.js";
+export { InstalledModuleCatalog } from "./installed.js";
+export { expandPackageDirs, findWorkspaceRoot, hasDeploymentArtifacts, readWorkspaceGlobs, } from "./workspace.js";

package/dist/src/discovery/installed.d.ts

@@ -0,0 +1,21 @@
+import type { ModuleCatalog, ModuleSource } from "../modules.ts";
+/**
+ * Discovers governed modules installed as ordinary npm dependencies of a
+ * product workspace. It never scans the global npm cache, queries a registry,
+ * or walks `node_modules` — it only inspects the package names explicitly
+ * declared in the root `package.json` `dependencies`/`devDependencies`, and
+ * only treats a package as a governed Module when both its
+ * `deployment/descriptor` and `deployment/adapter` subpath exports actually
+ * resolve through Node package resolution.
+ */
+export declare class InstalledModuleCatalog implements ModuleCatalog {
+    readonly root: string;
+    private readonly require;
+    constructor(root?: string);
+    sources(): Promise<ModuleSource[]>;
+    loadDescriptor(source: ModuleSource): Promise<unknown>;
+    loadAdapter(source: ModuleSource): Promise<unknown>;
+    private isGovernedModule;
+    private canResolve;
+    private loadModule;
+}

package/dist/src/discovery/installed.js

@@ -0,0 +1,130 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { proflowPackageMetadataSchema } from "@tomflow/proflow-module-contract";
+import { PlatformError } from "../errors.js";
+import { findWorkspaceRoot } from "./workspace.js";
+async function readRootPackageJson(root) {
+    try {
+        const raw = await readFile(join(root, "package.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null)
+            return {};
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Discovers governed modules installed as ordinary npm dependencies of a
+ * product workspace. It never scans the global npm cache, queries a registry,
+ * or walks `node_modules` — it only inspects the package names explicitly
+ * declared in the root `package.json` `dependencies`/`devDependencies`, and
+ * only treats a package as a governed Module when both its
+ * `deployment/descriptor` and `deployment/adapter` subpath exports actually
+ * resolve through Node package resolution.
+ */
+export class InstalledModuleCatalog {
+    root;
+    require;
+    constructor(root) {
+        this.root = root ?? findWorkspaceRoot();
+        this.require = createRequire(pathToFileURL(join(this.root, "package.json")));
+    }
+    async sources() {
+        const manifest = await readRootPackageJson(this.root);
+        const names = new Set();
+        for (const name of Object.keys(manifest.dependencies ?? {})) {
+            names.add(name);
+        }
+        for (const name of Object.keys(manifest.devDependencies ?? {})) {
+            names.add(name);
+        }
+        const sources = [];
+        for (const name of [...names].sort()) {
+            if (!(await this.isGovernedModule(name)))
+                continue;
+            sources.push({ type: "installed", packageName: name });
+        }
+        return sources;
+    }
+    async loadDescriptor(source) {
+        const namespace = await this.loadModule(source, "descriptor");
+        const descriptor = namespace.descriptor;
+        if (descriptor === undefined) {
+            throw new PlatformError("DESCRIPTOR_INVALID", `deployment descriptor export missing for ${source.packageName}`);
+        }
+        return descriptor;
+    }
+    async loadAdapter(source) {
+        return this.loadModule(source, "adapter");
+    }
+    async isGovernedModule(packageName) {
+        if (!packageName.startsWith("@tomflow/proflow-"))
+            return false;
+        if (!this.canResolve(`${packageName}/deployment/descriptor`) ||
+            !this.canResolve(`${packageName}/deployment/adapter`)) {
+            return false;
+        }
+        const descriptorPath = this.require.resolve(`${packageName}/deployment/descriptor`);
+        const packageJson = await readInstalledPackageJson(descriptorPath, packageName);
+        if (packageJson === undefined)
+            return false;
+        return proflowPackageMetadataSchema.safeParse(packageJson.proflow).success;
+    }
+    canResolve(specifier) {
+        try {
+            this.require.resolve(specifier);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async loadModule(source, artifact) {
+        try {
+            const resolved = this.require.resolve(`${source.packageName}/deployment/${artifact}`);
+            return await import(__rewriteRelativeImportExtension(pathToFileURL(resolved).href));
+        }
+        catch (error) {
+            throw new PlatformError("DESCRIPTOR_INVALID", `failed to load ${artifact} for ${source.packageName}: ${errorMessage(error)}`);
+        }
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function readInstalledPackageJson(resolvedArtifact, packageName) {
+    let current = dirname(resolvedArtifact);
+    for (;;) {
+        try {
+            const raw = await readFile(join(current, "package.json"), "utf8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed === "object" &&
+                parsed !== null &&
+                !Array.isArray(parsed) &&
+                Reflect.get(parsed, "name") === packageName) {
+                return parsed;
+            }
+        }
+        catch {
+            // Keep walking towards the package root. Export maps commonly hide
+            // package.json, so resolving the descriptor and walking upward is the
+            // stable local-install boundary.
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}

package/dist/src/discovery/workspace.d.ts

@@ -0,0 +1,10 @@
+export declare function findWorkspaceRoot(fromUrl?: string): string;
+export declare function readWorkspaceGlobs(root: string): Promise<string[]>;
+export declare function expandPackageDirs(root: string, globs: readonly string[]): Promise<string[]>;
+export declare function hasDeploymentArtifacts(dir: string): boolean;
+export interface PackageJson {
+    name?: string;
+    version?: string;
+    proflow?: unknown;
+}
+export declare function readPackageJson(dir: string): Promise<PackageJson>;

package/dist/src/discovery/workspace.js

@@ -0,0 +1,155 @@
+import { existsSync } from "node:fs";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { PlatformError } from "../errors.js";
+const PRUNE_DIRS = new Set([
+    "node_modules",
+    ".git",
+    ".proflow",
+    "dist",
+    ".omo",
+    ".codegraph",
+]);
+export function findWorkspaceRoot(fromUrl = import.meta.url) {
+    let dir = dirname(fileURLToPath(fromUrl));
+    for (;;) {
+        if (existsSync(join(dir, "pnpm-workspace.yaml")))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir) {
+            throw new PlatformError("INVALID_REQUEST", "pnpm-workspace.yaml not found in any parent directory");
+        }
+        dir = parent;
+    }
+}
+export async function readWorkspaceGlobs(root) {
+    const file = join(root, "pnpm-workspace.yaml");
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const globs = [];
+    let inPackages = false;
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed === "" || trimmed.startsWith("#"))
+            continue;
+        if (/^packages\s*:/.test(trimmed)) {
+            inPackages = true;
+            const inline = /^packages\s*:\s*\[(.*)\]$/.exec(trimmed);
+            if (inline !== null) {
+                const body = inline[1] ?? "";
+                for (const match of body.matchAll(/"([^"]*)"|'([^']*)'/g)) {
+                    const value = match[1] ?? match[2];
+                    if (value !== undefined && value !== "")
+                        globs.push(value);
+                }
+                inPackages = false;
+            }
+            continue;
+        }
+        if (!inPackages)
+            continue;
+        if (!/^\s/.test(line) && !trimmed.startsWith("-")) {
+            inPackages = false;
+            continue;
+        }
+        const match = /^\s*-\s*(?:"([^"]*)"|'([^']*)'|([^\s#]+))/.exec(line);
+        if (match !== null) {
+            const value = match[1] ?? match[2] ?? match[3];
+            if (value !== undefined)
+                globs.push(value);
+        }
+    }
+    return globs;
+}
+function globToRegExp(glob) {
+    const segments = glob.split("/");
+    let pattern = "^";
+    for (let index = 0; index < segments.length; index += 1) {
+        if (index > 0)
+            pattern += "/";
+        const segment = segments[index] ?? "";
+        if (segment === "**") {
+            pattern += ".*";
+            continue;
+        }
+        pattern += segment
+            .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+            .replace(/\*\*/g, ".*")
+            .replace(/\*/g, "[^/]*")
+            .replace(/\?/g, "[^/]");
+    }
+    pattern += "$";
+    return new RegExp(pattern);
+}
+function globStaticPrefix(glob) {
+    const magic = glob.search(/[*?[\]]/);
+    if (magic === -1)
+        return glob;
+    const prefix = glob.slice(0, magic);
+    const lastSlash = prefix.lastIndexOf("/");
+    if (lastSlash === -1)
+        return ".";
+    const base = prefix.slice(0, lastSlash);
+    return base === "" ? "/" : base;
+}
+async function walkMatchingDirs(base, root, regex) {
+    const found = [];
+    const entries = await readdir(base, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (PRUNE_DIRS.has(entry.name))
+            continue;
+        const full = join(base, entry.name);
+        const rel = relative(root, full).split(sep).join("/");
+        if (regex.test(rel))
+            found.push(full);
+        found.push(...(await walkMatchingDirs(full, root, regex)));
+    }
+    return found;
+}
+export async function expandPackageDirs(root, globs) {
+    const found = new Set();
+    for (const rawGlob of globs) {
+        const glob = rawGlob.replace(/\\/g, "/").replace(/^\.\//, "");
+        if (glob === "")
+            continue;
+        if (!/[*?[\]]/.test(glob)) {
+            const absolute = resolve(root, glob);
+            try {
+                const info = await stat(absolute);
+                if (info.isDirectory())
+                    found.add(absolute);
+            }
+            catch {
+                // ignore missing literal paths
+            }
+            continue;
+        }
+        const regex = globToRegExp(glob);
+        const base = resolve(root, globStaticPrefix(glob));
+        for (const dir of await walkMatchingDirs(base, root, regex)) {
+            found.add(dir);
+        }
+    }
+    return [...found].sort();
+}
+export function hasDeploymentArtifacts(dir) {
+    return (existsSync(join(dir, "deployment", "descriptor.ts")) &&
+        existsSync(join(dir, "deployment", "adapter.ts")));
+}
+export async function readPackageJson(dir) {
+    try {
+        const raw = await readFile(join(dir, "package.json"), "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}