@ctrl-spc/cli 1.1.14 → 1.2.0

package/dist/env.js

@@ -0,0 +1,5 @@
+/** Baked-in Supabase project defaults, overridable per Global Constraints. */
+export const SUPABASE_URL = process.env.CTRL_SPC_SUPABASE_URL || 'https://gdioapkjgnlddsutysne.supabase.co';
+export const SUPABASE_KEY = process.env.CTRL_SPC_SUPABASE_KEY || 'sb_publishable_izf3buHACC2LJKm2JH96YQ_safmL1k0';
+/** MCP server port (Task 4 binds here); override via `CTRL_SPC_PORT`. */
+export const MCP_PORT = Number(process.env.CTRL_SPC_PORT) || 4571;

package/dist/git.js

@@ -0,0 +1,70 @@
+import { execFileSync } from 'node:child_process';
+/**
+ * Normalizes a git remote URL to a canonical `host/path` key (no scheme,
+ * lowercase throughout — hosts are case-insensitive and GitHub/GitLab paths
+ * redirect case-insensitively, so one repo should always map to one key).
+ * Non-default ports are kept (`host:port/path`); 22/443/80 are stripped.
+ *
+ * Verbatim from the task brief (spec §11 open item):
+ *   git@github.com:User/Repo.git      -> github.com/user/repo
+ *   https://github.com/User/Repo/     -> github.com/user/repo
+ *   ssh://git@Host.com:2222/x/y.git   -> host.com:2222/x/y
+ *   https://user:pass@host/x/y.git    -> host/x/y
+ */
+export function normalizeRemoteUrl(raw) {
+    let s = raw.trim();
+    const scp = /^(?:[^@/]+@)([^:/]+):(?!\/\/)(.+)$/.exec(s); // scp-like git@host:path
+    if (scp)
+        s = `${scp[1]}/${scp[2]}`;
+    else {
+        s = s.replace(/^[a-z+]+:\/\//i, ''); // scheme
+        s = s.replace(/^[^@/]+(?::[^@/]*)?@/, ''); // user[:pass]@
+    }
+    s = s.replace(/\/+$/, '').replace(/\.git$/i, '');
+    s = s.replace(/^([^/:]+):(22|443|80)(?=\/)/, '$1'); // default ports
+    return s.toLowerCase();
+}
+/**
+ * Runs `git remote get-url origin` in `cwd`. Returns `null` if there's no
+ * `origin` remote, `cwd` isn't a git repository, or `git` isn't on PATH —
+ * callers treat all of those the same way ("no remote here").
+ */
+export function currentRepoRemote(cwd) {
+    try {
+        const out = execFileSync('git', ['remote', 'get-url', 'origin'], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const trimmed = out.trim();
+        return trimmed || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Looks up the project registered for the current repo's git remote, scoped
+ * to the signed-in user's orgs by RLS (`projects_select` only surfaces rows
+ * in orgs the user is a member of). Returns `null` when there's no remote
+ * here, or no project the user can see is keyed on it. Throws on a genuine
+ * query/network error — that's distinct from "not registered" and callers
+ * (`init`/`link`) must not treat it as such.
+ */
+export async function resolveProject(client, cwd) {
+    const remote = currentRepoRemote(cwd);
+    if (!remote)
+        return null;
+    const key = normalizeRemoteUrl(remote);
+    const { data, error } = await client
+        .from('projects')
+        .select('id, org_id, name, organizations(name)')
+        .eq('git_remote_url', key)
+        .maybeSingle();
+    if (error)
+        throw new Error(`Failed to look up project for ${key}: ${error.message}`);
+    if (!data)
+        return null;
+    const row = data;
+    return { id: row.id, orgId: row.org_id, name: row.name, orgName: row.organizations?.name ?? '' };
+}

package/dist/index.js

@@ -1,74 +1,58 @@
-const [, , command, ...args] = process.argv;
-async function loadDaemonControl() {
-    const mod = process.platform === 'darwin'
-        ? await import('./launchd.js')
-        : await import('./windows-service.js');
-    return {
-        installDaemon: mod.installDaemon,
-        restartDaemon: mod.restartDaemon,
-        stopDaemon: mod.stopDaemon,
-        isDaemonInstalled: mod.isDaemonInstalled,
-    };
-}
-async function lifecycleDeps() {
-    const { hostname } = await import('node:os');
-    const { createSessionClient, upsertDevice, setDeviceStatus } = await import('./devices.js');
-    return {
-        createSession: createSessionClient,
-        upsertDevice,
-        setDeviceStatus,
-        daemon: await loadDaemonControl(),
-        label: hostname(),
-        log: (msg) => console.log(msg),
-    };
-}
-async function main() {
-    if (command === 'setup') {
-        const { runSetup } = await import('./setup.js');
-        await runSetup();
-        return;
-    }
-    if (command === 'daemon') {
-        const { runDaemon } = await import('./daemon.js');
-        await runDaemon();
-        return;
-    }
-    if (command === 'init') {
-        const { runInit } = await import('./init.js');
-        await runInit(args);
-        return;
-    }
-    if (command === 'serve') {
-        const { startMcpServer } = await import('@ctrl-spc/mcp-server');
-        await startMcpServer();
-        return;
+#!/usr/bin/env node
+import { login } from './commands/login.js';
+import { logout } from './commands/logout.js';
+import { init } from './commands/init.js';
+import { link } from './commands/link.js';
+import { fetchRepository } from './commands/fetch.js';
+import { run } from './commands/run.js';
+export const HELP_TEXT = `ctrl-spc — CTRL+SPC CLI
+
+Usage:
+  ctrl-spc login    Sign in via the browser and store a session
+  ctrl-spc logout   Remove the stored session from this machine
+  ctrl-spc init     Discover repositories and explicitly group them into projects
+  ctrl-spc link     Reconcile a project's full topology after grouping changes
+                    [--project <project-id>]
+  ctrl-spc fetch    Clone and link one unavailable project repository
+                    [repository-id] [--project <project-id>] [--destination <path>] [--yes]
+  ctrl-spc          Run the local agent process (presence + MCP server)
+  ctrl-spc --help   Show this help text
+`;
+export async function main(argv = process.argv.slice(2)) {
+    const command = argv[0];
+    switch (command) {
+        case 'login':
+            await login();
+            return;
+        case 'logout':
+            logout();
+            return;
+        case 'init':
+            await init(argv.slice(1));
+            return;
+        case 'link':
+            await link(argv.slice(1));
+            return;
+        case 'fetch':
+            await fetchRepository(argv.slice(1));
+            return;
+        case '--help':
+        case '-h':
+            console.log(HELP_TEXT);
+            return;
+        case undefined:
+            await run();
+            return;
+        default:
+            console.error(`Unknown command: ${command}\n`);
+            console.log(HELP_TEXT);
+            process.exitCode = 1;
+            return;
     }
-    if (command === 'status') {
-        const { runStatus } = await import('./lifecycle.js');
-        const deps = await lifecycleDeps();
-        await runStatus({ createSession: deps.createSession, daemon: deps.daemon, log: deps.log });
-        return;
-    }
-    if (command === 'connect') {
-        const { runConnect } = await import('./lifecycle.js');
-        await runConnect(await lifecycleDeps());
-        return;
-    }
-    if (command === 'reconnect') {
-        const { runReconnect } = await import('./lifecycle.js');
-        await runReconnect(await lifecycleDeps());
-        return;
-    }
-    if (command === 'disconnect') {
-        const { runDisconnect } = await import('./lifecycle.js');
-        await runDisconnect(await lifecycleDeps());
-        return;
-    }
-    console.error('Usage: ctrl-spc <setup|status|connect|reconnect|disconnect|init|serve>');
-    process.exitCode = 1;
 }
-main().catch((err) => {
-    console.error(err instanceof Error ? err.message : 'Unexpected ctrl-spc error');
-    process.exit(1);
-});
-export {};
+if (!process.env.VITEST) {
+    main().catch((err) => {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    });
+}