@ctrl-spc/cli 1.3.2 → 1.3.3

package/dist/commands/fetch.js

@@ -1,11 +1,36 @@
 import { execFileSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
-import { basename, join, resolve } from 'node:path';
+import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { getMachineIdentity } from '../config.js';
+import { isLocalRepositoryKey } from '../git.js';
 import { select } from '../prompt.js';
 import { getClient } from '../supabase.js';
 import { inspectLocalCheckout, observeLocalWorkspace, registerMachineWorkspace, } from './run.js';
 import { chooseTopologyProject } from './link.js';
+export function missingFetchDestinations(targets, destinationRoot) {
+    const root = resolve(destinationRoot);
+    const used = new Set();
+    return new Map(targets.map(target => {
+        const remoteName = basename(target.remoteKey);
+        const cleaned = target.repositoryName
+            .replace(/[\u0000-\u001f/\\:]+/g, '-')
+            .replace(/^[. -]+|[. ]+$/g, '')
+            .trim() || remoteName || 'folder';
+        let name = cleaned.slice(0, 80);
+        let suffix = 2;
+        while (used.has(name.toLowerCase())) {
+            const ending = `-${suffix++}`;
+            name = `${cleaned.slice(0, 80 - ending.length)}${ending}`;
+        }
+        used.add(name.toLowerCase());
+        const destination = resolve(root, name);
+        const rel = relative(root, destination);
+        if (rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+            throw new Error(`CTRL+SPC could not create a safe folder name for ${target.repositoryName}.`);
+        }
+        return [target.repositoryId, destination];
+    }));
+}
 export function parseFetchArgs(argv) {
     const flags = { yes: false };
     for (let i = 0; i < argv.length; i++) {
@@ -14,6 +39,10 @@ export function parseFetchArgs(argv) {
             flags.yes = true;
             continue;
         }
+        if (token === '--missing') {
+            flags.missing = true;
+            continue;
+        }
         if (token === '--project' || token === '--destination') {
             const value = argv[i + 1];
             if (!value || value.startsWith('--'))
@@ -37,6 +66,8 @@ export function parseFetchArgs(argv) {
             throw new Error('Provide only one repository id');
         flags.repository = token;
     }
+    if (flags.missing && flags.repository)
+        throw new Error('--missing cannot be combined with a repository id');
     return flags;
 }
 function one(value) {
@@ -47,7 +78,7 @@ export async function loadProjectFetchTargets(client, projectId) {
         .from('project_repository_scopes')
         .select('repository_scope_id,required,' +
         'scope:repository_scopes!project_repository_scopes_repository_scope_id_fkey(' +
-        'repository:repositories!repository_scopes_repository_id_fkey(id,name,remote_key))')
+        'repository:repositories!repository_scopes_repository_id_fkey(id,name,remote_key,source_kind))')
         .eq('project_id', projectId)
         .eq('active', true);
     if (error)
@@ -64,6 +95,7 @@ export async function loadProjectFetchTargets(client, projectId) {
             remoteKey: repository.remote_key,
             scopeIds: [],
             required: false,
+            sourceKind: repository.source_kind ?? (isLocalRepositoryKey(repository.remote_key) ? 'local' : 'remote'),
         };
         target.scopeIds.push(raw.repository_scope_id);
         target.required ||= raw.required;
@@ -74,6 +106,9 @@ export async function loadProjectFetchTargets(client, projectId) {
         .sort((left, right) => left.repositoryName.localeCompare(right.repositoryName) || left.repositoryId.localeCompare(right.repositoryId));
 }
 export function cloneUrlForRemoteKey(remoteKey) {
+    if (isLocalRepositoryKey(remoteKey)) {
+        throw new Error('This repository has no Git remote. Copy its folder to this machine, then link it in the CTRL+SPC local app.');
+    }
     const slash = remoteKey.indexOf('/');
     if (slash < 1)
         throw new Error(`Repository remote is not fetchable: ${remoteKey}`);
@@ -117,6 +152,11 @@ async function confirmFetch(target, destination, approved) {
 function defaultClone(remote, destination) {
     execFileSync('git', ['clone', remote, destination], { stdio: 'inherit' });
 }
+function normalizeInspection(result) {
+    if (result === null)
+        return { status: 'missing' };
+    return 'status' in result ? result : { status: 'observed', checkout: result };
+}
 export async function fetchRepository(argv = [], deps = {}) {
     let flags;
     try {
@@ -124,7 +164,7 @@ export async function fetchRepository(argv = [], deps = {}) {
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));
-        console.error('Usage: ctrl-spc fetch [repository-id] [--project <project-id>] [--destination <path>] [--yes]');
+        console.error('Usage: ctrl-spc fetch [repository-id] [--project <project-id>] [--missing] [--destination <path>] [--yes]');
         process.exitCode = 1;
         return;
     }
@@ -144,7 +184,12 @@ export async function fetchRepository(argv = [], deps = {}) {
             .filter((remote) => remote !== null);
         const project = await chooseTopologyProject(client, flags.project, observedRemoteKeys, { action: 'fetch', allowAllWhenNoMatch: true });
         const machine = getMachineIdentity();
-        const workspace = await registerMachineWorkspace(client, userData.user.id, project.id, machine, cwd, { observeWorkspace: () => observation, inspectCheckout: deps.inspectCheckout });
+        const workspace = await registerMachineWorkspace(client, userData.user.id, project.id, machine, cwd, {
+            observeWorkspace: () => observation,
+            inspectCheckout: deps.inspectCheckout
+                ? path => normalizeInspection(deps.inspectCheckout(path))
+                : undefined,
+        });
         const allTargets = await loadProjectFetchTargets(client, project.id);
         const { data: checkoutData, error: checkoutError } = await client
             .from('repository_checkouts')
@@ -155,56 +200,76 @@ export async function fetchRepository(argv = [], deps = {}) {
         const available = new Set((checkoutData ?? [])
             .filter((checkout) => checkout.availability === 'available')
             .map((checkout) => `${checkout.repository_id}\u0000${checkout.verified_remote_key ?? ''}`));
-        const missingTargets = allTargets.filter((target) => !available.has(`${target.repositoryId}\u0000${target.remoteKey}`));
+        const missingTargets = allTargets.filter((target) => target.sourceKind === 'remote' &&
+            !available.has(`${target.repositoryId}\u0000${target.remoteKey}`));
         if (flags.repository) {
             const requested = allTargets.find((target) => target.repositoryId === flags.repository || target.scopeIds.includes(flags.repository));
+            if (requested?.sourceKind === 'local') {
+                throw new Error(`${requested.repositoryName} has no Git remote. Copy its folder to this machine, then link it in the CTRL+SPC local app.`);
+            }
             if (requested && !missingTargets.includes(requested)) {
                 throw new Error(`${requested.repositoryName} is already available on this machine; nothing was cloned.`);
             }
         }
-        const target = await chooseFetchTarget(missingTargets, flags.repository);
-        const folderName = basename(target.remoteKey);
-        const destination = resolve(cwd, flags.destination ?? join(observation.workspaceRoot, folderName));
-        const inspect = deps.inspectCheckout ?? inspectLocalCheckout;
-        let checkout = existsSync(destination) ? inspect(destination) : null;
-        if (existsSync(destination) && checkout?.remoteKey !== target.remoteKey) {
-            throw new Error(`Destination already exists but is not ${target.remoteKey}: ${destination}. ` +
-                'Nothing was cloned or linked.');
-        }
-        const approved = await (deps.confirm ?? confirmFetch)(target, destination, flags.yes);
-        if (!approved) {
-            console.log(`Fetch declined. ${target.repositoryName} remains unavailable; nothing was cloned or linked.`);
-            return;
+        if (flags.missing) {
+            for (const local of allTargets.filter(target => target.sourceKind === 'local' && !available.has(`${target.repositoryId}\u0000${target.remoteKey}`))) {
+                console.log(`${local.repositoryName} is only on another computer. Copy that folder here, then open the CTRL+SPC local app.`);
+            }
         }
-        if (!checkout) {
-            const remote = cloneUrlForRemoteKey(target.remoteKey);
-            try {
+        const targets = flags.missing ? missingTargets : [await chooseFetchTarget(missingTargets, flags.repository)];
+        const destinationRoot = resolve(cwd, flags.destination ?? observation.workspaceRoot);
+        const missingDestinations = flags.missing ? missingFetchDestinations(targets, destinationRoot) : null;
+        const inspect = deps.inspectCheckout ?? inspectLocalCheckout;
+        for (const target of targets) {
+            const destination = flags.missing
+                ? missingDestinations.get(target.repositoryId)
+                : resolve(cwd, flags.destination ?? join(observation.workspaceRoot, basename(target.remoteKey)));
+            const initialInspection = existsSync(destination) || !deps.inspectCheckout
+                ? normalizeInspection(inspect(destination))
+                : { status: 'missing' };
+            if (initialInspection.status === 'unreachable') {
+                throw new Error(initialInspection.reason === 'drive_missing'
+                    ? 'The destination drive is not connected.'
+                    : 'CTRL+SPC cannot open the destination folder. Check its permissions and try again.');
+            }
+            let checkout = initialInspection.status === 'observed' ? initialInspection.checkout : null;
+            if (existsSync(destination) && checkout?.remoteKey !== target.remoteKey) {
+                throw new Error(`The destination folder is already used by different code: ${destination}.`);
+            }
+            const approved = await (deps.confirm ?? confirmFetch)(target, destination, flags.yes);
+            if (!approved) {
+                console.log(`${target.repositoryName} remains unavailable; nothing was changed.`);
+                continue;
+            }
+            if (!checkout) {
                 ;
-                (deps.clone ?? defaultClone)(remote, destination);
+                (deps.clone ?? defaultClone)(cloneUrlForRemoteKey(target.remoteKey), destination);
+                if (deps.initializeSubmodules)
+                    deps.initializeSubmodules(destination);
+                else if (!deps.clone)
+                    execFileSync('git', ['submodule', 'update', '--init'], { cwd: destination, stdio: 'inherit' });
+                const result = normalizeInspection(inspect(destination));
+                checkout = result.status === 'observed' ? result.checkout : null;
             }
-            catch (err) {
-                throw new Error(`Clone failed; the repository was not linked. ` +
-                    `${err instanceof Error ? err.message : String(err)}`);
+            if (!checkout || checkout.remoteKey !== target.remoteKey) {
+                throw new Error(`CTRL+SPC could not verify the fetched folder at ${destination}.`);
             }
-            checkout = inspect(destination);
-        }
-        if (!checkout || checkout.remoteKey !== target.remoteKey) {
-            throw new Error(`Clone completed but origin verification failed for ${destination}. ` +
-                `Expected ${target.remoteKey}; found ${checkout?.remoteKey ?? 'no origin'}. The checkout was not linked.`);
+            const { error: registerError } = await client.from('repository_checkouts').upsert({
+                machine_workspace_id: workspace.workspaceId,
+                repository_id: target.repositoryId,
+                local_path: checkout.localPath,
+                availability: 'available',
+                unavailable_reason: null,
+                verified_remote_key: checkout.remoteKey,
+                head_sha: checkout.headSha,
+                observed_root_commit_sha: checkout.rootCommitSha ?? null,
+                is_worktree: checkout.isWorktree,
+                verified_at: new Date().toISOString(),
+            }, { onConflict: 'machine_workspace_id,repository_id,local_path' });
+            if (registerError)
+                throw new Error(`Could not register fetched folder: ${registerError.message}`);
+            console.log(`Fetched ${target.repositoryName} — ${checkout.localPath}`);
         }
-        const { error: registerError } = await client.from('repository_checkouts').upsert({
-            machine_workspace_id: workspace.workspaceId,
-            repository_id: target.repositoryId,
-            local_path: checkout.localPath,
-            availability: 'available',
-            verified_remote_key: checkout.remoteKey,
-            head_sha: checkout.headSha,
-            is_worktree: checkout.isWorktree,
-            verified_at: new Date().toISOString(),
-        }, { onConflict: 'machine_workspace_id,repository_id,local_path' });
-        if (registerError)
-            throw new Error(`Could not register fetched checkout: ${registerError.message}`);
-        console.log(`Fetched and linked ${target.repositoryName} — ${checkout.localPath}`);
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));