@ctrl-spc/cli 1.1.15 → 1.2.0

package/dist/launchd.js

@@ -1,154 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { basename, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { ensureStateDir, getStatePaths } from './session.js';
-export const PLIST_LABEL = 'com.ctrl-spc.daemon';
-const INSTALL_FAILED_MESSAGE = "Couldn't install the background helper. Try again, or download the installer from the web app.";
-const STOP_FAILED_MESSAGE = "Couldn't stop the background helper.";
-const RESTART_FAILED_MESSAGE = "Couldn't restart the background helper. Try `ctrl-spc setup` again.";
-const defaultExec = (command, args) => {
-    execFileSync(command, args, { stdio: 'pipe' });
-};
-export function getPlistPath(home = homedir()) {
-    return join(home, 'Library', 'LaunchAgents', `${PLIST_LABEL}.plist`);
-}
-export function resolveBinPath(moduleUrl = import.meta.url) {
-    return fileURLToPath(new URL('../bin/ctrl-spc.js', moduleUrl));
-}
-export function buildDaemonPath(home = homedir(), envPath = process.env.PATH ?? '') {
-    const preferred = [
-        join(home, '.local', 'bin'),
-        '/opt/homebrew/bin',
-        '/usr/local/bin',
-        '/usr/bin',
-        '/bin',
-        '/usr/sbin',
-        '/sbin',
-        '/Applications/Codex.app/Contents/Resources',
-    ];
-    return [...new Set([...preferred, ...envPath.split(':').filter(Boolean)])].join(':');
-}
-export function buildPlist(nodePath, scriptPath, home = homedir(), daemonPath = buildDaemonPath(home)) {
-    const { daemonLogPath } = getStatePaths(home);
-    const user = process.env.USER || process.env.LOGNAME || basename(home);
-    return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>${escapeXml(PLIST_LABEL)}</string>
-  <key>ProgramArguments</key>
-  <array>
-    <string>${escapeXml(nodePath)}</string>
-    <string>${escapeXml(scriptPath)}</string>
-    <string>daemon</string>
-  </array>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <true/>
-  <key>EnvironmentVariables</key>
-  <dict>
-    <key>HOME</key>
-    <string>${escapeXml(home)}</string>
-    <key>LOGNAME</key>
-    <string>${escapeXml(user)}</string>
-    <key>PATH</key>
-    <string>${escapeXml(daemonPath)}</string>
-    <key>USER</key>
-    <string>${escapeXml(user)}</string>
-  </dict>
-  <key>StandardErrorPath</key>
-  <string>${escapeXml(daemonLogPath)}</string>
-  <key>StandardOutPath</key>
-  <string>${escapeXml(daemonLogPath)}</string>
-</dict>
-</plist>`;
-}
-function writeDaemonPlist(home = homedir()) {
-    const launchAgentsDir = join(home, 'Library', 'LaunchAgents');
-    const plistPath = getPlistPath(home);
-    ensureStateDir(home);
-    mkdirSync(launchAgentsDir, { recursive: true });
-    writeFileSync(plistPath, buildPlist(process.execPath, resolveBinPath(), home), 'utf8');
-    return plistPath;
-}
-export async function installDaemon() {
-    const home = homedir();
-    const uid = process.getuid?.();
-    if (uid === undefined) {
-        throw new Error(INSTALL_FAILED_MESSAGE);
-    }
-    const plistPath = writeDaemonPlist(home);
-    const domain = `gui/${uid}`;
-    try {
-        try {
-            execFileSync('launchctl', ['bootout', domain, plistPath], { stdio: 'pipe' });
-        }
-        catch {
-            // It is fine if the agent was not loaded yet.
-        }
-        execFileSync('launchctl', ['bootstrap', domain, plistPath], { stdio: 'pipe' });
-        execFileSync('launchctl', ['kickstart', '-k', `${domain}/${PLIST_LABEL}`], { stdio: 'pipe' });
-    }
-    catch {
-        throw new Error(INSTALL_FAILED_MESSAGE);
-    }
-}
-export function isDaemonInstalled(home = homedir()) {
-    return existsSync(getPlistPath(home));
-}
-export function bootoutArgs(uid, plistPath) {
-    return ['bootout', `gui/${uid}`, plistPath];
-}
-export function kickstartArgs(uid) {
-    return ['kickstart', '-k', `gui/${uid}/${PLIST_LABEL}`];
-}
-export function bootstrapArgs(uid, plistPath) {
-    return ['bootstrap', `gui/${uid}`, plistPath];
-}
-export async function stopDaemon(home = homedir(), exec = defaultExec) {
-    const uid = process.getuid?.();
-    if (uid === undefined)
-        throw new Error(STOP_FAILED_MESSAGE);
-    try {
-        exec('launchctl', bootoutArgs(uid, getPlistPath(home)));
-    }
-    catch {
-        // Already stopped — fine.
-    }
-}
-export async function restartDaemon(home = homedir(), exec = defaultExec) {
-    const uid = process.getuid?.();
-    if (uid === undefined)
-        throw new Error(RESTART_FAILED_MESSAGE);
-    const plistPath = writeDaemonPlist(home);
-    try {
-        exec('launchctl', bootoutArgs(uid, plistPath));
-    }
-    catch {
-        // Already stopped or not loaded; bootstrap below covers both cases.
-    }
-    try {
-        exec('launchctl', bootstrapArgs(uid, plistPath));
-        exec('launchctl', kickstartArgs(uid));
-    }
-    catch {
-        try {
-            exec('launchctl', kickstartArgs(uid));
-        }
-        catch {
-            throw new Error(RESTART_FAILED_MESSAGE);
-        }
-    }
-}
-function escapeXml(value) {
-    return value
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}

package/dist/lifecycle.js

@@ -1,37 +0,0 @@
-async function ensureDaemonRunning(daemon, forceRestart) {
-    if (!daemon.isDaemonInstalled()) {
-        await daemon.installDaemon();
-        return;
-    }
-    if (forceRestart)
-        await daemon.restartDaemon();
-}
-export async function runConnect(deps) {
-    const session = await deps.createSession();
-    await deps.upsertDevice(session, deps.label);
-    await ensureDaemonRunning(deps.daemon, true);
-    deps.log('Connected. This machine now shows as connected in the web app.');
-}
-export async function runReconnect(deps) {
-    const session = await deps.createSession();
-    await deps.setDeviceStatus(session, 'connected');
-    await ensureDaemonRunning(deps.daemon, true);
-    deps.log('Reconnected - no email needed.');
-}
-export async function runDisconnect(deps) {
-    const session = await deps.createSession();
-    await deps.setDeviceStatus(session, 'disconnected');
-    await deps.daemon.stopDaemon();
-    deps.log('Disconnected. Run `ctrl-spc reconnect` to come back online - no email needed.');
-}
-export async function runStatus(deps) {
-    try {
-        await deps.createSession();
-    }
-    catch (err) {
-        deps.log(err instanceof Error ? err.message : 'This machine is not connected.');
-        return;
-    }
-    const installed = deps.daemon.isDaemonInstalled() ? 'yes' : 'no';
-    deps.log(`Connected (session valid). Background helper installed: ${installed}.`);
-}

package/dist/mcpConfig.js

@@ -1,12 +0,0 @@
-import { writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-export function writeMcpConfig(repoRoot) {
-    writeFileSync(join(repoRoot, '.mcp.json'), JSON.stringify({
-        mcpServers: {
-            'ctrl-spc': {
-                command: 'ctrl-spc',
-                args: ['serve'],
-            },
-        },
-    }, null, 2));
-}

package/dist/repo.js

@@ -1,52 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { basename, join } from 'node:path';
-import { fingerprintRepo, normalizeRemoteUrl } from '@ctrl-spc/mcp-server/fingerprint';
-function git(cwd, args) {
-    return execFileSync('git', args, { cwd, encoding: 'utf8' }).trim();
-}
-export function detectRepo(cwd) {
-    const root = git(cwd, ['rev-parse', '--show-toplevel']);
-    const rootCommit = git(root, ['rev-list', '--max-parents=0', 'HEAD']).split('\n')[0];
-    let remoteUrl = '';
-    try {
-        remoteUrl = git(root, ['config', '--get', 'remote.origin.url']);
-    }
-    catch {
-        remoteUrl = '';
-    }
-    const normalizedRemoteUrl = normalizeRemoteUrl(remoteUrl);
-    return {
-        root,
-        rootCommit,
-        remoteUrl,
-        normalizedRemoteUrl,
-        fingerprint: fingerprintRepo(rootCommit, normalizedRemoteUrl),
-    };
-}
-export function detectMonorepoProjects(root) {
-    const rootPackage = join(root, 'package.json');
-    const hasWorkspaceMarker = existsSync(join(root, 'pnpm-workspace.yaml')) ||
-        existsSync(join(root, 'turbo.json')) ||
-        existsSync(join(root, 'nx.json')) ||
-        existsSync(join(root, 'lerna.json')) ||
-        (existsSync(rootPackage) && Boolean(JSON.parse(readFileSync(rootPackage, 'utf8')).workspaces));
-    if (!hasWorkspaceMarker)
-        return [{ name: basename(root), path: root }];
-    const packagesDir = join(root, 'packages');
-    if (!existsSync(packagesDir))
-        return [{ name: basename(root), path: root }];
-    const projects = readdirSync(packagesDir, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => join(packagesDir, entry.name))
-        .filter((path) => existsSync(join(path, 'package.json')))
-        .map((path) => ({ name: basename(path), path }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-    return projects.length > 0 ? projects : [{ name: basename(root), path: root }];
-}
-export function parseProjectSelection(input, projects) {
-    if (!input.trim())
-        return [];
-    const indexes = new Set(input.split(',').map((value) => Number(value.trim()) - 1));
-    return projects.filter((_, index) => indexes.has(index));
-}

package/dist/session.js

@@ -1,58 +0,0 @@
-import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { randomUUID } from 'node:crypto';
-import * as path from 'node:path';
-import { homedir } from 'node:os';
-export function getStatePaths(options) {
-    const { stateDir, pathApi } = resolveStateDir(options);
-    return {
-        stateDir,
-        statePath: pathApi.join(stateDir, 'machine.json'),
-        daemonLogPath: pathApi.join(stateDir, 'daemon.log'),
-    };
-}
-export function ensureStateDir(options) {
-    const { stateDir } = getStatePaths(options);
-    mkdirSync(stateDir, { recursive: true });
-    return stateDir;
-}
-export function loadMachineState(statePath = getStatePaths().statePath) {
-    try {
-        const parsed = JSON.parse(readFileSync(statePath, 'utf8'));
-        if (typeof parsed.machineId === 'string' &&
-            typeof parsed.accessToken === 'string' &&
-            typeof parsed.refreshToken === 'string') {
-            return {
-                machineId: parsed.machineId,
-                accessToken: parsed.accessToken,
-                refreshToken: parsed.refreshToken,
-            };
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-export function saveMachineState(state, statePath = getStatePaths().statePath) {
-    mkdirSync(path.dirname(statePath), { recursive: true });
-    const tmpPath = `${statePath}.tmp`;
-    writeFileSync(tmpPath, JSON.stringify(state, null, 2), { mode: 0o600 });
-    chmodSync(tmpPath, 0o600);
-    renameSync(tmpPath, statePath);
-}
-export function getOrCreateMachineId(statePath = getStatePaths().statePath) {
-    return loadMachineState(statePath)?.machineId ?? randomUUID();
-}
-function resolveStateDir(options) {
-    if (typeof options === 'string') {
-        return { stateDir: path.join(options, '.ctrl-spc'), pathApi: path };
-    }
-    const platform = options?.platform ?? process.platform;
-    const pathApi = platform === 'win32' ? path.win32 : path;
-    const home = options?.home ?? homedir();
-    if (platform === 'win32') {
-        const appData = options?.appData ?? process.env.APPDATA ?? pathApi.join(home, 'AppData', 'Roaming');
-        return { stateDir: pathApi.join(appData, 'ctrl-spc'), pathApi };
-    }
-    return { stateDir: pathApi.join(home, '.ctrl-spc'), pathApi };
-}

package/dist/setup.js

@@ -1,60 +0,0 @@
-import { hostname } from 'node:os';
-import { stdin as input, stdout as output } from 'node:process';
-import * as readline from 'node:readline/promises';
-const UNSUPPORTED_PLATFORM_MESSAGE = 'Automatic install supports macOS and Windows. (Linux support coming soon.)';
-const SEND_EMAIL_FAILED_MESSAGE = "Couldn't send the sign-in email. Check your connection and try again.";
-export async function runSetup() {
-    if (process.platform !== 'darwin' && process.platform !== 'win32') {
-        exitWithMessage(UNSUPPORTED_PLATFORM_MESSAGE);
-        return;
-    }
-    const email = await promptForEmail();
-    if (!email) {
-        exitWithMessage(SEND_EMAIL_FAILED_MESSAGE);
-        return;
-    }
-    const { authenticate } = await import('./auth.js');
-    const { createSessionClient, upsertDevice } = await import('./devices.js');
-    const installer = process.platform === 'darwin'
-        ? await import('./launchd.js')
-        : await import('./windows-service.js');
-    try {
-        await completeSetup({
-            email,
-            label: hostname(),
-            onReadyForAuth: () => {
-                console.log('Check your email for a sign-in link to connect this machine.');
-            },
-            authenticate: async (addr) => { await authenticate(addr); },
-            registerDevice: async (label) => {
-                const session = await createSessionClient();
-                await upsertDevice(session, label);
-            },
-            installDaemon: installer.installDaemon,
-        });
-    }
-    catch (err) {
-        exitWithMessage(err instanceof Error ? err.message : SEND_EMAIL_FAILED_MESSAGE);
-        return;
-    }
-    console.log('Connected - you can close this terminal. Your machine now shows as connected in the web app.');
-}
-async function promptForEmail() {
-    const rl = readline.createInterface({ input, output });
-    try {
-        return (await rl.question('Enter your Control Space email: ')).trim();
-    }
-    finally {
-        rl.close();
-    }
-}
-function exitWithMessage(message) {
-    console.log(message);
-    process.exitCode = 1;
-}
-export async function completeSetup(options) {
-    options.onReadyForAuth?.();
-    await options.authenticate(options.email);
-    await options.registerDevice(options.label);
-    await options.installDaemon();
-}

package/dist/spawner.js

@@ -1,140 +0,0 @@
-import { spawn } from 'node:child_process';
-import { PassThrough } from 'node:stream';
-import { assembleCommand, READINESS_REPLY } from './flagAssembler.js';
-// agent_type -> spawn mode is derived, never stored (spec decision 8).
-function isRemote(agentType) {
-    return agentType === 'claude-code' || agentType === 'codex';
-}
-export function makeSpawner(deps) {
-    const timeoutMs = deps.readinessTimeoutMs ?? 45_000;
-    const backoffMs = deps.retryBackoffMs ?? 30_000;
-    const lastAttempt = new Map(); // requestId -> timestamp; in-memory back-off
-    async function awaitReadiness(handle) {
-        return new Promise((resolve) => {
-            let buf = '';
-            let errBuf = '';
-            let done = false;
-            const finish = (ready) => {
-                if (!done) {
-                    done = true;
-                    clearTimeout(timer);
-                    resolve({ ready, stdout: buf, stderr: errBuf });
-                }
-            };
-            const timer = setTimeout(() => finish(false), timeoutMs);
-            handle.stdout.on('data', (chunk) => {
-                buf += chunk.toString();
-                if (buf.includes(READINESS_REPLY))
-                    finish(true);
-            });
-            handle.stderr?.on('data', (chunk) => { errBuf += chunk.toString(); });
-            handle.stdout.on('end', () => finish(buf.includes(READINESS_REPLY)));
-            handle.stdout.on('error', () => finish(false));
-            handle.stderr?.on('error', () => { });
-        });
-    }
-    async function resolveLocalPath(projectId) {
-        const { data } = await deps.session.client
-            .from('project_links')
-            .select('value')
-            .eq('project_id', projectId)
-            .eq('kind', 'path')
-            .limit(1);
-        return data?.[0]?.value ?? null;
-    }
-    async function markRequest(row, status) {
-        await deps.session.client.from('spawn_requests').update({ status }).eq('id', row.id);
-    }
-    async function fulfil(row, pid, stdout, handle) {
-        const { data, error } = await deps.session.client.from('sessions').insert({
-            project_id: row.project_id,
-            device_id: deps.session.machineId,
-            connection_state: 'connected',
-            awaiting_input: false,
-            agent_type: row.agent_type,
-            model: row.model,
-            effort: row.effort,
-            permission_mode: row.permission_mode,
-            allowed_tools: row.allowed_tools,
-            pid,
-            last_seen_at: new Date(deps.now()).toISOString(),
-        }).select('id').single();
-        if (error)
-            throw new Error(`Session insert failed: ${error.message}`);
-        const sessionId = data.id;
-        const { error: messageError } = await deps.session.client.from('agent_messages').insert({
-            project_id: row.project_id,
-            session_id: sessionId,
-            role: 'agent',
-            kind: 'ready',
-            content: stdout,
-        });
-        if (messageError)
-            throw new Error(`Ready message insert failed: ${messageError.message}`);
-        deps.ownedSessions?.set(sessionId, { projectId: row.project_id, sessionId, handle });
-        await markRequest(row, 'fulfilled');
-    }
-    async function processOne(row) {
-        if (!isRemote(row.agent_type))
-            return; // manual types are never auto-fulfilled
-        if (row.target_device_id && row.target_device_id !== deps.session.machineId)
-            return;
-        const last = lastAttempt.get(row.id);
-        if (last !== undefined && deps.now() - last < backoffMs)
-            return;
-        lastAttempt.set(row.id, deps.now());
-        const cwd = await resolveLocalPath(row.project_id);
-        if (!cwd) {
-            deps.log(`No local path for project ${row.project_id}; skipping`);
-            return;
-        }
-        await markRequest(row, 'processing');
-        const { cmd, args } = assembleCommand(row);
-        const handle = deps.spawnAgent(cmd, args, cwd);
-        const result = await awaitReadiness(handle);
-        if (!result.ready) {
-            handle.kill();
-            deps.log(`Readiness gate failed for ${row.id}; will retry. stdout=${quoteSnippet(result.stdout)} stderr=${quoteSnippet(result.stderr)}`);
-            await markRequest(row, 'failed');
-            return;
-        }
-        await fulfil(row, handle.pid, result.stdout, handle);
-        deps.log(`Spawned agent for project ${row.project_id} (request ${row.id})`);
-    }
-    async function processPending() {
-        const { data, error } = await deps.session.client
-            .from('spawn_requests')
-            .select('id, project_id, target_device_id, agent_type, model, effort, permission_mode, allowed_tools')
-            .eq('status', 'pending');
-        if (error) {
-            deps.log(`spawn_requests scan failed: ${error.message}`);
-            return;
-        }
-        for (const row of (data ?? [])) {
-            try {
-                await processOne(row);
-            }
-            catch (err) {
-                deps.log(err instanceof Error ? err.message : `spawn failed for ${row.id}`);
-            }
-        }
-    }
-    return { processPending };
-}
-// Real spawn handle backed by node:child_process, used by the daemon (not in unit tests).
-export function nodeSpawnAgent(cmd, args, cwd) {
-    const child = spawn(cmd, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
-    const stdout = new PassThrough();
-    const stderr = new PassThrough();
-    child.stdout?.pipe(stdout);
-    child.stderr?.pipe(stderr);
-    child.on('error', (err) => {
-        stdout.destroy(err);
-        stderr.end();
-    });
-    return { pid: child.pid ?? -1, stdout, stderr, kill: () => child.kill() };
-}
-function quoteSnippet(value) {
-    const trimmed = value.replace(/\s+/g, ' ').trim().slice(0, 500);
-    return JSON.stringify(trimmed);
-}

package/dist/windows-service.js

@@ -1,142 +0,0 @@
-import { existsSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { homedir } from 'node:os';
-import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { ensureStateDir, getStatePaths } from './session.js';
-export const WINDOWS_SERVICE_NAME = 'ctrl-spc-daemon';
-const INSTALL_FAILED_MESSAGE = "Couldn't install the background helper. Try again, or download the installer from the web app.";
-const STOP_FAILED_MESSAGE = "Couldn't stop the background helper.";
-export function resolveBinPath(moduleUrl = import.meta.url) {
-    return fileURLToPath(new URL('../bin/ctrl-spc.js', moduleUrl));
-}
-export function buildWindowsServiceConfig(options = {}) {
-    const userProfile = options.userProfile ?? process.env.USERPROFILE ?? homedir();
-    const appData = options.appData ?? process.env.APPDATA ?? path.win32.join(userProfile, 'AppData', 'Roaming');
-    const scriptPath = options.scriptPath ?? resolveBinPath();
-    const { stateDir } = getStatePaths({ platform: 'win32', home: userProfile, appData });
-    return {
-        name: WINDOWS_SERVICE_NAME,
-        description: 'Control Space background daemon',
-        script: scriptPath,
-        scriptOptions: 'daemon',
-        execPath: options.nodePath ?? process.execPath,
-        workingDirectory: windowsDirname(scriptPath),
-        logpath: stateDir,
-        wait: 5,
-        grow: 0.25,
-        maxRestarts: 3,
-        stopparentfirst: true,
-        stoptimeout: 30,
-        env: [
-            { name: 'APPDATA', value: appData },
-            { name: 'USERPROFILE', value: userProfile },
-        ],
-    };
-}
-export async function installDaemon() {
-    if (process.platform !== 'win32') {
-        throw new Error(INSTALL_FAILED_MESSAGE);
-    }
-    const userProfile = process.env.USERPROFILE ?? homedir();
-    const appData = process.env.APPDATA ?? path.win32.join(userProfile, 'AppData', 'Roaming');
-    const stateDir = ensureStateDir({ platform: 'win32', home: userProfile, appData });
-    const service = createWindowsService(buildWindowsServiceConfig({ userProfile, appData }));
-    await installAndStartService(service, path.win32.join(stateDir, 'service'));
-}
-export function installAndStartService(service, serviceDir) {
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        let startRequested = false;
-        const timeout = setTimeout(() => {
-            finish(() => reject(new Error(INSTALL_FAILED_MESSAGE)));
-        }, 60_000);
-        service.once('install', startService);
-        service.once('alreadyinstalled', startService);
-        service.once('invalidinstallation', () => finish(() => reject(new Error(INSTALL_FAILED_MESSAGE))));
-        service.once('start', () => finish(resolve));
-        service.once('error', (err) => {
-            if (startRequested && isAlreadyStartedError(err)) {
-                finish(resolve);
-                return;
-            }
-            finish(() => reject(new Error(INSTALL_FAILED_MESSAGE)));
-        });
-        try {
-            service.install(serviceDir);
-        }
-        catch {
-            finish(() => reject(new Error(INSTALL_FAILED_MESSAGE)));
-        }
-        function startService() {
-            startRequested = true;
-            try {
-                service.start();
-            }
-            catch {
-                finish(() => reject(new Error(INSTALL_FAILED_MESSAGE)));
-            }
-        }
-        function finish(done) {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeout);
-            done();
-        }
-    });
-}
-export function stopService(service) {
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const timeout = setTimeout(() => finish(() => reject(new Error(STOP_FAILED_MESSAGE))), 60_000);
-        service.once('stop', () => finish(resolve));
-        service.once('error', () => finish(() => reject(new Error(STOP_FAILED_MESSAGE))));
-        try {
-            service.stop();
-        }
-        catch {
-            finish(() => reject(new Error(STOP_FAILED_MESSAGE)));
-        }
-        function finish(done) {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeout);
-            done();
-        }
-    });
-}
-export async function stopDaemon() {
-    if (process.platform !== 'win32')
-        throw new Error(STOP_FAILED_MESSAGE);
-    const userProfile = process.env.USERPROFILE ?? homedir();
-    const appData = process.env.APPDATA ?? path.win32.join(userProfile, 'AppData', 'Roaming');
-    const service = createWindowsService(buildWindowsServiceConfig({ userProfile, appData }));
-    await stopService(service);
-}
-export async function restartDaemon() {
-    await stopDaemon();
-    // installDaemon is idempotent: 'alreadyinstalled' -> start.
-    await installDaemon();
-}
-export function isDaemonInstalled() {
-    const userProfile = process.env.USERPROFILE ?? homedir();
-    const appData = process.env.APPDATA ?? path.win32.join(userProfile, 'AppData', 'Roaming');
-    const { stateDir } = getStatePaths({ platform: 'win32', home: userProfile, appData });
-    return existsSync(path.win32.join(stateDir, 'service', 'ctrlspcdaemon.exe'));
-}
-function createWindowsService(config) {
-    const require = createRequire(import.meta.url);
-    const { Service } = require('node-windows');
-    return new Service(config);
-}
-function isAlreadyStartedError(err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return message.toLowerCase().includes('already') && message.toLowerCase().includes('started');
-}
-function windowsDirname(filePath) {
-    return /^[A-Za-z]:[\\/]/.test(filePath) || filePath.includes('\\')
-        ? path.win32.dirname(filePath)
-        : path.dirname(filePath);
-}

package/node_modules/@ctrl-spc/mcp-server/dist/claimResolver.d.ts

@@ -1,24 +0,0 @@
-import type { SupabaseClient } from '@supabase/supabase-js';
-export type ClaimInput = {
-    name: string;
-    remoteUrl: string;
-    localPath: string;
-    fingerprint: string;
-    orgId: string | null;
-    isMonorepoSubproject?: boolean;
-};
-export type ClaimResult = {
-    ok: true;
-    projectId: string;
-    projectName: string;
-    claimed: boolean;
-} | {
-    ok: false;
-    message: string;
-};
-export declare function mapClaimError(message: string): string;
-export declare function claimProject(client: SupabaseClient, input: ClaimInput): Promise<ClaimResult>;
-export declare function releaseProjectClaim(client: SupabaseClient, projectId: string): Promise<{
-    ok: boolean;
-    message?: string;
-}>;