@ctrl-spc/cli 1.3.1 → 1.3.3

package/dist/companion-projects.js

@@ -0,0 +1,375 @@
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getMachineIdentity } from './config.js';
+import { ensureLocalRepositoryIdentity } from './git.js';
+import { detectRoleFingerprint } from './role-detection.js';
+import { suffixedRoleSlug } from './roles.js';
+import { mergeDiscoveries } from './commands/init.js';
+import { getClient } from './supabase.js';
+import { discoverRepositoryTopology, componentTargetId, repositoryTargetId, } from './topology.js';
+const CLI_ENTRY_PATH = fileURLToPath(new URL('./index.js', import.meta.url));
+function parseCompanionLinkOutput(stdout) {
+    const linkLine = stdout.split('\n').find(line => line.startsWith('CTRL_SPC_LINK_RESULT='));
+    const folders = linkLine
+        ? JSON.parse(linkLine.slice('CTRL_SPC_LINK_RESULT='.length)).folders
+        : undefined;
+    return {
+        message: stdout.trim().split('\n').filter(Boolean).at(-1) ?? 'The folders are ready on this computer.',
+        ...(folders ? { folders } : {}),
+    };
+}
+function one(value) {
+    return Array.isArray(value) ? value[0] ?? null : value;
+}
+const execute = (command, args, options = {}) => {
+    return new Promise((resolve, reject) => {
+        execFile(command, args, {
+            cwd: options.cwd,
+            env: options.env,
+            encoding: 'utf8',
+            maxBuffer: 2 * 1024 * 1024,
+            timeout: 120_000,
+        }, (error, stdout, stderr) => {
+            if (error) {
+                const detail = String(stderr || stdout || error.message).trim();
+                reject(new Error(detail || 'CTRL+SPC could not complete the project setup.'));
+                return;
+            }
+            resolve({ stdout: String(stdout), stderr: String(stderr) });
+        });
+    });
+};
+export async function loadCompanionProjects(clientFactory = getClient) {
+    const client = await clientFactory();
+    const { data: userData, error: userError } = await client.auth.getUser();
+    if (userError || !userData.user) {
+        throw new Error('Could not load the signed-in account. Sign in again and retry.');
+    }
+    const userId = userData.user.id;
+    const machine = getMachineIdentity();
+    const [organizationsResult, projectsResult, workspacesResult, topologyResult] = await Promise.all([
+        client
+            .from('organizations')
+            .select('id,name,is_personal')
+            .order('is_personal', { ascending: false })
+            .order('name', { ascending: true }),
+        client
+            .from('projects')
+            .select('id,org_id,name,organization:organizations!projects_org_id_fkey(name)')
+            .is('archived_at', null)
+            .order('name', { ascending: true }),
+        client
+            .from('machine_workspaces')
+            .select('workspace_root,needs_relink,' +
+            'project:projects!machine_workspaces_project_id_fkey(' +
+            'id,name,organization:organizations!projects_org_id_fkey(name))')
+            .eq('user_id', userId)
+            .eq('machine_id', machine.id),
+        client
+            .from('project_repository_scopes')
+            .select('project_id')
+            .eq('active', true),
+    ]);
+    if (organizationsResult.error) {
+        throw new Error('Could not load organizations. Try again.');
+    }
+    if (workspacesResult.error) {
+        throw new Error('Could not load projects on this computer. Try again.');
+    }
+    if (projectsResult.error) {
+        throw new Error('Could not load projects. Try again.');
+    }
+    if (topologyResult.error) {
+        throw new Error('Could not load project folder details. Try again.');
+    }
+    const organizations = (organizationsResult.data ?? []).map((organization) => ({
+        id: organization.id,
+        name: organization.name,
+        isPersonal: organization.is_personal,
+    }));
+    const workspaceByProject = new Map((workspacesResult.data ?? []).flatMap((workspace) => {
+        const project = one(workspace.project);
+        if (!project)
+            return [];
+        return [[project.id, workspace]];
+    }));
+    const configuredProjectIds = new Set((topologyResult.data ?? [])
+        .map((row) => row.project_id));
+    const projects = (projectsResult.data ?? []).map((project) => {
+        const workspace = workspaceByProject.get(project.id);
+        return {
+            id: project.id,
+            orgId: project.org_id,
+            name: project.name,
+            organizationName: one(project.organization)?.name ?? '',
+            workspaceRoot: workspace?.workspace_root ?? '',
+            available: Boolean(workspace && existsSync(workspace.workspace_root)),
+            needsRelink: workspace?.needs_relink === true,
+            onThisMachine: Boolean(workspace),
+            setupState: configuredProjectIds.has(project.id) ? 'configured' : 'empty',
+        };
+    }).sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
+    return { organizations, projects };
+}
+export function summarizeDiscovery(discovery) {
+    if (discovery.repositories.length === 0) {
+        throw new Error('No project folders were found in this selection.');
+    }
+    const repositories = discovery.repositories.flatMap((repository) => {
+        const repositoryKey = repository.origin.status === 'normalized'
+            ? repository.origin.url
+            : existsSync(repository.rootPath)
+                ? ensureLocalRepositoryIdentity(repository.rootPath)
+                : `local:v1:${repository.rootPath}`;
+        const detectedComponents = repository.componentCandidates.flatMap(component => {
+            const rootPath = join(repository.rootPath, component.relativePath);
+            const role = detectRoleFingerprint(rootPath);
+            return role ? [{ component, rootPath, role }] : [];
+        });
+        const entries = detectedComponents.length > 0
+            ? detectedComponents.map(({ component, rootPath, role }) => ({
+                name: component.label,
+                rootPath,
+                repositoryRoot: repository.rootPath,
+                componentPath: component.relativePath,
+                targetId: componentTargetId(repositoryKey, component.relativePath),
+                role: { slug: role.slug, label: role.label, source: 'detected' },
+                copiesFound: repository.alternateWorktreeRoots.map(root => join(root, component.relativePath)),
+            }))
+            : [{
+                    name: basename(repository.rootPath),
+                    rootPath: repository.rootPath,
+                    repositoryRoot: repository.rootPath,
+                    componentPath: null,
+                    targetId: repositoryTargetId(repositoryKey),
+                    role: (() => {
+                        const detected = detectRoleFingerprint(repository.rootPath);
+                        return detected ? { slug: detected.slug, label: detected.label, source: 'detected' } : null;
+                    })(),
+                    copiesFound: repository.alternateWorktreeRoots,
+                }];
+        return entries.map(entry => ({
+            ...entry,
+            remoteUrl: repository.origin.status === 'normalized' ? repository.origin.url : null,
+            localOnly: repository.origin.status === 'missing_origin',
+            hasRemote: repository.origin.status === 'normalized',
+            relationship: repository.relationship.kind,
+            components: [],
+        }));
+    });
+    const usedSlugs = new Set();
+    for (const repository of repositories) {
+        if (!repository.role)
+            continue;
+        const base = repository.role.slug;
+        let suffix = 2;
+        while (usedSlugs.has(repository.role.slug)) {
+            repository.role = { ...repository.role, slug: suffixedRoleSlug(base, suffix++) };
+        }
+        usedSlugs.add(repository.role.slug);
+    }
+    return {
+        selectedPath: discovery.selectedPath,
+        scanRoot: discovery.scanRoot,
+        suggestedName: basename(discovery.scanRoot),
+        requiresGrouping: repositories.length > 1 || repositories.some((repository) => repository.componentPath !== null),
+        repositories,
+    };
+}
+export function discoverCompanionProject(paths) {
+    const selected = (Array.isArray(paths) ? paths : [paths]).map(path => path.trim()).filter(Boolean);
+    if (selected.length === 0)
+        throw new Error('Choose a folder first.');
+    try {
+        return summarizeDiscovery(mergeDiscoveries(selected.map(path => discoverRepositoryTopology(path))));
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === 'No project folders were found in this selection.')
+            throw error;
+        throw new Error('CTRL+SPC could not inspect those folders. Choose a different folder and try again.');
+    }
+}
+function assignedRoles(repositories, overrides) {
+    const used = new Set();
+    const roles = new Map();
+    for (const repository of repositories) {
+        const hasOverride = overrides !== undefined && Object.hasOwn(overrides, repository.targetId);
+        const requested = hasOverride ? overrides[repository.targetId] : repository.role;
+        if (!requested) {
+            if (hasOverride)
+                roles.set(repository.targetId, null);
+            continue;
+        }
+        const base = requested.slug;
+        let slug = base;
+        let suffix = 2;
+        while (used.has(slug))
+            slug = suffixedRoleSlug(base, suffix++);
+        used.add(slug);
+        roles.set(repository.targetId, { ...requested, slug });
+    }
+    return roles;
+}
+export function buildProjectInitArgs(request, discovery) {
+    const name = request.name.trim();
+    if (!request.orgId.trim())
+        throw new Error('Choose an organization.');
+    if (!name)
+        throw new Error('Enter a project name.');
+    const repositories = request.includedTargetIds !== undefined
+        ? discovery.repositories.filter(repository => request.includedTargetIds.includes(repository.targetId))
+        : discovery.repositories;
+    if (repositories.length === 0)
+        throw new Error('Include at least one folder.');
+    const roles = assignedRoles(repositories, request.roles);
+    const args = ['init'];
+    for (const root of [...new Set(repositories.map(repository => repository.repositoryRoot))])
+        args.push('--repo', root);
+    args.push('--org', request.orgId, '--combine', '--yes');
+    for (const repository of repositories) {
+        args.push('--target', repository.targetId);
+        const role = roles.get(repository.targetId);
+        if (role === null)
+            args.push('--clear-role', repository.targetId);
+        else if (role)
+            args.push(role.source === 'detected' ? '--detected-role' : '--role', `${repository.targetId}=${role.slug}:${role.label}`);
+    }
+    args.push('--name', name);
+    return args;
+}
+export async function createCompanionProject(request, deps = {}) {
+    const discovery = (deps.discover ?? discoverCompanionProject)(request.paths?.length ? request.paths : request.path);
+    const repositories = request.includedTargetIds !== undefined
+        ? discovery.repositories.filter(repository => request.includedTargetIds.includes(repository.targetId))
+        : discovery.repositories;
+    const roles = assignedRoles(repositories, request.roles);
+    const attaching = Boolean(request.existingProjectId && request.existingProjectMode === 'attach');
+    if (attaching && repositories.length === 0)
+        throw new Error('Include at least one folder.');
+    const args = request.existingProjectId
+        ? attaching
+            ? [
+                'init', '--project', request.existingProjectId,
+                ...[...new Set(repositories.map(repository => repository.repositoryRoot))].flatMap(root => ['--repo', root]),
+                '--combine',
+                ...repositories.flatMap(repository => {
+                    const role = roles.get(repository.targetId);
+                    return [
+                        '--target', repository.targetId,
+                        ...(role === null
+                            ? ['--clear-role', repository.targetId]
+                            : role
+                                ? [role.source === 'detected' ? '--detected-role' : '--role', `${repository.targetId}=${role.slug}:${role.label}`]
+                                : []),
+                    ];
+                }),
+                '--yes',
+            ]
+            : ['link', '--project', request.existingProjectId]
+        : buildProjectInitArgs(request, discovery);
+    if (!request.existingProjectId || attaching) {
+        args.push('--report-promotion-conflicts');
+        if (request.promotionChoice === 'use_online')
+            args.push('--skip-local-promotion');
+    }
+    let output;
+    try {
+        output = await (deps.execute ?? execute)(process.execPath, [deps.entryPath ?? CLI_ENTRY_PATH, ...args], {
+            cwd: discovery.scanRoot,
+            env: process.env,
+        });
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        const conflictLine = detail.split('\n').find(line => line.startsWith('CTRL_SPC_PROMOTION_CONFLICT='));
+        if (conflictLine) {
+            const conflict = JSON.parse(conflictLine.slice('CTRL_SPC_PROMOTION_CONFLICT='.length));
+            return {
+                message: 'This folder is already online through another project folder.',
+                promotionConflict: {
+                    existingRepositoryId: conflict.existing_repository_id,
+                    remoteKey: conflict.remote_key,
+                },
+            };
+        }
+        throw new Error('CTRL+SPC could not finish setup. Review the selected folders and try again.');
+    }
+    const linkLine = output.stdout.split('\n').find(line => line.startsWith('CTRL_SPC_LINK_RESULT='));
+    const linkResult = linkLine
+        ? JSON.parse(linkLine.slice('CTRL_SPC_LINK_RESULT='.length))
+        : null;
+    return {
+        message: request.existingProjectId
+            ? attaching
+                ? 'The folders are ready in this project.'
+                : output.stdout.trim().split('\n').filter(Boolean).at(-1) ?? 'The folder is ready in the existing project on this computer.'
+            : `${request.name.trim()} is ready on this computer.`,
+        ...(linkResult ? { folders: linkResult.folders } : {}),
+    };
+}
+export async function fetchMissingCompanionFolders(projectId, destination, deps = {}) {
+    const output = await (deps.execute ?? execute)(process.execPath, [
+        deps.entryPath ?? CLI_ENTRY_PATH,
+        'fetch', '--project', projectId, '--missing', '--destination', destination, '--yes',
+    ], { cwd: destination, env: process.env });
+    const lines = output.stdout.trim().split('\n').filter(Boolean);
+    return { message: lines.at(-1) ?? 'Missing folders are ready on this computer.' };
+}
+export async function linkCompanionFolder(projectId, repositoryId, path, deps = {}) {
+    const output = await (deps.execute ?? execute)(process.execPath, [
+        deps.entryPath ?? CLI_ENTRY_PATH,
+        'link', '--project', projectId, '--folder', `${repositoryId}=${path}`,
+    ], { cwd: path, env: process.env });
+    return parseCompanionLinkOutput(output.stdout);
+}
+export async function linkCompanionProject(projectId, deps = {}) {
+    const snapshot = await (deps.loadProjects ?? (() => loadCompanionProjects()))();
+    const project = snapshot.projects.find(candidate => candidate.id === projectId);
+    if (!project || project.setupState !== 'configured')
+        throw new Error('This project is unavailable or has no folders yet.');
+    const cwd = project.available && project.workspaceRoot ? project.workspaceRoot : deps.cwd ?? process.cwd();
+    const output = await (deps.execute ?? execute)(process.execPath, [
+        deps.entryPath ?? CLI_ENTRY_PATH, 'link', '--project', projectId,
+    ], { cwd, env: process.env });
+    return parseCompanionLinkOutput(output.stdout);
+}
+export async function chooseCompanionFolder() {
+    if (process.env.CTRL_SPC_FOLDER_PICKER_PATH)
+        return process.env.CTRL_SPC_FOLDER_PICKER_PATH;
+    try {
+        if (process.platform === 'darwin') {
+            const { stdout } = await execute('osascript', [
+                '-e', 'tell application "Finder"',
+                '-e', 'activate',
+                '-e', 'set selectedFolder to choose folder with prompt "Choose a project folder for CTRL+SPC"',
+                '-e', 'return POSIX path of selectedFolder',
+                '-e', 'end tell',
+            ]);
+            return stdout.trim().replace(/\/$/, '') || null;
+        }
+        if (process.platform === 'win32') {
+            const script = [
+                'Add-Type -AssemblyName System.Windows.Forms',
+                '$dialog = New-Object System.Windows.Forms.FolderBrowserDialog',
+                '$dialog.Description = "Choose a project folder for CTRL+SPC"',
+                'if ($dialog.ShowDialog() -eq "OK") { $dialog.SelectedPath }',
+            ].join('; ');
+            const { stdout } = await execute('powershell.exe', ['-NoProfile', '-Command', script]);
+            return stdout.trim() || null;
+        }
+        const { stdout } = await execute('zenity', [
+            '--file-selection',
+            '--directory',
+            '--title=Choose a project folder for CTRL+SPC',
+        ]);
+        return stdout.trim() || null;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (/cancel|canceled|cancelled/i.test(message))
+            return null;
+        throw error;
+    }
+}