orbital-command 0.2.0 → 0.3.0

package/dist/server/server/services/sync-service.js

@@ -0,0 +1,434 @@
+import path from 'path';
+import fs from 'fs';
+import { GLOBAL_PRIMITIVES_DIR, GLOBAL_WORKFLOW_PATH, getRegisteredProjects } from '../global-config.js';
+import { createLogger } from '../utils/logger.js';
+import { hashFile, hashTree } from '../manifest.js';
+const log = createLogger('sync');
+const SYNC_MANIFEST_FILENAME = 'orbital-sync.json';
+// ─── Manifest I/O ───────────────────────────────────────────
+function manifestPath(projectRoot) {
+    return path.join(projectRoot, '.claude', SYNC_MANIFEST_FILENAME);
+}
+/** Load a project's sync manifest, or return null if none exists. */
+function loadManifest(projectRoot) {
+    const mp = manifestPath(projectRoot);
+    if (!fs.existsSync(mp))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(mp, 'utf-8'));
+    }
+    catch {
+        log.warn('Failed to parse sync manifest', { path: mp });
+        return null;
+    }
+}
+/** Save a project's sync manifest atomically. */
+function saveManifest(projectRoot, manifest) {
+    const mp = manifestPath(projectRoot);
+    const dir = path.dirname(mp);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    const tmp = mp + '.tmp';
+    try {
+        fs.writeFileSync(tmp, JSON.stringify(manifest, null, 2), 'utf-8');
+        fs.renameSync(tmp, mp);
+    }
+    catch (err) {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch { /* best-effort cleanup */ }
+        throw err;
+    }
+}
+/** Create a default manifest for a project by comparing its files against global. */
+function createInitialManifest(projectRoot) {
+    const claudeDir = path.join(projectRoot, '.claude');
+    const globalHashes = hashTree(GLOBAL_PRIMITIVES_DIR);
+    const now = new Date().toISOString();
+    const files = {};
+    for (const [relPath, globalHash] of globalHashes) {
+        const localPath = path.join(claudeDir, relPath);
+        if (fs.existsSync(localPath)) {
+            const localHash = hashFile(localPath);
+            files[relPath] = {
+                mode: localHash === globalHash ? 'synced' : 'override',
+                globalHash,
+                localHash,
+                syncedAt: now,
+                ...(localHash !== globalHash ? { overriddenAt: now, reason: 'Existing file at registration time' } : {}),
+            };
+        }
+        else {
+            // Global file not present locally — copy it
+            const localDir = path.dirname(localPath);
+            if (!fs.existsSync(localDir))
+                fs.mkdirSync(localDir, { recursive: true });
+            fs.copyFileSync(path.join(GLOBAL_PRIMITIVES_DIR, relPath), localPath);
+            files[relPath] = {
+                mode: 'synced',
+                globalHash,
+                localHash: globalHash,
+                syncedAt: now,
+            };
+        }
+    }
+    // Workflow
+    let workflow;
+    const workflowPath = path.join(projectRoot, '.claude', 'config', 'workflow.json');
+    if (fs.existsSync(GLOBAL_WORKFLOW_PATH) && fs.existsSync(workflowPath)) {
+        const globalHash = hashFile(GLOBAL_WORKFLOW_PATH);
+        const localHash = hashFile(workflowPath);
+        workflow = {
+            mode: localHash === globalHash ? 'synced' : 'override',
+            globalHash,
+            localHash,
+            syncedAt: now,
+            ...(localHash !== globalHash ? { overriddenAt: now, reason: 'Existing workflow at registration time' } : {}),
+        };
+    }
+    else {
+        workflow = { mode: 'synced', globalHash: '', localHash: '', syncedAt: now };
+    }
+    return { version: 1, files, workflow, newFilesPolicy: 'auto-sync' };
+}
+// ─── Atomic File Copy ───────────────────────────────────────
+/** Copy a file atomically (write to temp, then rename). */
+function atomicCopy(src, dest) {
+    const dir = path.dirname(dest);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    const tmp = dest + '.sync-tmp';
+    try {
+        fs.copyFileSync(src, tmp);
+        fs.renameSync(tmp, dest);
+    }
+    catch (err) {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch { /* best-effort cleanup */ }
+        throw err;
+    }
+}
+// ─── SyncService ────────────────────────────────────────────
+export class SyncService {
+    constructor() { }
+    // ─── Sync State Computation ──────────────────────────────
+    /** Compute the actual sync state of every tracked file in a project. */
+    computeSyncState(projectId, projectRoot) {
+        let manifest = loadManifest(projectRoot);
+        if (!manifest) {
+            manifest = createInitialManifest(projectRoot);
+            saveManifest(projectRoot, manifest);
+        }
+        const claudeDir = path.join(projectRoot, '.claude');
+        const files = [];
+        for (const [relPath, record] of Object.entries(manifest.files)) {
+            const localPath = path.join(claudeDir, relPath);
+            const globalPath = path.join(GLOBAL_PRIMITIVES_DIR, relPath);
+            const localExists = fs.existsSync(localPath);
+            const globalExists = fs.existsSync(globalPath);
+            let state;
+            let localHash = localExists ? hashFile(localPath) : null;
+            let globalHash = globalExists ? hashFile(globalPath) : null;
+            if (record.mode === 'override') {
+                state = 'override';
+            }
+            else if (!localExists) {
+                state = 'absent';
+            }
+            else if (localHash !== record.localHash) {
+                // Local file changed since last sync — drift
+                state = 'drifted';
+            }
+            else {
+                state = 'synced';
+            }
+            files.push({
+                relativePath: relPath,
+                state,
+                globalHash,
+                localHash,
+                overriddenAt: record.overriddenAt,
+                reason: record.reason,
+            });
+        }
+        // Check for new global files not in manifest
+        if (fs.existsSync(GLOBAL_PRIMITIVES_DIR)) {
+            const globalHashes = hashTree(GLOBAL_PRIMITIVES_DIR);
+            for (const [relPath] of globalHashes) {
+                if (!manifest.files[relPath]) {
+                    files.push({
+                        relativePath: relPath,
+                        state: 'absent',
+                        globalHash: globalHashes.get(relPath) ?? null,
+                        localHash: null,
+                    });
+                }
+            }
+        }
+        // Workflow state
+        const wfLocalPath = path.join(projectRoot, '.claude', 'config', 'workflow.json');
+        let workflowState = 'synced';
+        if (manifest.workflow.mode === 'override') {
+            workflowState = 'override';
+        }
+        else if (fs.existsSync(wfLocalPath)) {
+            const currentLocalHash = hashFile(wfLocalPath);
+            if (currentLocalHash !== manifest.workflow.localHash) {
+                workflowState = 'drifted';
+            }
+        }
+        return {
+            projectId,
+            projectPath: projectRoot,
+            files,
+            workflow: {
+                relativePath: 'workflow.json',
+                state: workflowState,
+                globalHash: manifest.workflow.globalHash || null,
+                localHash: manifest.workflow.localHash || null,
+            },
+        };
+    }
+    /** Compute sync state across ALL registered projects. */
+    computeGlobalSyncState() {
+        const projects = getRegisteredProjects();
+        const allFiles = new Set();
+        const projectStates = [];
+        for (const reg of projects) {
+            if (!reg.enabled || !fs.existsSync(reg.path))
+                continue;
+            const report = this.computeSyncState(reg.id, reg.path);
+            const states = {};
+            for (const f of report.files) {
+                allFiles.add(f.relativePath);
+                states[f.relativePath] = f.state;
+            }
+            projectStates.push({ projectId: reg.id, projectName: reg.name, states });
+        }
+        return { files: [...allFiles].sort(), projects: projectStates };
+    }
+    // ─── Write Operations ────────────────────────────────────
+    /** Propagate a global file change to all synced projects. */
+    propagateGlobalChange(relativePath) {
+        const globalPath = path.join(GLOBAL_PRIMITIVES_DIR, relativePath);
+        if (!fs.existsSync(globalPath)) {
+            return { updated: [], skipped: [], failed: [] };
+        }
+        const globalHash = hashFile(globalPath);
+        const projects = getRegisteredProjects();
+        const result = { updated: [], skipped: [], failed: [] };
+        for (const reg of projects) {
+            if (!reg.enabled || !fs.existsSync(reg.path))
+                continue;
+            const manifest = loadManifest(reg.path);
+            if (!manifest)
+                continue;
+            const record = manifest.files[relativePath];
+            if (!record || record.mode === 'override') {
+                result.skipped.push(reg.id);
+                // Update globalHash even for overrides so drift detection works
+                if (record) {
+                    record.globalHash = globalHash;
+                    saveManifest(reg.path, manifest);
+                }
+                continue;
+            }
+            try {
+                const destPath = path.join(reg.path, '.claude', relativePath);
+                atomicCopy(globalPath, destPath);
+                record.globalHash = globalHash;
+                record.localHash = globalHash;
+                record.syncedAt = new Date().toISOString();
+                saveManifest(reg.path, manifest);
+                result.updated.push(reg.id);
+                log.info('Propagated global change', { file: relativePath, project: reg.id });
+            }
+            catch (err) {
+                result.failed.push({ projectId: reg.id, error: String(err) });
+            }
+        }
+        return result;
+    }
+    /** Create an override for a file in a specific project. */
+    createOverride(projectRoot, relativePath, reason) {
+        const manifest = loadManifest(projectRoot);
+        if (!manifest)
+            return;
+        const record = manifest.files[relativePath];
+        if (!record)
+            return;
+        record.mode = 'override';
+        record.overriddenAt = new Date().toISOString();
+        if (reason)
+            record.reason = reason;
+        // Update localHash to current file content
+        const localPath = path.join(projectRoot, '.claude', relativePath);
+        if (fs.existsSync(localPath)) {
+            record.localHash = hashFile(localPath);
+        }
+        saveManifest(projectRoot, manifest);
+        log.info('Created override', { file: relativePath, reason });
+    }
+    /** Revert an override — replace local file with global version. */
+    revertOverride(projectRoot, relativePath) {
+        const manifest = loadManifest(projectRoot);
+        if (!manifest)
+            return;
+        const record = manifest.files[relativePath];
+        if (!record)
+            return;
+        const globalPath = path.join(GLOBAL_PRIMITIVES_DIR, relativePath);
+        if (!fs.existsSync(globalPath))
+            return;
+        const destPath = path.join(projectRoot, '.claude', relativePath);
+        atomicCopy(globalPath, destPath);
+        const globalHash = hashFile(globalPath);
+        record.mode = 'synced';
+        record.globalHash = globalHash;
+        record.localHash = globalHash;
+        record.syncedAt = new Date().toISOString();
+        delete record.overriddenAt;
+        delete record.reason;
+        saveManifest(projectRoot, manifest);
+        log.info('Reverted override', { file: relativePath });
+    }
+    /** Promote a project override to become the new global version. */
+    promoteOverride(projectRoot, relativePath) {
+        const localPath = path.join(projectRoot, '.claude', relativePath);
+        if (!fs.existsSync(localPath)) {
+            return { updated: [], skipped: [], failed: [{ projectId: 'self', error: 'Local file not found' }] };
+        }
+        // Copy local to global
+        const globalPath = path.join(GLOBAL_PRIMITIVES_DIR, relativePath);
+        atomicCopy(localPath, globalPath);
+        // Update this project's manifest to synced
+        const manifest = loadManifest(projectRoot);
+        if (manifest && manifest.files[relativePath]) {
+            const hash = hashFile(globalPath);
+            manifest.files[relativePath] = {
+                mode: 'synced',
+                globalHash: hash,
+                localHash: hash,
+                syncedAt: new Date().toISOString(),
+            };
+            saveManifest(projectRoot, manifest);
+        }
+        // Propagate to all other synced projects
+        log.info('Promoted override to global', { file: relativePath });
+        return this.propagateGlobalChange(relativePath);
+    }
+    /** Resolve drift — either pin as override or reset to global. */
+    resolveDrift(projectRoot, relativePath, resolution) {
+        if (resolution === 'pin-override') {
+            this.createOverride(projectRoot, relativePath, 'Pinned from drift resolution');
+        }
+        else {
+            this.revertOverride(projectRoot, relativePath);
+        }
+    }
+    // ─── New File Handling ───────────────────────────────────
+    /** Handle a new file appearing in the global primitives directory. */
+    handleNewGlobalFile(relativePath) {
+        const globalPath = path.join(GLOBAL_PRIMITIVES_DIR, relativePath);
+        if (!fs.existsSync(globalPath)) {
+            return { updated: [], skipped: [], failed: [] };
+        }
+        const globalHash = hashFile(globalPath);
+        const projects = getRegisteredProjects();
+        const result = { updated: [], skipped: [], failed: [] };
+        for (const reg of projects) {
+            if (!reg.enabled || !fs.existsSync(reg.path))
+                continue;
+            const manifest = loadManifest(reg.path);
+            if (!manifest)
+                continue;
+            if (manifest.newFilesPolicy === 'prompt') {
+                result.skipped.push(reg.id);
+                continue;
+            }
+            try {
+                const destPath = path.join(reg.path, '.claude', relativePath);
+                atomicCopy(globalPath, destPath);
+                manifest.files[relativePath] = {
+                    mode: 'synced',
+                    globalHash,
+                    localHash: globalHash,
+                    syncedAt: new Date().toISOString(),
+                };
+                saveManifest(reg.path, manifest);
+                result.updated.push(reg.id);
+            }
+            catch (err) {
+                result.failed.push({ projectId: reg.id, error: String(err) });
+            }
+        }
+        return result;
+    }
+    /** Handle a file being deleted from the global primitives directory. */
+    handleGlobalFileDeletion(relativePath) {
+        const projects = getRegisteredProjects();
+        const removed = [];
+        const preserved = [];
+        for (const reg of projects) {
+            if (!reg.enabled || !fs.existsSync(reg.path))
+                continue;
+            const manifest = loadManifest(reg.path);
+            if (!manifest || !manifest.files[relativePath])
+                continue;
+            const record = manifest.files[relativePath];
+            const localPath = path.join(reg.path, '.claude', relativePath);
+            if (record.mode === 'synced') {
+                // Delete the local copy
+                if (fs.existsSync(localPath))
+                    fs.unlinkSync(localPath);
+                delete manifest.files[relativePath];
+                saveManifest(reg.path, manifest);
+                removed.push(reg.id);
+            }
+            else {
+                // Override — preserve the local file, remove from manifest
+                delete manifest.files[relativePath];
+                saveManifest(reg.path, manifest);
+                preserved.push(reg.id);
+            }
+        }
+        return { removed, preserved };
+    }
+    // ─── Impact Preview ──────────────────────────────────────
+    /** Preview which projects would be affected by a global file change. */
+    getImpactPreview(relativePath) {
+        const projects = getRegisteredProjects();
+        const willUpdate = [];
+        const willSkip = [];
+        for (const reg of projects) {
+            if (!reg.enabled || !fs.existsSync(reg.path))
+                continue;
+            const manifest = loadManifest(reg.path);
+            if (!manifest) {
+                willSkip.push({ id: reg.id, reason: 'No sync manifest' });
+                continue;
+            }
+            const record = manifest.files[relativePath];
+            if (!record || record.mode === 'synced') {
+                willUpdate.push(reg.id);
+            }
+            else {
+                willSkip.push({ id: reg.id, reason: record.reason });
+            }
+        }
+        return { willUpdate, willSkip };
+    }
+    // ─── Manifest Management ─────────────────────────────────
+    /** Ensure a project has a sync manifest. Creates one if missing. */
+    ensureManifest(projectRoot) {
+        let manifest = loadManifest(projectRoot);
+        if (!manifest) {
+            manifest = createInitialManifest(projectRoot);
+            saveManifest(projectRoot, manifest);
+        }
+        return manifest;
+    }
+}

package/dist/server/server/services/sync-types.js

@@ -0,0 +1,2 @@
+// ─── Sync State Types ───────────────────────────────────────
+export {};

package/dist/server/server/services/telemetry-service.js

@@ -0,0 +1,143 @@
+/**
+ * Session Telemetry — uploads raw Claude session JSONL files to a remote
+ * Cloudflare Worker + R2 endpoint. This entire feature lives in this single
+ * file for easy removal.
+ */
+import fs from 'fs';
+import path from 'path';
+import { Router } from 'express';
+import { getClaudeSessionsDir } from '../config.js';
+// ─── Service ───────────────────────────────────────────────
+export class TelemetryService {
+    db;
+    config;
+    projectName;
+    projectRoot;
+    lastResult = null;
+    constructor(db, config, projectName, projectRoot) {
+        this.db = db;
+        this.config = config;
+        this.projectName = projectName;
+        this.projectRoot = projectRoot;
+    }
+    get enabled() {
+        return this.config.enabled && this.config.url.length > 0;
+    }
+    /** Upload sessions that have changed since last telemetry send. */
+    async uploadChangedSessions() {
+        if (!this.enabled)
+            return { ok: true, uploaded: 0, errors: 0 };
+        const rows = this.db.prepare(`SELECT id, claude_session_id, ended_at, telemetry_sent_at
+       FROM sessions
+       WHERE claude_session_id IS NOT NULL
+         AND (telemetry_sent_at IS NULL OR ended_at > telemetry_sent_at)`).all();
+        return this.uploadRows(rows);
+    }
+    /** Force re-upload all sessions regardless of telemetry_sent_at. */
+    async uploadAllSessions() {
+        if (!this.enabled)
+            return { ok: true, uploaded: 0, errors: 0 };
+        const rows = this.db.prepare(`SELECT id, claude_session_id, ended_at, telemetry_sent_at
+       FROM sessions
+       WHERE claude_session_id IS NOT NULL`).all();
+        return this.uploadRows(rows);
+    }
+    /** Ping the remote health endpoint. */
+    async testConnection() {
+        try {
+            const res = await fetch(`${this.config.url}/health`, {
+                method: 'GET',
+                headers: this.config.headers,
+                signal: AbortSignal.timeout(10_000),
+            });
+            const body = await res.text();
+            return { ok: res.ok, status: res.status, body };
+        }
+        catch (err) {
+            return { ok: false, status: 0, body: err.message };
+        }
+    }
+    getStatus() {
+        return {
+            enabled: this.enabled,
+            url: this.config.url || null,
+            lastResult: this.lastResult,
+        };
+    }
+    // ─── Internal ──────────────────────────────────────────────
+    async uploadRows(rows) {
+        if (rows.length === 0) {
+            this.lastResult = { ok: true, uploaded: 0, errors: 0 };
+            return this.lastResult;
+        }
+        const sessionsDir = getClaudeSessionsDir(this.projectRoot);
+        const now = new Date().toISOString();
+        let uploaded = 0;
+        let errors = 0;
+        const updateStmt = this.db.prepare('UPDATE sessions SET telemetry_sent_at = ? WHERE id = ?');
+        // Deduplicate by claude_session_id (multiple rows can share the same JSONL file)
+        const seen = new Set();
+        const unique = [];
+        for (const row of rows) {
+            if (row.claude_session_id && !seen.has(row.claude_session_id)) {
+                seen.add(row.claude_session_id);
+                unique.push(row);
+            }
+        }
+        for (const row of unique) {
+            const sessionId = row.claude_session_id;
+            const filePath = path.join(sessionsDir, `${sessionId}.jsonl`);
+            if (!fs.existsSync(filePath)) {
+                continue;
+            }
+            try {
+                const body = fs.readFileSync(filePath);
+                const encodedProject = encodeURIComponent(this.projectName);
+                const url = `${this.config.url}/upload/${encodedProject}/${sessionId}.jsonl`;
+                const res = await fetch(url, {
+                    method: 'PUT',
+                    body,
+                    headers: {
+                        'Content-Type': 'application/x-ndjson',
+                        ...this.config.headers,
+                    },
+                    signal: AbortSignal.timeout(30_000),
+                });
+                if (res.ok) {
+                    uploaded++;
+                    // Update telemetry_sent_at for ALL rows with this claude_session_id
+                    const matching = rows.filter((r) => r.claude_session_id === sessionId);
+                    for (const m of matching) {
+                        updateStmt.run(now, m.id);
+                    }
+                }
+                else {
+                    errors++;
+                }
+            }
+            catch {
+                errors++;
+            }
+        }
+        this.lastResult = { ok: errors === 0, uploaded, errors };
+        return this.lastResult;
+    }
+}
+export function createTelemetryRoutes({ telemetryService }) {
+    const router = Router();
+    router.post('/telemetry/trigger', async (req, res) => {
+        const force = req.query.force === 'true';
+        const result = force
+            ? await telemetryService.uploadAllSessions()
+            : await telemetryService.uploadChangedSessions();
+        res.json(result);
+    });
+    router.post('/telemetry/test', async (_req, res) => {
+        const result = await telemetryService.testConnection();
+        res.json(result);
+    });
+    router.get('/telemetry/status', (_req, res) => {
+        res.json(telemetryService.getStatus());
+    });
+    return router;
+}

package/dist/server/server/services/workflow-service.js

@@ -46,11 +46,18 @@ export class WorkflowService {
         else {
             const active = JSON.parse(fs.readFileSync(this.activeConfigPath, 'utf-8'));
             if (!active._defaultDigest) {
-                // Legacy file without digest marker. If content matches current default, stamp it.
-                // If different, it's user-customized — leave it alone.
                 if (configDigest(active) === currentDigest) {
+                    // Exact content match — just stamp it with the digest
                     this.writeWithDigest(this.activeConfigPath, defaultConfig, currentDigest);
                 }
+                else if (this.isLikelyOldDefault(active, defaultConfig)) {
+                    // Same list structure but different edges — old default that needs updating
+                    log.info('Upgrading legacy workflow config to current default');
+                    this.writeWithDigest(this.activeConfigPath, defaultConfig, currentDigest);
+                    this.engine.reload(defaultConfig);
+                    fs.writeFileSync(this.manifestPath, this.engine.generateShellManifest(), 'utf-8');
+                }
+                // else: genuinely user-customized (different list structure), leave alone
             }
             else if (active._defaultDigest !== currentDigest) {
                 // Bundled default changed since last sync — refresh + regenerate manifest
@@ -59,10 +66,14 @@ export class WorkflowService {
                 fs.writeFileSync(this.manifestPath, this.engine.generateShellManifest(), 'utf-8');
             }
         }
-        // Always keep the "default" preset in sync with the bundled default
+        // Always keep the "default" preset in sync with the bundled default.
+        // Copy the raw template bytes to preserve formatting (avoid hash drift from re-serialization).
         const defaultPresetPath = path.join(this.presetsDir, 'default.json');
-        const preset = { _preset: { name: 'default', savedAt: new Date().toISOString(), savedFrom: 'bundled' }, ...defaultConfig };
-        fs.writeFileSync(defaultPresetPath, JSON.stringify(preset, null, 2));
+        const templateBytes = fs.readFileSync(this.defaultConfigPath, 'utf-8');
+        const existing = fs.existsSync(defaultPresetPath) ? fs.readFileSync(defaultPresetPath, 'utf-8') : '';
+        if (existing !== templateBytes) {
+            fs.writeFileSync(defaultPresetPath, templateBytes);
+        }
     }
     setSocketServer(io) {
         this.io = io;
@@ -70,6 +81,16 @@ export class WorkflowService {
     getEngine() {
         return this.engine;
     }
+    /** Check if a legacy config (no digest) is structurally an old default rather than
+     *  a user customization. If it has the same list IDs in the same order, it was
+     *  almost certainly seeded from an older version of the bundled default. */
+    isLikelyOldDefault(active, currentDefault) {
+        if (active.name !== currentDefault.name)
+            return false;
+        const activeListIds = active.lists.map(l => l.id).join(',');
+        const defaultListIds = currentDefault.lists.map(l => l.id).join(',');
+        return activeListIds === defaultListIds;
+    }
     // ─── Validation ──────────────────────────────────────
     validate(config) {
         const errors = [];