codehere 0.6.0-alpha.1 → 0.6.1

package/dist/infrastructure/protocols/cloud-sync.js

@@ -0,0 +1,208 @@
+/**
+ * Cloud sync bridge for codehere remote dashboard.
+ *
+ * Pushes session state to codehere.uk/api/sync every 30s.
+ * Pulls task assignments from cloud.
+ *
+ * What leaves the machine:
+ *   - Session metadata (id, title, status, agent, project, tags, duration, tools, files, trustScore)
+ *   - Machine identity (name, token hash)
+ *
+ * What stays local:
+ *   - Code, file contents, API keys, git repos, full conversation threads
+ */
+import { randomUUID } from 'crypto';
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir, hostname } from 'os';
+const CLOUD_URL = 'https://codehere.uk/api/sync';
+const TOKEN_PATH = join(homedir(), '.codehere', 'cloud-token');
+const SESSIONS_FILE = join(homedir(), '.codehere', 'sessions.jsonl');
+// Lazy-loaded session manager — imported once to avoid circular deps
+let _sessionManager = null;
+async function getSessionManager() {
+    if (!_sessionManager) {
+        const { SessionManager } = await import('../orchestration/session-manager.js');
+        _sessionManager = SessionManager.getInstance();
+    }
+    return _sessionManager;
+}
+// ── Token management ─────────────────────────────────────────────────────────
+export function getOrCreateToken() {
+    if (existsSync(TOKEN_PATH)) {
+        return readFileSync(TOKEN_PATH, 'utf-8').trim();
+    }
+    const token = randomUUID();
+    const dir = dirname(TOKEN_PATH);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(TOKEN_PATH, token);
+    return token;
+}
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    return `${minutes}m ${remainingSeconds}s`;
+}
+function extractProjectFromCwd(cwd) {
+    // Extract project name from cwd path (last directory component)
+    const parts = cwd.split('/').filter(Boolean);
+    return parts[parts.length - 1] || 'unknown';
+}
+function extractTrustScore(artifacts) {
+    return artifacts?.trustScore;
+}
+export function collectSessionMetadata() {
+    if (!existsSync(SESSIONS_FILE)) {
+        return [];
+    }
+    try {
+        const content = readFileSync(SESSIONS_FILE, 'utf-8');
+        const lines = content.split('\n').filter(l => l.trim().length > 0);
+        // Parse records and pair spawned + completed
+        const spawnedMap = new Map();
+        const completedMap = new Map();
+        const finalReportMap = new Map();
+        for (const line of lines) {
+            try {
+                const record = JSON.parse(line);
+                if (record.t === 'spawned') {
+                    spawnedMap.set(record.id, record);
+                }
+                else if (record.t === 'completed') {
+                    completedMap.set(record.id, record);
+                }
+                else if (record.t === 'finalReport') {
+                    finalReportMap.set(record.id, record);
+                }
+            }
+            catch {
+                // Skip malformed lines
+            }
+        }
+        const sessions = [];
+        for (const [id, spawned] of spawnedMap.entries()) {
+            const completed = completedMap.get(id);
+            const finalReport = finalReportMap.get(id);
+            const status = completed
+                ? (completed.status === 'completed' ? 'done' : completed.status === 'failed' ? 'failed' : 'done')
+                : 'running';
+            const durationMs = completed?.durationMs ?? (Date.now() - spawned.startedAt);
+            const tools = completed?.steps?.length ?? 0;
+            const files = completed?.artifacts?.filesChanged?.length ?? 0;
+            const trustScore = extractTrustScore(completed?.artifacts);
+            // Extract title from prompt (first line or first 80 chars)
+            const title = spawned.prompt.split('\n')[0].slice(0, 80) || 'Untitled task';
+            sessions.push({
+                id,
+                title,
+                status,
+                agent: spawned.agent || 'Unknown',
+                project: extractProjectFromCwd(spawned.cwd || ''),
+                tags: [], // Tags not yet implemented in session schema
+                duration: formatDuration(durationMs),
+                tools,
+                files,
+                ...(trustScore !== undefined ? { trustScore } : {}),
+            });
+        }
+        return sessions.sort((a, b) => {
+            // Running first, then by duration descending
+            if (a.status === 'running' && b.status !== 'running')
+                return -1;
+            if (a.status !== 'running' && b.status === 'running')
+                return 1;
+            return 0;
+        });
+    }
+    catch {
+        return [];
+    }
+}
+// ── Sync loop ────────────────────────────────────────────────────────────────
+let syncInterval = null;
+export function startCloudSync(machineName) {
+    const token = getOrCreateToken();
+    // Use hostname + first 8 chars of token as machine ID — unique per machine
+    const machineId = machineName || `${hostname()}-${token.slice(0, 8)}`;
+    console.log(`  Cloud sync enabled — pushing to codehere.uk/app`);
+    console.log(`  Machine: ${machineId}`);
+    console.log(`  Token: ${TOKEN_PATH}`);
+    const push = async () => {
+        try {
+            const sessions = collectSessionMetadata();
+            const res = await fetch(CLOUD_URL, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    machineId,
+                    name: machineId,
+                    token,
+                    sessions,
+                    timestamp: Date.now(),
+                }),
+            });
+            if (!res.ok) {
+                const body = await res.text();
+                console.error(`  Cloud sync failed: ${res.status} ${body}`);
+            }
+            else {
+                const data = await res.json();
+                if (data.sessionsPushed && data.sessionsPushed > 0) {
+                    console.log(`  Cloud sync: ${data.sessionsPushed} session(s) pushed`);
+                }
+            }
+        }
+        catch (err) {
+            console.error(`  Cloud sync error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    };
+    const pullTasks = async () => {
+        try {
+            const res = await fetch(`${CLOUD_URL}?action=pull-tasks&machineId=${machineId}`);
+            if (!res.ok)
+                return;
+            const data = await res.json();
+            const tasks = data.tasks || [];
+            for (const task of tasks) {
+                if (task.prompt) {
+                    console.log(`  Cloud task received: ${task.prompt.slice(0, 60)}...`);
+                    try {
+                        const manager = await getSessionManager();
+                        manager.spawn(task.prompt, task.agent || 'claude-code');
+                        // Mark task as claimed
+                        await fetch(`${CLOUD_URL}?action=claim-task&machineId=${machineId}&taskId=${task.id}`, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({ machineId, token, taskId: task.id }),
+                        });
+                    }
+                    catch (err) {
+                        console.error(`  Failed to spawn cloud task: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            // Silent fail for task pull — not critical
+        }
+    };
+    // Push immediately, then every 30s
+    push();
+    pullTasks();
+    syncInterval = setInterval(() => {
+        push();
+        pullTasks();
+    }, 30000);
+}
+export function stopCloudSync() {
+    if (syncInterval) {
+        clearInterval(syncInterval);
+        syncInterval = null;
+    }
+}
+//# sourceMappingURL=cloud-sync.js.map