@ctrl-spc/cli 1.1.15 → 1.2.0

package/dist/agents.js

@@ -0,0 +1,54 @@
+import { accessSync, constants } from 'node:fs';
+import { homedir } from 'node:os';
+import { delimiter, join } from 'node:path';
+const AGENT_COMMANDS = ['claude', 'codex'];
+const DEFAULT_FALLBACK_PATHS = {
+    claude: [
+        join(homedir(), '.local', 'bin', 'claude'),
+        '/opt/homebrew/bin/claude',
+        '/usr/local/bin/claude',
+    ],
+    codex: [
+        process.env.CODEX_CLI_PATH ?? '',
+        '/Applications/ChatGPT.app/Contents/Resources/codex',
+        join(homedir(), '.local', 'bin', 'codex'),
+        '/opt/homebrew/bin/codex',
+        '/usr/local/bin/codex',
+    ].filter(Boolean),
+};
+/** True if `command` resolves to an executable file in some directory on `PATH`. */
+function isExecutable(path) {
+    try {
+        accessSync(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolves the executable used for detection and MCP registration. PATH is
+ * preferred, then well-known install locations. The macOS Codex app bundles
+ * its CLI inside the application, so PATH-only detection misses it in a
+ * normal Terminal session.
+ */
+export function resolveAgentCommand(command, options = {}) {
+    const dirs = (options.path ?? process.env.PATH ?? '').split(delimiter).filter(Boolean);
+    for (const dir of dirs) {
+        const path = join(dir, command);
+        try {
+            if (isExecutable(path))
+                return path;
+        }
+        catch { /* continue */ }
+    }
+    const fallbackPaths = options.fallbackPaths?.[command] ?? DEFAULT_FALLBACK_PATHS[command];
+    return fallbackPaths.find(isExecutable) ?? null;
+}
+/**
+ * Detects which supported agents (spec §4: "claude / codex on PATH") are
+ * installed and available on this machine, in a stable order.
+ */
+export function detectAgents(options = {}) {
+    return AGENT_COMMANDS.filter((agent) => Boolean(resolveAgentCommand(agent, options)));
+}

package/dist/collision.js

@@ -0,0 +1,44 @@
+/**
+ * Canonical repository-relative path used by work reservations.
+ *
+ * The empty string represents the repository root. Absolute paths and parent
+ * traversal are rejected before a claim reaches Postgres, so two agents use
+ * the same segment-aware overlap rules on every platform.
+ */
+export function normalizeReservationPath(input) {
+    if (input.includes('\0'))
+        throw new Error('Reservation paths cannot contain NUL bytes.');
+    const normalizedSeparators = input.trim().replaceAll('\\', '/');
+    if (/^[a-zA-Z]:\//.test(normalizedSeparators) || normalizedSeparators.startsWith('/')) {
+        throw new Error(`Reservation path must be relative to its repository: ${input}`);
+    }
+    const parts = [];
+    for (const part of normalizedSeparators.split('/')) {
+        if (!part || part === '.')
+            continue;
+        if (part === '..')
+            throw new Error(`Reservation path cannot traverse outside its repository: ${input}`);
+        parts.push(part);
+    }
+    return parts.join('/');
+}
+/** Segment-aware prefix overlap: `web` overlaps `web/src`, not `webapp`. */
+export function reservationPathsOverlap(left, right) {
+    const a = normalizeReservationPath(left);
+    const b = normalizeReservationPath(right);
+    if (!a || !b)
+        return true;
+    return a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`);
+}
+/** Returns the first conflicting pair, or null when all proposed scopes are disjoint. */
+export function findReservationOverlap(existing, proposed) {
+    for (const candidate of proposed) {
+        for (const active of existing) {
+            if (active.repositoryId === candidate.repositoryId &&
+                reservationPathsOverlap(active.path, candidate.path)) {
+                return { existing: active, proposed: candidate };
+            }
+        }
+    }
+    return null;
+}

package/dist/commands/fetch.js

@@ -0,0 +1,213 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { getMachineIdentity } from '../config.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 parseFetchArgs(argv) {
+    const flags = { yes: false };
+    for (let i = 0; i < argv.length; i++) {
+        const token = argv[i];
+        if (token === '--yes' || token === '-y') {
+            flags.yes = true;
+            continue;
+        }
+        if (token === '--project' || token === '--destination') {
+            const value = argv[i + 1];
+            if (!value || value.startsWith('--'))
+                throw new Error(`${token} requires a value`);
+            if (token === '--project') {
+                if (flags.project)
+                    throw new Error('--project may only be provided once');
+                flags.project = value;
+            }
+            else {
+                if (flags.destination)
+                    throw new Error('--destination may only be provided once');
+                flags.destination = value;
+            }
+            i++;
+            continue;
+        }
+        if (token.startsWith('-'))
+            throw new Error(`Unknown argument: ${token}`);
+        if (flags.repository)
+            throw new Error('Provide only one repository id');
+        flags.repository = token;
+    }
+    return flags;
+}
+function one(value) {
+    return Array.isArray(value) ? value[0] ?? null : value;
+}
+export async function loadProjectFetchTargets(client, projectId) {
+    const { data, error } = await client
+        .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))')
+        .eq('project_id', projectId)
+        .eq('active', true);
+    if (error)
+        throw new Error(`Could not load project repositories: ${error.message}`);
+    const targets = new Map();
+    for (const raw of (data ?? [])) {
+        const scope = one(raw.scope);
+        const repository = scope ? one(scope.repository) : null;
+        if (!repository)
+            continue;
+        const target = targets.get(repository.id) ?? {
+            repositoryId: repository.id,
+            repositoryName: repository.name,
+            remoteKey: repository.remote_key,
+            scopeIds: [],
+            required: false,
+        };
+        target.scopeIds.push(raw.repository_scope_id);
+        target.required ||= raw.required;
+        targets.set(repository.id, target);
+    }
+    return [...targets.values()]
+        .map((target) => ({ ...target, scopeIds: [...new Set(target.scopeIds)].sort() }))
+        .sort((left, right) => left.repositoryName.localeCompare(right.repositoryName) || left.repositoryId.localeCompare(right.repositoryId));
+}
+export function cloneUrlForRemoteKey(remoteKey) {
+    const slash = remoteKey.indexOf('/');
+    if (slash < 1)
+        throw new Error(`Repository remote is not fetchable: ${remoteKey}`);
+    const host = remoteKey.slice(0, slash);
+    const path = remoteKey.slice(slash + 1);
+    return host.includes(':')
+        ? `ssh://git@${host}/${path}.git`
+        : `https://${host}/${path}.git`;
+}
+async function chooseFetchTarget(targets, repositoryId) {
+    if (repositoryId) {
+        const match = targets.find((target) => target.repositoryId === repositoryId || target.scopeIds.includes(repositoryId));
+        if (!match)
+            throw new Error(`Repository or scope "${repositoryId}" is not active in this project.`);
+        return match;
+    }
+    if (targets.length === 0)
+        throw new Error('This project has no missing repositories to fetch.');
+    if (targets.length === 1)
+        return targets[0];
+    if (!process.stdin.isTTY) {
+        throw new Error(`Choose one missing repository id: ` +
+            targets.map((target) => `${target.repositoryName} (${target.repositoryId})`).join(', '));
+    }
+    return select('Which missing repository should CTRL+SPC fetch?', targets.map((target) => ({
+        label: `${target.repositoryName} · ${target.required ? 'required' : 'optional'} · ${target.remoteKey}`,
+        value: target,
+    })));
+}
+async function confirmFetch(target, destination, approved) {
+    if (approved)
+        return true;
+    if (!process.stdin.isTTY) {
+        throw new Error('Fetching requires explicit approval. Re-run with --yes after reviewing the repository and destination.');
+    }
+    return select(`Clone ${target.remoteKey} to ${destination}?`, [
+        { label: 'No, leave it unavailable', value: false },
+        { label: 'Yes, clone and link it', value: true },
+    ]);
+}
+function defaultClone(remote, destination) {
+    execFileSync('git', ['clone', remote, destination], { stdio: 'inherit' });
+}
+export async function fetchRepository(argv = [], deps = {}) {
+    let flags;
+    try {
+        flags = parseFetchArgs(argv);
+    }
+    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]');
+        process.exitCode = 1;
+        return;
+    }
+    const cwd = process.cwd();
+    const observe = deps.observeWorkspace ?? observeLocalWorkspace;
+    const observation = observe(cwd);
+    const client = await (deps.getClient ?? getClient)();
+    const { data: userData, error: userError } = await client.auth.getUser();
+    if (userError || !userData.user) {
+        console.error(`Could not resolve the signed-in user: ${userError?.message ?? 'no user returned'}`);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const observedRemoteKeys = observation.checkouts
+            .map((checkout) => checkout.remoteKey)
+            .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 allTargets = await loadProjectFetchTargets(client, project.id);
+        const { data: checkoutData, error: checkoutError } = await client
+            .from('repository_checkouts')
+            .select('repository_id,availability,verified_remote_key')
+            .eq('machine_workspace_id', workspace.workspaceId);
+        if (checkoutError)
+            throw new Error(`Could not load local repository checkouts: ${checkoutError.message}`);
+        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}`));
+        if (flags.repository) {
+            const requested = allTargets.find((target) => target.repositoryId === flags.repository || target.scopeIds.includes(flags.repository));
+            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 (!checkout) {
+            const remote = cloneUrlForRemoteKey(target.remoteKey);
+            try {
+                ;
+                (deps.clone ?? defaultClone)(remote, destination);
+            }
+            catch (err) {
+                throw new Error(`Clone failed; the repository was not linked. ` +
+                    `${err instanceof Error ? err.message : String(err)}`);
+            }
+            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',
+            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));
+        process.exitCode = 1;
+    }
+}