@doubledigit/cli 0.1.0

package/dist/lib/validators.js

@@ -0,0 +1,435 @@
+/**
+ * Pre-install validation checks for `dd install`.
+ *
+ * Validates local directory conflicts, remote repository existence,
+ * downloaded package structure, and slug prefix collisions before
+ * (or just after) downloading from GitHub.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveGitHubToken } from './github-auth.js';
+function ok(warnings = []) {
+    return { valid: true, errors: [], warnings };
+}
+function fail(errors, warnings = []) {
+    return { valid: false, errors, warnings };
+}
+function merge(...results) {
+    const errors = [];
+    const warnings = [];
+    for (const r of results) {
+        errors.push(...r.errors);
+        warnings.push(...r.warnings);
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}
+// ---------------------------------------------------------------------------
+// Local directory check
+// ---------------------------------------------------------------------------
+/**
+ * Check if a local directory already exists for this app name across
+ * all known installation roots (packages/, extensions/micro-apps/,
+ * extensions/payload-plugins/).
+ */
+export function validateLocalDirectory(scanRoots, appName) {
+    for (const root of scanRoots) {
+        const targetDir = path.join(root, appName);
+        if (fs.existsSync(targetDir)) {
+            return fail([
+                `Directory already exists: ${targetDir}\n` +
+                    'Use --force to overwrite or choose a different name.',
+            ]);
+        }
+    }
+    return ok();
+}
+// ---------------------------------------------------------------------------
+// Name collision check
+// ---------------------------------------------------------------------------
+/**
+ * Check if an app with this name already exists in any of the
+ * installation roots.
+ */
+export function validateNoNameCollision(scanRoots, appName) {
+    for (const root of scanRoots) {
+        const targetDir = path.join(root, appName);
+        if (!fs.existsSync(targetDir))
+            continue;
+        const pkgJsonPath = path.join(targetDir, 'package.json');
+        if (!fs.existsSync(pkgJsonPath)) {
+            return fail([
+                `Directory "${appName}" exists at ${targetDir} but has no package.json. ` +
+                    'Remove it manually or choose a different name.',
+            ]);
+        }
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+            const isDdApp = pkg.ddapp === true;
+            const isPayloadPlugin = pkg.ddPackageType === 'payload-plugin';
+            return fail([
+                `Package "${pkg.name || appName}" already exists at ${targetDir}.` +
+                    (isDdApp || isPayloadPlugin
+                        ? ' It is a dd-managed extension — use `dd uninstall` first.'
+                        : ' Choose a different name.'),
+            ]);
+        }
+        catch {
+            return fail([
+                `Directory "${appName}" exists at ${targetDir} and its package.json could not be parsed.`,
+            ]);
+        }
+    }
+    return ok();
+}
+// ---------------------------------------------------------------------------
+// Remote source validation
+// ---------------------------------------------------------------------------
+/**
+ * Validate that the remote GitHub repository exists and the path is accessible.
+ */
+export async function validateRemoteSource(source) {
+    const token = resolveGitHubToken();
+    const headers = {
+        Accept: 'application/vnd.github.v3+json',
+        'User-Agent': 'dd-cli',
+    };
+    if (token) {
+        headers['Authorization'] = `Bearer ${token}`;
+    }
+    // 1. Check the repository itself
+    const repoUrl = `https://api.github.com/repos/${source.owner}/${source.repo}`;
+    let repoRes;
+    try {
+        repoRes = await fetch(repoUrl, { headers });
+    }
+    catch (err) {
+        return fail([
+            `Network error checking repository: ${err instanceof Error ? err.message : String(err)}`,
+        ]);
+    }
+    if (repoRes.status === 404) {
+        return fail([
+            `Repository not found: ${source.owner}/${source.repo}\n` +
+                'Check the owner/repo spelling. If this is a private repo, set GITHUB_TOKEN or authenticate with `gh auth login`.',
+        ]);
+    }
+    if (repoRes.status === 401 || repoRes.status === 403) {
+        return fail([
+            'Authentication required for private repository.\n' +
+                'Set GITHUB_TOKEN or authenticate with `gh auth login` using an account that has repo access.',
+        ]);
+    }
+    if (!repoRes.ok) {
+        return fail([
+            `GitHub API error (${repoRes.status}) checking repository: ${source.owner}/${source.repo}`,
+        ]);
+    }
+    // 2. If a subdirectory is specified, verify it exists
+    if (source.subdir) {
+        const ref = source.ref ? `?ref=${encodeURIComponent(source.ref)}` : '';
+        const contentsUrl = `https://api.github.com/repos/${source.owner}/${source.repo}` +
+            `/contents/${source.subdir}${ref}`;
+        let contentsRes;
+        try {
+            contentsRes = await fetch(contentsUrl, { headers });
+        }
+        catch (err) {
+            return fail([
+                `Network error checking path: ${err instanceof Error ? err.message : String(err)}`,
+            ]);
+        }
+        if (contentsRes.status === 404) {
+            const refHint = source.ref ? ` (ref: ${source.ref})` : '';
+            return fail([
+                `Path not found in repository: ${source.subdir}${refHint}\n` +
+                    'Check that the subdirectory path exists and is spelled correctly.',
+            ]);
+        }
+        if (!contentsRes.ok) {
+            return fail([
+                `GitHub API error (${contentsRes.status}) checking path: ${source.subdir}`,
+            ]);
+        }
+    }
+    return ok();
+}
+// ---------------------------------------------------------------------------
+// Package kind detection
+// ---------------------------------------------------------------------------
+/**
+ * Detect the extension kind from a downloaded package's package.json.
+ * Returns 'payload-plugin' when ddPackageType is set, otherwise 'micro-app'.
+ */
+export function detectPackageKind(packageDir) {
+    return readManagedPackageMetadata(packageDir).kind ?? 'micro-app';
+}
+/**
+ * Read package.json metadata without importing the package.
+ * Returns whether the directory looks like a dd-managed extension.
+ */
+export function readManagedPackageMetadata(packageDir) {
+    const pkgJsonPath = path.join(packageDir, 'package.json');
+    if (!fs.existsSync(pkgJsonPath)) {
+        return { isManagedExtension: false };
+    }
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+        const kind = pkg.ddPackageType === 'payload-plugin'
+            ? 'payload-plugin'
+            : pkg.ddapp === true
+                ? 'micro-app'
+                : undefined;
+        return {
+            npmName: typeof pkg.name === 'string' ? pkg.name : undefined,
+            kind,
+            isManagedExtension: kind !== undefined,
+        };
+    }
+    catch {
+        return { isManagedExtension: false };
+    }
+}
+// ---------------------------------------------------------------------------
+// Downloaded package validation
+// ---------------------------------------------------------------------------
+/**
+ * After download: validate the downloaded package has the correct structure.
+ * When kind is 'payload-plugin', checks for ddPackageType instead of ddapp.
+ */
+export function validateDownloadedPackage(packageDir, kind) {
+    const errors = [];
+    const warnings = [];
+    // 1. package.json must exist
+    const pkgJsonPath = path.join(packageDir, 'package.json');
+    if (!fs.existsSync(pkgJsonPath)) {
+        return fail(['Downloaded package is missing package.json']);
+    }
+    let pkg;
+    try {
+        pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+    }
+    catch {
+        return fail(['Could not parse package.json in downloaded package']);
+    }
+    // 2. Kind-specific identity check
+    const effectiveKind = kind ?? 'micro-app';
+    if (effectiveKind === 'payload-plugin') {
+        if (pkg.ddPackageType !== 'payload-plugin') {
+            errors.push('package.json is missing "ddPackageType": "payload-plugin" — this may not be a valid payload plugin');
+        }
+    }
+    else {
+        if (pkg.ddapp !== true) {
+            errors.push('package.json is missing "ddapp": true — this may not be a valid dd micro-app');
+        }
+    }
+    // 3. Must have a name field
+    if (!pkg.name || typeof pkg.name !== 'string') {
+        errors.push('package.json is missing a "name" field');
+    }
+    // 4. Check entry point exists
+    const entryPoint = resolvePackageEntryPoint(packageDir, pkg);
+    if (!entryPoint) {
+        warnings.push('No entry point found (checked src/index.ts, src/index.tsx, exports["."], and main)');
+    }
+    return errors.length > 0 ? fail(errors, warnings) : ok(warnings);
+}
+export function resolvePackageEntryPoint(packageDir, pkg) {
+    // Check common entry points
+    const commonEntries = ['src/index.ts', 'src/index.tsx'];
+    for (const entry of commonEntries) {
+        if (fs.existsSync(path.join(packageDir, entry)))
+            return entry;
+    }
+    // Check exports["."] in package.json
+    const exports = pkg.exports;
+    if (exports && typeof exports === 'object' && '.' in exports) {
+        const dotExport = exports['.'];
+        const exportPath = typeof dotExport === 'string'
+            ? dotExport
+            : typeof dotExport === 'object' && dotExport !== null
+                ? dotExport.import ||
+                    dotExport.default
+                : undefined;
+        if (typeof exportPath === 'string') {
+            const resolved = path.join(packageDir, exportPath);
+            if (fs.existsSync(resolved))
+                return exportPath;
+        }
+    }
+    const main = pkg.main;
+    if (typeof main === 'string') {
+        const resolved = path.join(packageDir, main);
+        if (fs.existsSync(resolved))
+            return main;
+    }
+    return null;
+}
+const DDAPP_KEY_RE = /key:\s*['"]([^'"]+)['"]/;
+const DDAPP_SLUG_RE = /slugPrefix:\s*['"]([^'"]+)['"]/;
+function addCandidateEntry(candidates, packageDir, entry) {
+    if (typeof entry !== 'string' || entry.length === 0)
+        return;
+    const normalizedEntry = entry.replace(/^\.\//, '');
+    if (fs.existsSync(path.join(packageDir, normalizedEntry))) {
+        candidates.add(normalizedEntry);
+    }
+}
+function getMicroAppMetadataCandidates(packageDir, pkg, preferredEntryPoint) {
+    const candidates = new Set();
+    addCandidateEntry(candidates, packageDir, preferredEntryPoint);
+    addCandidateEntry(candidates, packageDir, resolvePackageEntryPoint(packageDir, pkg));
+    for (const entry of [
+        'src/index.ts',
+        'src/index.tsx',
+        'src/micro-app/index.ts',
+        'src/micro-app/index.tsx',
+    ]) {
+        addCandidateEntry(candidates, packageDir, entry);
+    }
+    const exports = pkg.exports;
+    if (exports && typeof exports === 'object' && '.' in exports) {
+        const dotExport = exports['.'];
+        if (typeof dotExport === 'string') {
+            addCandidateEntry(candidates, packageDir, dotExport);
+        }
+        else if (typeof dotExport === 'object' && dotExport !== null) {
+            addCandidateEntry(candidates, packageDir, dotExport.import);
+            addCandidateEntry(candidates, packageDir, dotExport.default);
+        }
+    }
+    addCandidateEntry(candidates, packageDir, pkg.main);
+    return [...candidates];
+}
+export function extractMicroAppMetadata(packageDir, pkg, preferredEntryPoint) {
+    let key;
+    let slugPrefix;
+    for (const entry of getMicroAppMetadataCandidates(packageDir, pkg, preferredEntryPoint)) {
+        const entryPath = path.join(packageDir, entry);
+        try {
+            const content = fs.readFileSync(entryPath, 'utf-8');
+            if (!key) {
+                const keyMatch = content.match(DDAPP_KEY_RE);
+                if (keyMatch)
+                    key = keyMatch[1];
+            }
+            if (!slugPrefix) {
+                const slugMatch = content.match(DDAPP_SLUG_RE);
+                if (slugMatch)
+                    slugPrefix = slugMatch[1];
+            }
+            if (key && slugPrefix)
+                break;
+        }
+        catch {
+            // Skip unreadable files
+        }
+    }
+    return { key, slugPrefix };
+}
+// ---------------------------------------------------------------------------
+// Slug prefix collision check
+// ---------------------------------------------------------------------------
+/**
+ * Check slug prefix collisions with existing installed dd apps across
+ * all known package roots.
+ *
+ * Scans index files for `slugPrefix: '...'` patterns since we cannot
+ * import the modules at CLI time.
+ */
+export function validateSlugPrefix(scanRoots, slugPrefix, excludeKey) {
+    const collisions = [];
+    for (const root of scanRoots) {
+        if (!fs.existsSync(root))
+            continue;
+        let dirs;
+        try {
+            dirs = fs.readdirSync(root, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const dir of dirs) {
+            if (!dir.isDirectory())
+                continue;
+            if (excludeKey && dir.name === excludeKey)
+                continue;
+            const pkgJsonPath = path.join(root, dir.name, 'package.json');
+            if (!fs.existsSync(pkgJsonPath))
+                continue;
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+                if (pkg.ddapp !== true)
+                    continue;
+                const metadata = extractMicroAppMetadata(path.join(root, dir.name), pkg);
+                if (metadata.slugPrefix === slugPrefix) {
+                    collisions.push(dir.name);
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    if (collisions.length > 0) {
+        return fail([
+            `Slug prefix "${slugPrefix}" is already used by: ${collisions.join(', ')}.\n` +
+                'Each micro-app must have a unique slug prefix to avoid collection collisions.',
+        ]);
+    }
+    return ok();
+}
+/**
+ * Check if another installed workspace package already uses the same npm name.
+ * This prevents installing the same payload plugin under multiple folder aliases.
+ * Scans all known package roots including extensions/.
+ */
+export function validateNoPackageNameCollision(scanRoots, npmName, excludeKey) {
+    for (const root of scanRoots) {
+        if (!fs.existsSync(root))
+            continue;
+        let dirs;
+        try {
+            dirs = fs.readdirSync(root, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const dir of dirs) {
+            if (!dir.isDirectory())
+                continue;
+            if (excludeKey && dir.name === excludeKey)
+                continue;
+            const pkgJsonPath = path.join(root, dir.name, 'package.json');
+            if (!fs.existsSync(pkgJsonPath))
+                continue;
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+                if (pkg.name === npmName) {
+                    return fail([
+                        `Package name collision: "${npmName}" is already installed at ${path.join(root, dir.name)}.\n` +
+                            'Installing the same npm package under multiple folder names would corrupt dependency and TS path wiring.',
+                    ]);
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return ok();
+}
+// ---------------------------------------------------------------------------
+// Aggregate pre-install validation
+// ---------------------------------------------------------------------------
+/**
+ * Run all pre-install validations (local + remote) in one call.
+ */
+export async function runPreInstallValidation(scanRoots, appName, source) {
+    const local = merge(validateLocalDirectory(scanRoots, appName), validateNoNameCollision(scanRoots, appName));
+    // Short-circuit if local checks already failed
+    if (!local.valid)
+        return local;
+    const remote = await validateRemoteSource(source);
+    return merge(local, remote);
+}

package/dist/paths.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Resolve key workspace paths relative to the monorepo root.
+ *
+ * The CLI can be run from anywhere inside the monorepo.
+ * We walk upward from cwd until we find pnpm-workspace.yaml.
+ */
+export interface WorkspacePaths {
+    /** Monorepo root (contains pnpm-workspace.yaml) */
+    root: string;
+    /** packages/ directory (internal framework + legacy extensions) */
+    packagesDir: string;
+    /** extensions/micro-apps/ directory */
+    extensionsMicroAppsDir: string;
+    /** extensions/payload-plugins/ directory */
+    extensionsPayloadPluginsDir: string;
+    /** apps/main-app/ directory */
+    mainAppDir: string;
+    /** dd-apps.config.json path */
+    configPath: string;
+    /** dd-apps.lock.json path */
+    lockFilePath: string;
+    /** Generated micro-apps.ts path */
+    microAppsOutputPath: string;
+    /** Generated payload-plugins.ts path */
+    payloadPluginsOutputPath: string;
+    /** main-app package.json */
+    mainAppPackageJsonPath: string;
+}
+export declare function resolveWorkspacePaths(cwd?: string): WorkspacePaths;
+/** Absolute install directory for an extension of the given kind. */
+export declare function installDirForKind(paths: WorkspacePaths, kind: 'micro-app' | 'payload-plugin', name: string): string;
+/** Root-relative install path for lock file entries and display. */
+export declare function installRelPath(kind: 'micro-app' | 'payload-plugin', name: string): string;
+/** All directories where an extension can be installed (for directory/name checks). */
+export declare function allInstallRoots(paths: WorkspacePaths): string[];
+/** All directories that may contain discoverable packages (for collision/scan checks). */
+export declare function allScanRoots(paths: WorkspacePaths): string[];
+/** Legacy install location used before the extensions/ migration. */
+export declare function legacyInstallDir(paths: WorkspacePaths, name: string): string;
+/**
+ * Ordered candidate install paths for resolving current and legacy installs.
+ * Preferred kind is probed first, followed by the other extension root and
+ * the pre-Phase-4 packages/<name> location.
+ */
+export declare function installProbePaths(paths: WorkspacePaths, name: string, preferredKind?: 'micro-app' | 'payload-plugin'): string[];
+//# sourceMappingURL=paths.d.ts.map

package/dist/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,MAAM,WAAW,cAAc;IAC7B,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,WAAW,EAAE,MAAM,CAAC;IACpB,uCAAuC;IACvC,sBAAsB,EAAE,MAAM,CAAC;IAC/B,4CAA4C;IAC5C,2BAA2B,EAAE,MAAM,CAAC;IACpC,+BAA+B;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,+BAA+B;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,6BAA6B;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,mCAAmC;IACnC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,wCAAwC;IACxC,wBAAwB,EAAE,MAAM,CAAC;IACjC,4BAA4B;IAC5B,sBAAsB,EAAE,MAAM,CAAC;CAChC;AAgBD,wBAAgB,qBAAqB,CAAC,GAAG,SAAgB,GAAG,cAAc,CAoBzE;AAED,qEAAqE;AACrE,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,WAAW,GAAG,gBAAgB,EACpC,IAAI,EAAE,MAAM,GACX,MAAM,CAKR;AAED,oEAAoE;AACpE,wBAAgB,cAAc,CAC5B,IAAI,EAAE,WAAW,GAAG,gBAAgB,EACpC,IAAI,EAAE,MAAM,GACX,MAAM,CAIR;AAED,uFAAuF;AACvF,wBAAgB,eAAe,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,EAAE,CAM/D;AAED,0FAA0F;AAC1F,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,EAAE,CAO5D;AAED,qEAAqE;AACrE,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,MAAM,GACX,MAAM,CAER;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,MAAM,EACZ,aAAa,CAAC,EAAE,WAAW,GAAG,gBAAgB,GAC7C,MAAM,EAAE,CAcV"}

package/dist/paths.js

@@ -0,0 +1,85 @@
+/**
+ * Resolve key workspace paths relative to the monorepo root.
+ *
+ * The CLI can be run from anywhere inside the monorepo.
+ * We walk upward from cwd until we find pnpm-workspace.yaml.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+function findMonorepoRoot(startDir) {
+    let dir = startDir;
+    while (dir !== path.dirname(dir)) {
+        if (fs.existsSync(path.join(dir, 'pnpm-workspace.yaml'))) {
+            return dir;
+        }
+        dir = path.dirname(dir);
+    }
+    throw new Error('Could not find monorepo root (no pnpm-workspace.yaml found). ' +
+        'Make sure you are running this command from within the monorepo.');
+}
+export function resolveWorkspacePaths(cwd = process.cwd()) {
+    const root = findMonorepoRoot(cwd);
+    const mainAppDir = path.join(root, 'apps', 'main-app');
+    if (!fs.existsSync(mainAppDir)) {
+        throw new Error(`Main app not found at ${mainAppDir}`);
+    }
+    return {
+        root,
+        packagesDir: path.join(root, 'packages'),
+        extensionsMicroAppsDir: path.join(root, 'extensions', 'micro-apps'),
+        extensionsPayloadPluginsDir: path.join(root, 'extensions', 'payload-plugins'),
+        mainAppDir,
+        configPath: path.join(mainAppDir, 'dd-apps.config.json'),
+        lockFilePath: path.join(root, 'dd-apps.lock.json'),
+        microAppsOutputPath: path.join(mainAppDir, 'src', 'lib', 'micro-apps.ts'),
+        payloadPluginsOutputPath: path.join(mainAppDir, 'src', 'lib', 'payload-plugins.ts'),
+        mainAppPackageJsonPath: path.join(mainAppDir, 'package.json'),
+    };
+}
+/** Absolute install directory for an extension of the given kind. */
+export function installDirForKind(paths, kind, name) {
+    const base = kind === 'payload-plugin'
+        ? paths.extensionsPayloadPluginsDir
+        : paths.extensionsMicroAppsDir;
+    return path.join(base, name);
+}
+/** Root-relative install path for lock file entries and display. */
+export function installRelPath(kind, name) {
+    return kind === 'payload-plugin'
+        ? `extensions/payload-plugins/${name}`
+        : `extensions/micro-apps/${name}`;
+}
+/** All directories where an extension can be installed (for directory/name checks). */
+export function allInstallRoots(paths) {
+    return [
+        paths.packagesDir,
+        paths.extensionsMicroAppsDir,
+        paths.extensionsPayloadPluginsDir,
+    ];
+}
+/** All directories that may contain discoverable packages (for collision/scan checks). */
+export function allScanRoots(paths) {
+    return [
+        paths.packagesDir,
+        path.join(paths.packagesDir, 'adapters'),
+        paths.extensionsMicroAppsDir,
+        paths.extensionsPayloadPluginsDir,
+    ];
+}
+/** Legacy install location used before the extensions/ migration. */
+export function legacyInstallDir(paths, name) {
+    return path.join(paths.packagesDir, name);
+}
+/**
+ * Ordered candidate install paths for resolving current and legacy installs.
+ * Preferred kind is probed first, followed by the other extension root and
+ * the pre-Phase-4 packages/<name> location.
+ */
+export function installProbePaths(paths, name, preferredKind) {
+    const candidates = [];
+    if (preferredKind) {
+        candidates.push(installDirForKind(paths, preferredKind, name));
+    }
+    candidates.push(installDirForKind(paths, 'micro-app', name), installDirForKind(paths, 'payload-plugin', name), legacyInstallDir(paths, name));
+    return [...new Set(candidates)];
+}

package/dist/scanner.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Scan workspace packages/ and extensions/ directories for micro-apps
+ * (ddapp: true) and standalone payload plugins (ddPackageType: 'payload-plugin').
+ */
+import type { WorkspacePaths } from './paths.js';
+export interface DiscoveredApp {
+    /** Folder name (= DDApp key) */
+    key: string;
+    /** NPM package name, e.g. @doubledigit/meal-planner */
+    npmName: string;
+    /** JS-safe import name, e.g. mealPlanner */
+    importName: string;
+    /** Absolute path to the package directory */
+    dir: string;
+}
+export interface DiscoveredPayloadPlugin {
+    /** Folder name */
+    key: string;
+    /** NPM package name, e.g. @doubledigit/some-plugin */
+    npmName: string;
+    /** JS-safe import name, e.g. somePlugin */
+    importName: string;
+    /** Absolute path to the package directory */
+    dir: string;
+}
+/** Unified result from scanning the workspace. */
+export interface ScanResult {
+    microApps: DiscoveredApp[];
+    payloadPlugins: DiscoveredPayloadPlugin[];
+}
+/**
+ * Scan packages/, packages/adapters/, extensions/micro-apps/, and
+ * extensions/payload-plugins/ for micro-apps and payload plugins.
+ *
+ * packages/ is scanned first so internal/legacy packages take precedence
+ * during the transition period.
+ */
+export declare function scanWorkspace(paths: WorkspacePaths): ScanResult;
+/** @deprecated Use scanWorkspace(paths) instead — returns only micro-apps for backward compat. */
+export declare function scanForDDApps(packagesDir: string): DiscoveredApp[];
+//# sourceMappingURL=scanner.d.ts.map

package/dist/scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanner.d.ts","sourceRoot":"","sources":["../src/scanner.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,MAAM,WAAW,aAAa;IAC5B,gCAAgC;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,uDAAuD;IACvD,OAAO,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,UAAU,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,uBAAuB;IACtC,kBAAkB;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,GAAG,EAAE,MAAM,CAAC;CACb;AAED,kDAAkD;AAClD,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,cAAc,EAAE,uBAAuB,EAAE,CAAC;CAC3C;AA6ED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,GAAG,UAAU,CAgB/D;AAED,kGAAkG;AAClG,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,aAAa,EAAE,CAMlE"}