@ctrl-spc/cli 1.2.1 → 1.2.3

package/dist/commands/init.js

@@ -6,6 +6,7 @@ import { getClient } from '../supabase.js';
 import { ask, select } from '../prompt.js';
 import { buildTopologyTargets, componentTargetId, discoverRepositoryTopology, planExplicitGrouping, readGroupingManifest, repositoryTargetId, } from '../topology.js';
 import { upsertProjectLink } from './link.js';
+import { registerMachineWorkspace } from './run.js';
 function setGrouping(flags, grouping) {
     if (flags.grouping) {
         throw new Error(`Choose exactly one grouping option: --combine, --split, or --manifest <file>.`);
@@ -370,8 +371,16 @@ export async function init(argv = []) {
                 console.log(`Created project "${result.project_name}" in "${result.org_name ?? orgLabel}" — ${key}`);
                 break;
         }
-        await upsertProjectLink(client, userId, result.project_id, repository.rootPath);
-        console.log(`Linked — local path ${repository.rootPath}`);
+        try {
+            const machine = getMachineIdentity();
+            await registerMachineWorkspace(client, userId, result.project_id, machine, repository.rootPath);
+            await upsertProjectLink(client, userId, result.project_id, repository.rootPath);
+            console.log(`Linked — local path ${repository.rootPath}`);
+        }
+        catch (err) {
+            console.error(`Failed to initialize this machine: ${err instanceof Error ? err.message : String(err)}`);
+            process.exitCode = 1;
+        }
         return;
     }
     try {

package/dist/commands/run.js

@@ -15,6 +15,34 @@ import { discoverRepositoryTopology } from '../topology.js';
 function mcpUrl() {
     return `http://localhost:${MCP_PORT}/mcp`;
 }
+/** Retires the pre-1.2 background launcher, whose pinned repo checkout can
+ * otherwise reclaim the MCP port after an upgrade or reboot. */
+export function retireLegacyDaemon(deps = {}) {
+    if (process.platform !== 'darwin' && !deps.launchAgentPath)
+        return false;
+    const path = deps.launchAgentPath ?? join(homedir(), 'Library', 'LaunchAgents', 'com.ctrl-spc.daemon.plist');
+    if (!(deps.exists ?? existsSync)(path))
+        return false;
+    const read = deps.read ?? ((target) => readFileSync(target, 'utf8'));
+    const contents = read(path);
+    if (!contents.includes('com.ctrl-spc.daemon') || !contents.includes('daemon'))
+        return false;
+    const uid = deps.uid ?? process.getuid?.();
+    if (uid !== undefined) {
+        try {
+            const bootout = deps.bootout ?? ((domain, target) => {
+                execFileSync('launchctl', ['bootout', domain, target], { stdio: 'ignore' });
+            });
+            bootout(`gui/${uid}`, path);
+        }
+        catch {
+            // An unloaded service is already safe; still remove its stale launcher.
+        }
+    }
+    const remove = deps.remove ?? rmSync;
+    remove(path);
+    return true;
+}
 export async function existingBrokerStatus(machineId, port = MCP_PORT, fetcher = fetch) {
     try {
         const response = await fetcher(`http://127.0.0.1:${port}/health`, {
@@ -127,6 +155,67 @@ export async function legacyCurrentProjectCandidates(client, cwd) {
         throw new Error(`Could not resolve the current repository: ${error.message}`);
     return (data ?? []).sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
 }
+async function loadActiveProjectRemoteKeys(client, projectId) {
+    const { data, error } = await client
+        .from('project_repository_scopes')
+        .select('scope:repository_scopes!project_repository_scopes_repository_scope_id_fkey(' +
+        'repository:repositories!repository_scopes_repository_id_fkey(remote_key))')
+        .eq('project_id', projectId)
+        .eq('active', true);
+    if (error)
+        throw new Error(`Could not load project repositories: ${error.message}`);
+    const remotes = new Set();
+    for (const row of (data ?? [])) {
+        const scope = one(row.scope);
+        const repository = scope ? one(scope.repository) : null;
+        if (repository?.remote_key)
+            remotes.add(repository.remote_key);
+    }
+    return remotes;
+}
+/**
+ * Moves verifiable pre-machine project links onto this machine automatically.
+ * A legacy path is trusted only when it still exists as a Git checkout and its
+ * origin resolves back to the explicitly linked project. Stale paths from a
+ * different computer are ignored.
+ */
+export async function recoverLegacyProjectLinks(client, userId, machine, initializedProjectIds, deps = {}) {
+    const { data, error } = await client
+        .from('project_links')
+        .select('project_id,local_path')
+        .eq('user_id', userId);
+    if (error)
+        throw new Error(`Could not load legacy project links: ${error.message}`);
+    const observe = deps.observeWorkspace ?? observeLocalWorkspace;
+    const loadExpectedRemoteKeys = deps.loadExpectedRemoteKeys ?? loadActiveProjectRemoteKeys;
+    const register = deps.registerWorkspace ?? registerMachineWorkspace;
+    const recovered = [];
+    const links = [...(data ?? [])]
+        .sort((left, right) => left.project_id.localeCompare(right.project_id) || left.local_path.localeCompare(right.local_path));
+    for (const link of links) {
+        if (initializedProjectIds.has(link.project_id))
+            continue;
+        let observation;
+        try {
+            observation = observe(link.local_path);
+        }
+        catch {
+            continue;
+        }
+        const expectedRemoteKeys = await loadExpectedRemoteKeys(client, link.project_id);
+        const observedRemoteKeys = new Set(observation.checkouts
+            .map((checkout) => checkout.remoteKey)
+            .filter((remote) => remote !== null));
+        if (![...expectedRemoteKeys].some((remote) => observedRemoteKeys.has(remote)))
+            continue;
+        await register(client, userId, link.project_id, machine, link.local_path, {
+            observeWorkspace: () => observation,
+        });
+        initializedProjectIds.add(link.project_id);
+        recovered.push(link.project_id);
+    }
+    return recovered;
+}
 function checkoutPlan(workspaceId, repositories, observation, existing, inspectCheckout, verifiedAt) {
     const rows = new Map();
     const availableRepositoryIds = new Set();
@@ -545,6 +634,9 @@ function installShutdownHandler(presence, mcpServer) {
  * sessions; begin_work binds each session to the pasted task's project.
  */
 export async function run() {
+    if (retireLegacyDaemon()) {
+        console.log('Removed obsolete CTRL+SPC background launcher.');
+    }
     const cwd = process.cwd();
     const client = await getClient();
     const { data: userData, error: userError } = await client.auth.getUser();
@@ -563,6 +655,11 @@ export async function run() {
         return localObservation;
     };
     let projects = await loadMachineProjects(client, userId, machine.id);
+    const recoveredProjects = await recoverLegacyProjectLinks(client, userId, machine, new Set(projects.map((project) => project.id)));
+    if (recoveredProjects.length > 0) {
+        console.log(`Recovered ${recoveredProjects.length} initialized ${recoveredProjects.length === 1 ? 'project' : 'projects'} for this machine.`);
+        projects = await loadMachineProjects(client, userId, machine.id);
+    }
     const legacyCandidates = await legacyCurrentProjectCandidates(client, cwd);
     if (legacyCandidates.length === 1 && !projects.some((project) => project.id === legacyCandidates[0].id)) {
         await registerMachineWorkspace(client, userId, legacyCandidates[0].id, machine, cwd, {

package/dist/mcp.js

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
 import { createServer as createHttpServer } from 'node:http';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
@@ -372,7 +373,7 @@ export async function beginAgentRunHandler(deps, session, args) {
         const projects = await accessibleProjects(deps, session.machineId);
         if (!projects.some((project) => project.id === taskProjectId)) {
             return errorResult(`Task "${args.task_id}" belongs to a project that is not initialized on this machine. ` +
-                'Initialize or link that project before beginning work.');
+                `From that project's checkout, run \`ctrl-spc link --project ${taskProjectId}\`.`);
         }
         const result = await must(deps.client.rpc('begin_agent_run', {
             p_task: args.task_id,
@@ -879,7 +880,8 @@ export async function listTasksHandler(deps, args = {}) {
     try {
         const projects = await accessibleProjects(deps);
         if (args.project_id && !projects.some((project) => project.id === args.project_id)) {
-            return errorResult(`Project "${args.project_id}" is not initialized on this machine.`);
+            return errorResult(`Project "${args.project_id}" is not initialized on this machine. ` +
+                `From its checkout, run \`ctrl-spc link --project ${args.project_id}\`.`);
         }
         const projectIds = args.project_id ? [args.project_id] : projects.map((project) => project.id);
         if (projectIds.length === 0)
@@ -933,7 +935,8 @@ export async function getTaskHandler(deps, _attribution, args, machineId) {
                 return errorResult(`No task or artifact found for id "${args.id}".`);
         }
         if (!allowedProjectIds.has(row.project_id)) {
-            return errorResult(`The resolved item belongs to project "${row.project_id}", which is not initialized on this machine.`);
+            return errorResult(`The resolved item belongs to project "${row.project_id}", which is not initialized on this machine. ` +
+                `From that project's checkout, run \`ctrl-spc link --project ${row.project_id}\`.`);
         }
         const task = parseTaskRow(row);
         const topologyMachineId = machineId ?? deps.machineId;
@@ -1281,7 +1284,7 @@ export function protocolPromptHandler() {
 // ---------------------------------------------------------------------------
 const IDLE_TIMEOUT_MS = 10 * 60 * 1000;
 const HEARTBEAT_INTERVAL_MS = 30 * 1000;
-export const BROKER_VERSION = '1.2.1';
+export const BROKER_VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
 async function readJsonBody(req) {
     const chunks = [];
     for await (const chunk of req)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ctrl-spc/cli",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "CTRL+SPC CLI — per-machine agent for browser login, project linking, presence, and the local MCP server.",
   "engines": {
     "node": ">=22"
@@ -23,7 +23,6 @@
     "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"
   },