@latentforce/shift 1.0.1 → 1.0.3

package/build/cli/commands/status.js

@@ -0,0 +1,51 @@
+import { getApiKey, readProjectConfig, isGuestKey } from '../../utils/config.js';
+import { getDaemonStatus } from '../../daemon/daemon-manager.js';
+export async function statusCommand() {
+    const projectRoot = process.cwd();
+    console.log('\n╔════════════════════════════════════════════╗');
+    console.log('║              Shift Status                  ║');
+    console.log('╚════════════════════════════════════════════╝\n');
+    // Check API key
+    const apiKey = getApiKey();
+    if (!apiKey) {
+        console.log('API Key:     ❌ Not configured');
+        console.log('\nRun "shift start" to configure your API key.\n');
+        return;
+    }
+    if (isGuestKey()) {
+        console.log('API Key:     ✓ Guest key');
+    }
+    else {
+        console.log('API Key:     ✓ Configured');
+    }
+    // Check project config
+    const projectConfig = readProjectConfig(projectRoot);
+    if (!projectConfig) {
+        console.log('Project:     ❌ Not configured');
+        console.log('\nRun "shift start" to configure this project.\n');
+        return;
+    }
+    console.log(`Project:     ${projectConfig.project_name}`);
+    console.log(`Project ID:  ${projectConfig.project_id}`);
+    // Check agents
+    if (projectConfig.agents && projectConfig.agents.length > 0) {
+        console.log(`Agents:      ${projectConfig.agents.length} configured`);
+        projectConfig.agents.forEach((agent) => {
+            console.log(`             - ${agent.agent_name} (${agent.agent_type})`);
+        });
+    }
+    // Check daemon status
+    const status = getDaemonStatus(projectRoot);
+    if (!status.running) {
+        console.log('Daemon:      ❌ Not running');
+        console.log('\nRun "shift start" to start the daemon.\n');
+        return;
+    }
+    console.log(`Daemon:      ✓ Running (PID: ${status.pid})`);
+    console.log(`WebSocket:   ${status.connected ? '✓ Connected' : '⚠️  Disconnected'}`);
+    if (status.startedAt) {
+        const startedAt = new Date(status.startedAt);
+        console.log(`Started:     ${startedAt.toLocaleString()}`);
+    }
+    console.log('');
+}

package/build/cli/commands/stop.js

@@ -0,0 +1,18 @@
+import { getDaemonStatus, stopDaemon } from '../../daemon/daemon-manager.js';
+export async function stopCommand() {
+    const projectRoot = process.cwd();
+    console.log('\nStopping Shift daemon...\n');
+    // Check if daemon is running
+    const status = getDaemonStatus(projectRoot);
+    if (!status.running) {
+        console.log('Daemon is not running.');
+        return;
+    }
+    console.log(`Stopping daemon (PID: ${status.pid})...`);
+    const result = await stopDaemon(projectRoot);
+    if (!result.success) {
+        console.error(`Failed to stop daemon: ${result.error}`);
+        process.exit(1);
+    }
+    console.log('Daemon stopped successfully.\n');
+}

package/build/daemon/daemon-manager.js

@@ -0,0 +1,136 @@
+import { spawn } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+import { fileURLToPath } from 'url';
+import { readDaemonPid, writeDaemonPid, removeDaemonPid, removeDaemonStatus, readDaemonStatus, isProcessRunning, } from '../utils/config.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function getDaemonScriptPath() {
+    // The daemon.js will be in the same directory as daemon-manager.js after compilation
+    return path.join(__dirname, 'daemon.js');
+}
+export async function startDaemon(projectRoot, projectId, apiKey) {
+    // Check if daemon is already running
+    const existingPid = readDaemonPid(projectRoot);
+    if (existingPid && isProcessRunning(existingPid)) {
+        return {
+            success: false,
+            error: `Daemon already running with PID ${existingPid}`,
+            pid: existingPid,
+        };
+    }
+    // Clean up stale files if process is not running
+    if (existingPid) {
+        removeDaemonPid(projectRoot);
+        removeDaemonStatus(projectRoot);
+    }
+    const daemonScript = getDaemonScriptPath();
+    if (!fs.existsSync(daemonScript)) {
+        return {
+            success: false,
+            error: `Daemon script not found at ${daemonScript}`,
+        };
+    }
+    try {
+        // Spawn detached daemon process
+        const child = spawn(process.execPath, [daemonScript, projectRoot, projectId, apiKey], {
+            detached: true,
+            stdio: 'ignore',
+            cwd: projectRoot,
+        });
+        if (!child.pid) {
+            return {
+                success: false,
+                error: 'Failed to spawn daemon process',
+            };
+        }
+        // Detach from parent
+        child.unref();
+        // Write PID file
+        writeDaemonPid(child.pid, projectRoot);
+        return {
+            success: true,
+            pid: child.pid,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to start daemon: ${error.message}`,
+        };
+    }
+}
+export async function stopDaemon(projectRoot) {
+    const pid = readDaemonPid(projectRoot);
+    if (!pid) {
+        return {
+            success: false,
+            error: 'No daemon PID file found',
+        };
+    }
+    if (!isProcessRunning(pid)) {
+        // Clean up stale files
+        removeDaemonPid(projectRoot);
+        removeDaemonStatus(projectRoot);
+        return {
+            success: true,
+        };
+    }
+    try {
+        // Send SIGTERM for graceful shutdown
+        process.kill(pid, 'SIGTERM');
+        // Wait for process to exit (with timeout)
+        const maxWait = 5000;
+        const checkInterval = 100;
+        let waited = 0;
+        while (waited < maxWait && isProcessRunning(pid)) {
+            await new Promise((resolve) => setTimeout(resolve, checkInterval));
+            waited += checkInterval;
+        }
+        // If still running, force kill
+        if (isProcessRunning(pid)) {
+            try {
+                process.kill(pid, 'SIGKILL');
+            }
+            catch {
+                // Process might have exited between check and kill
+            }
+        }
+        // Clean up files
+        removeDaemonPid(projectRoot);
+        removeDaemonStatus(projectRoot);
+        return {
+            success: true,
+        };
+    }
+    catch (error) {
+        // Clean up files even on error
+        removeDaemonPid(projectRoot);
+        removeDaemonStatus(projectRoot);
+        return {
+            success: false,
+            error: `Failed to stop daemon: ${error.message}`,
+        };
+    }
+}
+export function getDaemonStatus(projectRoot) {
+    const pid = readDaemonPid(projectRoot);
+    const status = readDaemonStatus(projectRoot);
+    if (!pid) {
+        return { running: false };
+    }
+    const running = isProcessRunning(pid);
+    if (!running) {
+        // Clean up stale files
+        removeDaemonPid(projectRoot);
+        removeDaemonStatus(projectRoot);
+        return { running: false };
+    }
+    return {
+        running: true,
+        pid,
+        connected: status?.connected ?? false,
+        projectId: status?.project_id,
+        startedAt: status?.started_at,
+    };
+}

package/build/daemon/daemon.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+/**
+ * Daemon process entry point.
+ * This script runs as a detached background process and manages the WebSocket connection.
+ * Matching extension's behavior.
+ *
+ * Usage: node daemon.js <projectRoot> <projectId> <apiKey>
+ */
+import { WebSocketClient } from './websocket-client.js';
+import { writeDaemonStatus, removeDaemonPid, removeDaemonStatus } from '../utils/config.js';
+const args = process.argv.slice(2);
+if (args.length < 3) {
+    console.error('Usage: daemon <projectRoot> <projectId> <apiKey>');
+    process.exit(1);
+}
+const [projectRoot, projectId, apiKey] = args;
+let wsClient = null;
+let isShuttingDown = false;
+let startedAt = new Date().toISOString();
+function updateStatus(connected) {
+    const status = {
+        pid: process.pid,
+        connected,
+        project_id: projectId,
+        started_at: startedAt,
+    };
+    writeDaemonStatus(status, projectRoot);
+}
+function cleanup() {
+    if (isShuttingDown)
+        return;
+    isShuttingDown = true;
+    console.log('[Daemon] Shutting down...');
+    if (wsClient) {
+        wsClient.disconnect();
+        wsClient = null;
+    }
+    removeDaemonPid(projectRoot);
+    removeDaemonStatus(projectRoot);
+    process.exit(0);
+}
+// Handle graceful shutdown
+process.on('SIGTERM', cleanup);
+process.on('SIGINT', cleanup);
+process.on('SIGHUP', cleanup);
+// Handle uncaught errors
+process.on('uncaughtException', (error) => {
+    console.error('[Daemon] Uncaught exception:', error);
+    cleanup();
+});
+process.on('unhandledRejection', (reason) => {
+    console.error('[Daemon] Unhandled rejection:', reason);
+    cleanup();
+});
+async function main() {
+    console.log('╔════════════════════════════════════════════╗');
+    console.log('║      Shift Daemon Starting                 ║');
+    console.log('╚════════════════════════════════════════════╝');
+    console.log(`[Daemon] Project ID: ${projectId}`);
+    console.log(`[Daemon] Project root: ${projectRoot}`);
+    console.log(`[Daemon] PID: ${process.pid}`);
+    // Initial status - not connected yet
+    updateStatus(false);
+    wsClient = new WebSocketClient({
+        projectId,
+        apiKey,
+        workspaceRoot: projectRoot,
+    });
+    // Set up event listeners - matching extension's setupWebSocketListeners
+    wsClient.on('connecting', () => {
+        console.log('[Daemon] WebSocket connecting...');
+    });
+    wsClient.on('connected', (projectInfo) => {
+        console.log('[Daemon] ✓ Connected to project:', projectInfo?.project_name);
+        updateStatus(true);
+    });
+    wsClient.on('disconnected', (code, reason) => {
+        console.log(`[Daemon] Disconnected (code: ${code}, reason: ${reason})`);
+        updateStatus(false);
+    });
+    wsClient.on('auth_failed', (message) => {
+        console.error(`[Daemon] ❌ Authentication failed: ${message}`);
+        updateStatus(false);
+        // Don't exit immediately, let the reconnect logic handle it
+    });
+    wsClient.on('error', (error) => {
+        console.error('[Daemon] WebSocket error:', error.message);
+        updateStatus(false);
+    });
+    wsClient.on('reconnecting', (attempt) => {
+        console.log(`[Daemon] Reconnecting... (attempt ${attempt})`);
+    });
+    wsClient.on('max_reconnects_reached', () => {
+        console.error('[Daemon] ❌ Max reconnection attempts reached. Stopping daemon.');
+        cleanup();
+    });
+    wsClient.on('message', (message) => {
+        console.log(`[Daemon] Received message: ${message.type}`);
+    });
+    wsClient.on('tool_executed', ({ tool, result, requestId }) => {
+        console.log(`[Daemon] ✓ Tool executed: ${tool} (${requestId})`);
+    });
+    wsClient.on('tool_error', ({ tool, error, requestId }) => {
+        console.error(`[Daemon] ✗ Tool failed: ${tool} (${requestId}):`, error.message);
+    });
+    // Connect to WebSocket
+    try {
+        await wsClient.connect();
+        console.log('[Daemon] ✓ Initial connection successful');
+    }
+    catch (error) {
+        console.error('[Daemon] Initial connection failed:', error.message);
+        // Don't exit - the WebSocket client will handle reconnection
+    }
+}
+main().catch((error) => {
+    console.error('[Daemon] Fatal error:', error);
+    cleanup();
+});