@ctrl-spc/cli 1.1.2 → 1.1.3

package/dist/daemon.js

@@ -1,16 +1,37 @@
-import { disconnect, heartbeat } from './devices.js';
+import { createSessionClient, heartbeat, setDeviceStatus } from './devices.js';
 import { loadMachineState } from './session.js';
 export const HEARTBEAT_INTERVAL_MS = 30_000;
-const SESSION_WAIT_INTERVAL_MS = 5_000;
+const SESSION_RETRY_INTERVAL_MS = 5_000;
+export async function heartbeatOnce(session, deps) {
+    try {
+        await deps.heartbeat(session);
+        return session;
+    }
+    catch (err) {
+        deps.log(err instanceof Error ? err.message : 'Heartbeat failed');
+        // A re-run of `setup` may have rotated the token on disk; rebuild and let the next beat retry.
+        try {
+            return await deps.createSession();
+        }
+        catch {
+            return session;
+        }
+    }
+}
 export async function runDaemon() {
-    const state = await waitForMachineState();
+    const deps = {
+        createSession: createSessionClient,
+        heartbeat,
+        log: (msg) => process.stderr.write(`${msg}\n`),
+    };
+    let session = await acquireSession(deps);
     let shuttingDown = false;
     const shutdown = async () => {
         if (shuttingDown)
             return;
         shuttingDown = true;
         try {
-            await disconnect(state);
+            await setDeviceStatus(session, 'disconnected');
         }
         catch {
             // Best effort: a hard kill is covered by heartbeat staleness.
@@ -19,26 +40,24 @@ export async function runDaemon() {
     };
     process.once('SIGINT', () => void shutdown());
     process.once('SIGTERM', () => void shutdown());
-    await writeHeartbeat(state);
+    session = await heartbeatOnce(session, deps);
     while (true) {
         await sleep(HEARTBEAT_INTERVAL_MS);
-        await writeHeartbeat(state);
+        session = await heartbeatOnce(session, deps);
     }
 }
-export async function waitForMachineState() {
-    let state = loadMachineState();
-    while (!state) {
-        await sleep(SESSION_WAIT_INTERVAL_MS);
-        state = loadMachineState();
-    }
-    return state;
-}
-async function writeHeartbeat(state) {
-    try {
-        await heartbeat(state);
-    }
-    catch (err) {
-        process.stderr.write(`${err instanceof Error ? err.message : 'Heartbeat failed'}\n`);
+async function acquireSession(deps) {
+    while (true) {
+        while (!loadMachineState()) {
+            await sleep(SESSION_RETRY_INTERVAL_MS);
+        }
+        try {
+            return await deps.createSession();
+        }
+        catch (err) {
+            deps.log(err instanceof Error ? err.message : 'Session unavailable');
+            await sleep(SESSION_RETRY_INTERVAL_MS);
+        }
     }
 }
 function sleep(ms) {

package/dist/devices.js

@@ -1,66 +1,64 @@
 import { createHash } from 'node:crypto';
 import { createSupabaseClient } from './supabase.js';
-import { saveMachineState } from './session.js';
-const REGISTER_FAILED_MESSAGE = "Connected to your account but couldn't register this machine. Check your connection and re-run setup.";
-const SESSION_EXPIRED_MESSAGE = 'That sign-in link expired. Run `ctrl-spc setup` again to get a fresh one.';
+import { loadMachineState, saveMachineState } from './session.js';
+export const NOT_CONNECTED_MESSAGE = 'This machine is not connected. Run `ctrl-spc setup` first.';
+export const SESSION_EXPIRED_MESSAGE = 'Your machine session expired. Run `ctrl-spc setup` to reconnect.';
+const REGISTER_FAILED_MESSAGE = "Connected to your account but couldn't register this machine. Check your connection and try again.";
 export function hashToken(token) {
     return createHash('sha256').update(token).digest('hex');
 }
-export async function upsertDevice(state, label) {
-    const client = createSupabaseClient();
-    const activeState = await restoreSession(client, state);
-    const { data, error: userError } = await client.auth.getUser();
-    const user = data.user;
-    if (userError || !user) {
-        throw new Error(REGISTER_FAILED_MESSAGE);
-    }
-    const { error } = await client.from('devices').upsert({
-        id: activeState.machineId,
-        owner_id: user.id,
-        label,
-        token_hash: hashToken(activeState.refreshToken),
-        status: 'connected',
-        last_seen_at: new Date().toISOString(),
-    }, { onConflict: 'id' });
-    if (error) {
-        throw new Error(REGISTER_FAILED_MESSAGE);
-    }
-}
-export async function heartbeat(state) {
-    const client = createSupabaseClient();
-    const activeState = await restoreSession(client, state);
-    const { error } = await client
-        .from('devices')
-        .update({
-        last_seen_at: new Date().toISOString(),
-        status: 'connected',
-    })
-        .eq('id', activeState.machineId);
-    if (error) {
-        throw new Error(`Heartbeat failed: ${error.message}`);
-    }
-}
-export async function disconnect(state) {
-    const client = createSupabaseClient();
-    const activeState = await restoreSession(client, state);
-    const { error } = await client.from('devices').update({ status: 'disconnected' }).eq('id', activeState.machineId);
-    if (error) {
-        throw new Error(`Disconnect failed: ${error.message}`);
-    }
+export function sessionToState(machineId, session) {
+    return { machineId, accessToken: session.access_token, refreshToken: session.refresh_token };
 }
-async function restoreSession(client, state) {
+export async function createSessionClient(deps = {}) {
+    const loadState = deps.loadState ?? loadMachineState;
+    const saveState = deps.saveState ?? saveMachineState;
+    const createClient = deps.createClient ?? createSupabaseClient;
+    const state = loadState();
+    if (!state)
+        throw new Error(NOT_CONNECTED_MESSAGE);
+    const client = createClient();
+    const machineId = state.machineId;
+    client.auth.onAuthStateChange((_event, session) => {
+        if (session)
+            saveState(sessionToState(machineId, session));
+    });
     const { data, error } = await client.auth.setSession({
         access_token: state.accessToken,
         refresh_token: state.refreshToken,
     });
-    if (error || !data.session) {
+    if (error || !data.session)
         throw new Error(SESSION_EXPIRED_MESSAGE);
-    }
-    if (data.session.access_token !== state.accessToken ||
-        data.session.refresh_token !== state.refreshToken) {
-        state.accessToken = data.session.access_token;
-        state.refreshToken = data.session.refresh_token;
-        saveMachineState(state);
-    }
-    return state;
+    return { client, machineId };
+}
+export async function heartbeat(session) {
+    const { error } = await session.client
+        .from('devices')
+        .update({ last_seen_at: new Date().toISOString(), status: 'connected' })
+        .eq('id', session.machineId);
+    if (error)
+        throw new Error(`Heartbeat failed: ${error.message}`);
+}
+export async function setDeviceStatus(session, status) {
+    const { error } = await session.client.from('devices').update({ status }).eq('id', session.machineId);
+    if (error)
+        throw new Error(`Update failed: ${error.message}`);
+}
+export async function upsertDevice(session, label, loadState = loadMachineState) {
+    const { data, error: userError } = await session.client.auth.getUser();
+    if (userError || !data.user)
+        throw new Error(REGISTER_FAILED_MESSAGE);
+    const state = loadState();
+    if (!state)
+        throw new Error(NOT_CONNECTED_MESSAGE);
+    const { error } = await session.client.from('devices').upsert({
+        id: session.machineId,
+        owner_id: data.user.id,
+        label,
+        token_hash: hashToken(state.refreshToken),
+        status: 'connected',
+        last_seen_at: new Date().toISOString(),
+    }, { onConflict: 'id' });
+    if (error)
+        throw new Error(REGISTER_FAILED_MESSAGE);
 }

package/dist/index.js

@@ -1,4 +1,27 @@
 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');
@@ -20,7 +43,28 @@ async function main() {
         await startMcpServer();
         return;
     }
-    console.error('Usage: ctrl-spc <setup|daemon|init|serve>');
+    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) => {

package/dist/launchd.js

@@ -6,6 +6,11 @@ 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`);
 }
@@ -66,6 +71,34 @@ export async function installDaemon() {
 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 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);
+    try {
+        exec('launchctl', kickstartArgs(uid));
+    }
+    catch {
+        throw new Error(RESTART_FAILED_MESSAGE);
+    }
+}
 function escapeXml(value) {
     return value
         .replace(/&/g, '&')

package/dist/lifecycle.js

@@ -0,0 +1,37 @@
+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/session.js

@@ -1,4 +1,4 @@
-import { chmodSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+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';
@@ -35,8 +35,10 @@ export function loadMachineState(statePath = getStatePaths().statePath) {
 }
 export function saveMachineState(state, statePath = getStatePaths().statePath) {
     mkdirSync(path.dirname(statePath), { recursive: true });
-    writeFileSync(statePath, JSON.stringify(state, null, 2), { mode: 0o600 });
-    chmodSync(statePath, 0o600);
+    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();

package/dist/setup.js

@@ -14,7 +14,7 @@ export async function runSetup() {
         return;
     }
     const { authenticate } = await import('./auth.js');
-    const { upsertDevice } = await import('./devices.js');
+    const { createSessionClient, upsertDevice } = await import('./devices.js');
     const installer = process.platform === 'darwin'
         ? await import('./launchd.js')
         : await import('./windows-service.js');
@@ -22,12 +22,15 @@ export async function runSetup() {
         await completeSetup({
             email,
             label: hostname(),
-            installDaemon: installer.installDaemon,
             onReadyForAuth: () => {
                 console.log('Check your email for a sign-in link to connect this machine.');
             },
-            authenticate,
-            upsertDevice,
+            authenticate: async (addr) => { await authenticate(addr); },
+            registerDevice: async (label) => {
+                const session = await createSessionClient();
+                await upsertDevice(session, label);
+            },
+            installDaemon: installer.installDaemon,
         });
     }
     catch (err) {
@@ -50,8 +53,8 @@ function exitWithMessage(message) {
     process.exitCode = 1;
 }
 export async function completeSetup(options) {
-    await options.installDaemon();
     options.onReadyForAuth?.();
-    const state = await options.authenticate(options.email);
-    await options.upsertDevice(state, options.label);
+    await options.authenticate(options.email);
+    await options.registerDevice(options.label);
+    await options.installDaemon();
 }

package/dist/supabase.js

@@ -5,7 +5,7 @@ export const SUPABASE_FUNCTIONS_URL = `${SUPABASE_URL}/functions/v1`;
 export function createSupabaseClient() {
     return createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
         auth: {
-            autoRefreshToken: false,
+            autoRefreshToken: true,
             detectSessionInUrl: false,
             persistSession: false,
         },

package/dist/windows-service.js

@@ -6,6 +6,7 @@ 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));
 }
@@ -85,6 +86,40 @@ export function installAndStartService(service, serviceDir) {
         }
     });
 }
+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');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ctrl-spc/cli",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Control Space CLI - machine setup and background daemon",
   "type": "module",
   "files": [