@ctrl-spc/cli 1.1.14 → 1.2.0

package/dist/topology.js

@@ -0,0 +1,602 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, lstatSync, readFileSync, readdirSync, realpathSync } from 'node:fs';
+import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { normalizeRemoteUrl } from './git.js';
+/** Directories that are both expensive and extremely unlikely to contain a
+ * user-owned repository that should be auto-discovered. An explicitly passed
+ * --repo path is still inspected even when one of its ancestors has this name. */
+export const IGNORED_TOPOLOGY_DIRECTORIES = new Set([
+    '.git', '.hg', '.svn', '.cache', '.gradle', '.idea', '.next', '.turbo', '.venv',
+    '__pycache__', 'build', 'coverage', 'deriveddata', 'dist', 'node_modules', 'pods',
+    'target', 'vendor', 'venv',
+]);
+function gitOutput(cwd, args) {
+    try {
+        const output = execFileSync('git', args, {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        return output || null;
+    }
+    catch {
+        return null;
+    }
+}
+function canonicalDirectory(path) {
+    const absolute = resolve(path);
+    if (!existsSync(absolute))
+        throw new Error(`Directory does not exist: ${absolute}`);
+    const stat = lstatSync(absolute);
+    if (!stat.isDirectory() && !stat.isSymbolicLink())
+        throw new Error(`Not a directory: ${absolute}`);
+    const canonical = realpathSync(absolute);
+    if (!lstatSync(canonical).isDirectory())
+        throw new Error(`Not a directory: ${absolute}`);
+    return canonical;
+}
+function canonicalIfPresent(path) {
+    return existsSync(path) ? realpathSync(path) : resolve(path);
+}
+function toPosix(path) {
+    return path.split(sep).join('/');
+}
+function isWithin(parent, child) {
+    const rel = relative(parent, child);
+    return rel === '' || (!rel.startsWith(`..${sep}`) && rel !== '..' && !isAbsolute(rel));
+}
+function hasGitMarker(path) {
+    const marker = join(path, '.git');
+    if (!existsSync(marker))
+        return false;
+    try {
+        return !lstatSync(marker).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+function shouldIgnoreDirectory(name, ignored) {
+    const lower = name.toLowerCase();
+    return ignored.has(lower) || lower.endsWith('.xcodeproj') || lower.endsWith('.xcworkspace');
+}
+/** Breadth-first and lexically ordered so discovery is deterministic on every filesystem. */
+function walkDirectories(root, options) {
+    const queue = [root];
+    const directories = [];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current !== root && options.stopAtNestedGit && hasGitMarker(current))
+            continue;
+        directories.push(current);
+        if (directories.length > options.maxDirectories) {
+            throw new Error(`Repository scan exceeded ${options.maxDirectories} directories at ${current}. ` +
+                'Pass narrower --repo paths instead of accepting a partial scan.');
+        }
+        let entries;
+        try {
+            entries = readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.isSymbolicLink())
+                continue;
+            if (shouldIgnoreDirectory(entry.name, options.ignored))
+                continue;
+            const path = join(current, entry.name);
+            try {
+                if (lstatSync(path).isSymbolicLink())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            queue.push(path);
+        }
+    }
+    return directories;
+}
+/** Returns the canonical checkout root even when `startPath` is a deep subfolder. */
+export function findContainingGitRoot(startPath) {
+    const selected = canonicalDirectory(startPath);
+    const topLevel = gitOutput(selected, ['rev-parse', '--show-toplevel']);
+    return topLevel ? canonicalIfPresent(topLevel) : null;
+}
+function resolveGitDirectory(root) {
+    const absolute = gitOutput(root, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+    if (absolute)
+        return canonicalIfPresent(absolute);
+    const fallback = gitOutput(root, ['rev-parse', '--git-common-dir']);
+    if (!fallback)
+        throw new Error(`Could not resolve Git metadata for ${root}`);
+    return canonicalIfPresent(isAbsolute(fallback) ? fallback : resolve(root, fallback));
+}
+function readRepository(candidate, selectedPath) {
+    const topLevel = gitOutput(candidate, ['rev-parse', '--show-toplevel']);
+    if (!topLevel)
+        return null;
+    const rootPath = canonicalIfPresent(topLevel);
+    const rawOrigin = gitOutput(rootPath, ['remote', 'get-url', 'origin']);
+    const superproject = gitOutput(rootPath, ['rev-parse', '--show-superproject-working-tree']);
+    return {
+        rootPath,
+        gitCommonDir: resolveGitDirectory(rootPath),
+        origin: rawOrigin
+            ? { status: 'normalized', url: normalizeRemoteUrl(rawOrigin) }
+            : { status: 'missing_origin' },
+        superprojectRoot: superproject ? canonicalIfPresent(superproject) : null,
+        containsSelection: isWithin(rootPath, selectedPath),
+    };
+}
+function gitmodulePaths(repositoryRoot) {
+    const manifest = join(repositoryRoot, '.gitmodules');
+    if (!existsSync(manifest))
+        return [];
+    const output = gitOutput(repositoryRoot, [
+        'config', '--file', manifest, '--get-regexp', '^submodule\\..*\\.path$',
+    ]);
+    if (!output)
+        return [];
+    return output
+        .split(/\r?\n/)
+        .map((line) => /^\S+\s+(.+)$/.exec(line)?.[1]?.trim())
+        .filter((path) => Boolean(path))
+        .map((path) => resolve(repositoryRoot, path))
+        // A declared submodule is an explicit repository hint, so it may live in
+        // an otherwise ignored dependency folder. Still never follow a symlink.
+        .filter((path) => {
+        try {
+            return existsSync(path) && !lstatSync(path).isSymbolicLink();
+        }
+        catch {
+            return false;
+        }
+    })
+        .map(canonicalIfPresent);
+}
+function nearestRepositoryParent(root, repositories) {
+    return repositories
+        .filter((candidate) => candidate.rootPath !== root && isWithin(candidate.rootPath, root))
+        .sort((a, b) => b.rootPath.length - a.rootPath.length || a.rootPath.localeCompare(b.rootPath))[0] ?? null;
+}
+/**
+ * Discovers every Git root under the selected workspace. When invoked from
+ * inside a repository, the containing root is the scan boundary; when invoked
+ * from a Gitless workspace folder, sibling child repositories are discovered.
+ * Symlinks are never followed.
+ */
+export function discoverRepositoryTopology(selectedPath, options = {}) {
+    const selected = canonicalDirectory(selectedPath);
+    const containingGitRoot = findContainingGitRoot(selected);
+    const scanRoot = containingGitRoot ?? selected;
+    const maxDirectories = options.maxDirectories ?? 20_000;
+    const ignored = options.ignoredDirectoryNames ?? IGNORED_TOPOLOGY_DIRECTORIES;
+    const candidates = walkDirectories(scanRoot, { maxDirectories, ignored, stopAtNestedGit: false })
+        .filter(hasGitMarker);
+    if (containingGitRoot)
+        candidates.push(containingGitRoot);
+    const byRoot = new Map();
+    for (const candidate of [...new Set(candidates)].sort()) {
+        const repository = readRepository(candidate, selected);
+        if (repository)
+            byRoot.set(repository.rootPath, repository);
+    }
+    // `.gitmodules` is an explicit declaration, not a broad filesystem scan.
+    // Follow declared submodule paths even inside an ignored dependency folder,
+    // and recurse for submodules that themselves declare submodules.
+    const inspectedSubmoduleParents = new Set();
+    while (true) {
+        const parent = [...byRoot.values()]
+            .sort((a, b) => a.rootPath.localeCompare(b.rootPath))
+            .find((repository) => !inspectedSubmoduleParents.has(repository.rootPath));
+        if (!parent)
+            break;
+        inspectedSubmoduleParents.add(parent.rootPath);
+        for (const submodulePath of gitmodulePaths(parent.rootPath)) {
+            const repository = readRepository(submodulePath, selected);
+            if (repository)
+                byRoot.set(repository.rootPath, repository);
+        }
+    }
+    // Linked worktrees share a common Git directory. Preserve every alternate
+    // checkout path for visibility, but expose one repository choice so a user
+    // cannot accidentally select the same underlying repository twice.
+    const byCommonDir = new Map();
+    for (const repository of byRoot.values()) {
+        const group = byCommonDir.get(repository.gitCommonDir) ?? [];
+        group.push(repository);
+        byCommonDir.set(repository.gitCommonDir, group);
+    }
+    const chosen = [];
+    for (const group of byCommonDir.values()) {
+        group.sort((a, b) => {
+            const containingOrder = Number(b.rootPath === containingGitRoot) - Number(a.rootPath === containingGitRoot);
+            return containingOrder || a.rootPath.localeCompare(b.rootPath);
+        });
+        chosen.push({ repository: group[0], alternates: group.slice(1).map((repo) => repo.rootPath).sort() });
+    }
+    chosen.sort((a, b) => a.repository.rootPath.localeCompare(b.repository.rootPath));
+    const selectedRepositories = chosen.map((item) => item.repository);
+    const submodulesByParent = new Map();
+    for (const parent of selectedRepositories) {
+        submodulesByParent.set(parent.rootPath, new Set(gitmodulePaths(parent.rootPath)));
+    }
+    const repositories = chosen.map(({ repository, alternates }) => {
+        const parent = nearestRepositoryParent(repository.rootPath, selectedRepositories);
+        let relationship;
+        if (repository.superprojectRoot) {
+            relationship = { kind: 'submodule', parentRoot: repository.superprojectRoot };
+        }
+        else if (parent && submodulesByParent.get(parent.rootPath)?.has(repository.rootPath)) {
+            relationship = { kind: 'submodule', parentRoot: parent.rootPath };
+        }
+        else if (parent) {
+            relationship = { kind: 'nested_independent', parentRoot: parent.rootPath };
+        }
+        else {
+            relationship = { kind: 'independent' };
+        }
+        return {
+            rootPath: repository.rootPath,
+            alternateWorktreeRoots: alternates,
+            gitCommonDir: repository.gitCommonDir,
+            origin: repository.origin,
+            relationship,
+            containsSelection: repository.containsSelection || alternates.some((root) => isWithin(root, selected)),
+            componentCandidates: detectMonorepoComponents(repository.rootPath, { maxDirectories, ignoredDirectoryNames: ignored }),
+        };
+    });
+    return { selectedPath: selected, scanRoot, containingGitRoot, repositories };
+}
+function readJson(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+function normalizeWorkspacePattern(raw) {
+    const pattern = raw.trim().replace(/^['"]|['"]$/g, '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '');
+    if (!pattern || pattern.startsWith('!') || pattern.startsWith('/') || pattern.split('/').includes('..'))
+        return null;
+    return pattern;
+}
+function yamlList(text, key) {
+    const lines = text.split(/\r?\n/);
+    const values = [];
+    let baseIndent = null;
+    for (const line of lines) {
+        const keyMatch = new RegExp(`^(\\s*)${key}:\\s*(?:#.*)?$`).exec(line);
+        if (keyMatch) {
+            baseIndent = keyMatch[1].length;
+            continue;
+        }
+        if (baseIndent === null)
+            continue;
+        const item = /^(\s*)-\s*['"]?([^'"#]+?)['"]?\s*(?:#.*)?$/.exec(line);
+        if (item && item[1].length > baseIndent) {
+            values.push(item[2].trim());
+            continue;
+        }
+        if (line.trim() && line.length - line.trimStart().length <= baseIndent)
+            baseIndent = null;
+    }
+    return values;
+}
+function quotedTomlArray(text, key) {
+    const match = new RegExp(`${key}\\s*=\\s*\\[([\\s\\S]*?)\\]`, 'm').exec(text);
+    if (!match)
+        return [];
+    return [...match[1].matchAll(/['"]([^'"]+)['"]/g)].map((item) => item[1]);
+}
+function goWorkUses(text) {
+    const values = [];
+    const block = /\buse\s*\(([\s\S]*?)\)/m.exec(text);
+    if (block) {
+        for (const raw of block[1].split(/\r?\n/)) {
+            const value = raw.replace(/\/\/.*$/, '').trim();
+            if (value)
+                values.push(value);
+        }
+    }
+    for (const match of text.matchAll(/^\s*use\s+([^\s(][^\r\n]*)$/gm))
+        values.push(match[1].trim());
+    return values;
+}
+function workspacePatterns(repositoryRoot) {
+    const patterns = [];
+    const add = (source, values) => {
+        for (const value of values) {
+            const normalized = normalizeWorkspacePattern(value);
+            if (normalized)
+                patterns.push({ source, pattern: normalized });
+        }
+    };
+    const packageJson = readJson(join(repositoryRoot, 'package.json'));
+    if (packageJson) {
+        const workspaces = packageJson.workspaces;
+        add('package.json workspaces', Array.isArray(workspaces)
+            ? stringArray(workspaces)
+            : workspaces && typeof workspaces === 'object'
+                ? stringArray(workspaces.packages)
+                : []);
+    }
+    const lerna = readJson(join(repositoryRoot, 'lerna.json'));
+    if (lerna)
+        add('lerna.json packages', stringArray(lerna.packages));
+    const rush = readJson(join(repositoryRoot, 'rush.json'));
+    if (rush && Array.isArray(rush.projects)) {
+        add('rush.json projects', rush.projects
+            .map((project) => project && typeof project === 'object' ? project.projectFolder : null)
+            .filter((path) => typeof path === 'string'));
+    }
+    const yamlSources = [
+        ['pnpm-workspace.yaml', 'packages', 'pnpm-workspace.yaml packages'],
+        ['melos.yaml', 'packages', 'melos.yaml packages'],
+    ];
+    for (const [file, key, source] of yamlSources) {
+        const path = join(repositoryRoot, file);
+        if (existsSync(path))
+            add(source, yamlList(readFileSync(path, 'utf8'), key));
+    }
+    const cargoPath = join(repositoryRoot, 'Cargo.toml');
+    if (existsSync(cargoPath))
+        add('Cargo.toml workspace members', quotedTomlArray(readFileSync(cargoPath, 'utf8'), 'members'));
+    const goWorkPath = join(repositoryRoot, 'go.work');
+    if (existsSync(goWorkPath))
+        add('go.work use', goWorkUses(readFileSync(goWorkPath, 'utf8')));
+    const unique = new Map(patterns.map((pattern) => [`${pattern.source}\u0000${pattern.pattern}`, pattern]));
+    return [...unique.values()].sort((a, b) => a.pattern.localeCompare(b.pattern) || a.source.localeCompare(b.source));
+}
+function globRegex(pattern) {
+    let source = '^';
+    for (let i = 0; i < pattern.length; i++) {
+        const char = pattern[i];
+        if (char === '*' && pattern[i + 1] === '*') {
+            source += '.*';
+            i++;
+        }
+        else if (char === '*') {
+            source += '[^/]*';
+        }
+        else if (char === '?') {
+            source += '[^/]';
+        }
+        else {
+            source += char.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
+        }
+    }
+    return new RegExp(`${source}$`);
+}
+function componentManifests(path) {
+    const knownFiles = [
+        'Cargo.toml', 'Package.swift', 'Podfile', 'build.gradle', 'build.gradle.kts', 'go.mod',
+        'package.json', 'pubspec.yaml', 'pyproject.toml', 'settings.gradle', 'settings.gradle.kts',
+    ];
+    const manifests = knownFiles.filter((file) => existsSync(join(path, file)));
+    try {
+        for (const entry of readdirSync(path, { withFileTypes: true })) {
+            if (entry.name.endsWith('.xcodeproj') || entry.name.endsWith('.xcworkspace'))
+                manifests.push(entry.name);
+        }
+    }
+    catch { /* unreadable directories simply cannot be candidates */ }
+    return [...new Set(manifests)].sort();
+}
+/** Reports plausible component boundaries; it never chooses or groups them. */
+export function detectMonorepoComponents(repositoryRoot, options = {}) {
+    const root = canonicalDirectory(repositoryRoot);
+    const rawOrigin = gitOutput(root, ['remote', 'get-url', 'origin']);
+    const targetRemote = rawOrigin ? normalizeRemoteUrl(rawOrigin) : `local-only/${basename(root)}`;
+    const maxDirectories = options.maxDirectories ?? 20_000;
+    const ignored = options.ignoredDirectoryNames ?? IGNORED_TOPOLOGY_DIRECTORIES;
+    const patterns = workspacePatterns(root).map((entry) => ({ ...entry, regex: globRegex(entry.pattern) }));
+    const directories = walkDirectories(root, { maxDirectories, ignored, stopAtNestedGit: true });
+    const candidates = [];
+    for (const directory of directories) {
+        if (directory === root)
+            continue;
+        const relativePath = toPosix(relative(root, directory));
+        const manifests = componentManifests(directory);
+        const reasons = patterns
+            .filter((pattern) => pattern.regex.test(relativePath))
+            .map((pattern) => `${pattern.source}: ${pattern.pattern}`);
+        if (!relativePath.includes('/') && manifests.length > 0) {
+            reasons.push(`top-level app manifest: ${manifests.join(', ')}`);
+        }
+        if (reasons.length === 0)
+            continue;
+        candidates.push({
+            id: componentTargetId(targetRemote, relativePath),
+            repositoryRoot: root,
+            relativePath,
+            label: basename(directory),
+            manifests,
+            reasons: [...new Set(reasons)].sort(),
+        });
+    }
+    return candidates.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+/** Portable grouping identity. Local paths never participate, so the same
+ * manifest can be used by every teammate and CI checkout. */
+export function repositoryTargetId(remoteKey) {
+    return `repo:${normalizeRemoteUrl(remoteKey)}`;
+}
+export function componentTargetId(remoteKey, relativePath) {
+    const normalized = toPosix(relativePath).replace(/^\.\//, '').replace(/^\/+|\/+$/g, '');
+    return `component:${normalizeRemoteUrl(remoteKey)}#${normalized}`;
+}
+export function buildTopologyTargets(discovery) {
+    const targets = [];
+    for (const repository of discovery.repositories) {
+        if (repository.origin.status !== 'normalized')
+            continue;
+        targets.push({
+            id: repositoryTargetId(repository.origin.url),
+            repositoryRoot: repository.rootPath,
+            componentPath: null,
+            label: basename(repository.rootPath),
+        });
+        for (const component of repository.componentCandidates) {
+            targets.push({
+                id: componentTargetId(repository.origin.url, component.relativePath),
+                repositoryRoot: repository.rootPath,
+                componentPath: component.relativePath,
+                label: component.label,
+            });
+        }
+    }
+    return targets.sort((a, b) => a.id.localeCompare(b.id));
+}
+function pathsOverlap(a, b) {
+    return a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`);
+}
+/**
+ * Produces a grouping only from a complete explicit selection. There is no
+ * default mode and custom groups must assign every selected target exactly once.
+ */
+export function planExplicitGrouping(availableTargets, selection) {
+    if (selection.targetIds.length === 0)
+        throw new Error('Select at least one repository or component.');
+    const available = new Map(availableTargets.map((target) => [target.id, target]));
+    const selected = new Set();
+    for (const id of selection.targetIds) {
+        if (!available.has(id))
+            throw new Error(`Unknown topology target: ${id}`);
+        if (selected.has(id))
+            throw new Error(`Topology target selected more than once: ${id}`);
+        selected.add(id);
+    }
+    const resolved = [...selected].map((id) => available.get(id));
+    for (let i = 0; i < resolved.length; i++) {
+        for (let j = i + 1; j < resolved.length; j++) {
+            const a = resolved[i];
+            const b = resolved[j];
+            if (a.repositoryRoot !== b.repositoryRoot)
+                continue;
+            if (a.componentPath === null || b.componentPath === null) {
+                throw new Error(`Cannot select a whole repository and one of its components together: ${a.repositoryRoot}`);
+            }
+            if (pathsOverlap(a.componentPath, b.componentPath)) {
+                throw new Error(`Overlapping monorepo component scopes: ${a.componentPath} and ${b.componentPath}`);
+            }
+        }
+    }
+    const targetIds = [...selected];
+    if (selection.mode === 'combine') {
+        return { mode: 'combine', targetIds, groups: [{ name: null, targetIds }], targetConfiguration: {} };
+    }
+    if (selection.mode === 'split') {
+        return {
+            mode: 'split', targetIds, groups: targetIds.map((id) => ({ name: null, targetIds: [id] })),
+            targetConfiguration: {},
+        };
+    }
+    if (selection.groups.length === 0)
+        throw new Error('A custom grouping manifest must contain at least one group.');
+    const assigned = new Set();
+    const names = new Set();
+    const groups = selection.groups.map((group) => {
+        const name = group.name.trim();
+        if (!name)
+            throw new Error('Custom group names cannot be empty.');
+        const nameKey = name.toLowerCase();
+        if (names.has(nameKey))
+            throw new Error(`Duplicate custom group name: ${name}`);
+        names.add(nameKey);
+        if (group.targetIds.length === 0)
+            throw new Error(`Custom group "${name}" has no targets.`);
+        for (const id of group.targetIds) {
+            if (!selected.has(id))
+                throw new Error(`Custom group "${name}" references an unselected target: ${id}`);
+            if (assigned.has(id))
+                throw new Error(`Topology target assigned to more than one custom group: ${id}`);
+            assigned.add(id);
+        }
+        return { name, targetIds: [...group.targetIds] };
+    });
+    const missing = targetIds.filter((id) => !assigned.has(id));
+    if (missing.length > 0)
+        throw new Error(`Custom grouping omitted selected targets: ${missing.join(', ')}`);
+    const targetConfiguration = selection.targetConfiguration ?? {};
+    for (const id of Object.keys(targetConfiguration)) {
+        if (!selected.has(id))
+            throw new Error(`Configuration references an unselected topology target: ${id}`);
+    }
+    return { mode: 'custom', targetIds, groups, targetConfiguration };
+}
+function parseManifestTargets(values, label) {
+    const targetConfiguration = {};
+    const targetIds = values.map((target, index) => {
+        if (typeof target === 'string' && target.trim())
+            return target;
+        if (!target || typeof target !== 'object' || Array.isArray(target)) {
+            throw new Error(`${label} target ${index + 1} must be a non-empty string or object.`);
+        }
+        const config = target;
+        if (typeof config.id !== 'string' || !config.id.trim()) {
+            throw new Error(`${label} target ${index + 1} requires an id.`);
+        }
+        if (config.required !== undefined && typeof config.required !== 'boolean') {
+            throw new Error(`Grouping manifest target ${config.id} required must be true or false.`);
+        }
+        if (config.purpose !== undefined && typeof config.purpose !== 'string') {
+            throw new Error(`Grouping manifest target ${config.id} purpose must be a string.`);
+        }
+        targetConfiguration[config.id] = {
+            ...(config.required === undefined ? {} : { required: config.required }),
+            ...(config.purpose === undefined ? {} : { purpose: config.purpose }),
+        };
+        return config.id;
+    });
+    const duplicate = targetIds.find((id, index) => targetIds.indexOf(id) !== index);
+    if (duplicate)
+        throw new Error(`${label} declares target more than once: ${duplicate}`);
+    return { targetIds, targetConfiguration };
+}
+/** Strict, portable JSON format used by canonical `--manifest` and legacy `--group`. */
+export function readGroupingManifest(path) {
+    const absolute = resolve(path);
+    const json = readJson(absolute);
+    if (!json)
+        throw new Error(`Could not read grouping manifest JSON: ${absolute}`);
+    if (json.version !== undefined && json.version !== 1)
+        throw new Error('Grouping manifest version must be 1.');
+    if (!Array.isArray(json.groups))
+        throw new Error('Grouping manifest requires a groups array.');
+    const declared = json.targets === undefined
+        ? null
+        : Array.isArray(json.targets)
+            ? parseManifestTargets(json.targets, 'Grouping manifest')
+            : (() => { throw new Error('Grouping manifest targets must be an array.'); })();
+    const groups = json.groups.map((value, index) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            throw new Error(`Grouping manifest group ${index + 1} must be an object.`);
+        }
+        const group = value;
+        if (typeof group.name !== 'string')
+            throw new Error(`Grouping manifest group ${index + 1} requires a name.`);
+        if (!Array.isArray(group.targets)) {
+            throw new Error(`Grouping manifest group ${index + 1} requires a targets array.`);
+        }
+        const { targetIds, targetConfiguration } = parseManifestTargets(group.targets, `Grouping manifest group ${index + 1}`);
+        return { name: group.name, targetIds, targetConfiguration };
+    });
+    const targetConfiguration = Object.assign({}, declared?.targetConfiguration ?? {}, ...groups.map((group) => group.targetConfiguration));
+    return {
+        mode: 'custom',
+        targetIds: declared?.targetIds ?? groups.flatMap((group) => group.targetIds),
+        groups: groups.map(({ name, targetIds }) => ({ name, targetIds })),
+        targetConfiguration,
+    };
+}

package/package.json

@@ -1,39 +1,41 @@
 {
   "name": "@ctrl-spc/cli",
-  "version": "1.1.14",
-  "description": "Control Space CLI - machine setup and background daemon",
+  "version": "1.2.0",
+  "description": "CTRL+SPC CLI — per-machine agent for browser login, project linking, presence, and the local MCP server.",
+  "engines": {
+    "node": ">=22"
+  },
   "type": "module",
-  "files": [
-    "bin/",
-    "dist/"
-  ],
   "bin": {
-    "ctrl-spc": "bin/ctrl-spc.js"
+    "ctrl-spc": "dist/index.js",
+    "ctrl+spc": "dist/index.js"
   },
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
     "build": "tsc",
-    "prepack": "node scripts/bundle-mcp-server.mjs",
-    "postpack": "node scripts/cleanup-bundle.mjs",
-    "test": "vitest run"
+    "test": "vitest run",
+    "test:e2e-contract": "vitest run e2e",
+    "typecheck:e2e-contract": "tsc -p e2e/tsconfig.json",
+    "run:e2e-copied-work": "node --experimental-strip-types e2e/run-copied-work-item.ts",
+    "run:e2e-hosted-topology": "npm run build && node --experimental-strip-types e2e/run-hosted-topology-management.ts",
+    "run:e2e-hosted-topology": "npm run build && node --experimental-strip-types e2e/run-hosted-topology-management.ts",
+    "setup:e2e-multirepo": "node --experimental-strip-types e2e/setup-multirepo-matrix.ts",
+    "verify:e2e-multirepo": "npm run build && node --experimental-strip-types e2e/run-multirepo-matrix.ts"
   },
+  "license": "UNLICENSED",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.11.0",
-    "@ctrl-spc/mcp-server": "0.1.0",
-    "@supabase/supabase-js": "^2.108.2",
-    "node-windows": "^1.0.0-beta.8"
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@supabase/supabase-js": "^2.110.1",
+    "zod": "^4.4.3"
   },
-  "bundledDependencies": [
-    "@ctrl-spc/mcp-server"
-  ],
   "devDependencies": {
-    "@types/node": "^24.13.2",
-    "typescript": "~6.0.2",
-    "vitest": "^4.1.9"
-  },
-  "engines": {
-    "node": ">=20"
+    "@types/node": "^26.1.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.10"
   }
 }

package/bin/ctrl-spc.js

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-
-import('../dist/index.js').catch((err) => {
-  console.error('Failed to load ctrl-spc:', err.message)
-  process.exit(1)
-})