orbital-command 0.1.4 → 0.3.0

package/server/services/telemetry-service.ts

@@ -0,0 +1,195 @@
+/**
+ * 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 type Database from 'better-sqlite3';
+import { getClaudeSessionsDir } from '../config.js';
+
+export interface TelemetryConfig {
+  enabled: boolean;
+  url: string;
+  headers: Record<string, string>;
+}
+
+interface SessionRow {
+  id: string;
+  claude_session_id: string | null;
+  ended_at: string | null;
+  telemetry_sent_at: string | null;
+}
+
+interface TelemetryResult {
+  ok: boolean;
+  uploaded: number;
+  errors: number;
+}
+
+// ─── Service ───────────────────────────────────────────────
+
+export class TelemetryService {
+  private lastResult: TelemetryResult | null = null;
+
+  constructor(
+    private db: Database.Database,
+    private config: TelemetryConfig,
+    private projectName: string,
+    private projectRoot: string,
+  ) {}
+
+  get enabled(): boolean {
+    return this.config.enabled && this.config.url.length > 0;
+  }
+
+  /** Upload sessions that have changed since last telemetry send. */
+  async uploadChangedSessions(): Promise<TelemetryResult> {
+    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() as SessionRow[];
+
+    return this.uploadRows(rows);
+  }
+
+  /** Force re-upload all sessions regardless of telemetry_sent_at. */
+  async uploadAllSessions(): Promise<TelemetryResult> {
+    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() as SessionRow[];
+
+    return this.uploadRows(rows);
+  }
+
+  /** Ping the remote health endpoint. */
+  async testConnection(): Promise<{ ok: boolean; status: number; body: string }> {
+    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 as Error).message };
+    }
+  }
+
+  getStatus() {
+    return {
+      enabled: this.enabled,
+      url: this.config.url || null,
+      lastResult: this.lastResult,
+    };
+  }
+
+  // ─── Internal ──────────────────────────────────────────────
+
+  private async uploadRows(rows: SessionRow[]): Promise<TelemetryResult> {
+    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<string>();
+    const unique: SessionRow[] = [];
+    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;
+  }
+}
+
+// ─── Routes ────────────────────────────────────────────────
+
+interface TelemetryRouteDeps {
+  telemetryService: TelemetryService;
+}
+
+export function createTelemetryRoutes({ telemetryService }: TelemetryRouteDeps): Router {
+  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/server/services/workflow-service.test.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { WorkflowService } from './workflow-service.js';
+import { WorkflowEngine } from '../../shared/workflow-engine.js';
+import { DEFAULT_CONFIG, MINIMAL_CONFIG } from '../../shared/__fixtures__/workflow-configs.js';
+import { createMockEmitter } from '../__tests__/helpers/mock-emitter.js';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+describe('WorkflowService', () => {
+  let tmpDir: string;
+  let configDir: string;
+  let scopesDir: string;
+  let defaultConfigPath: string;
+  let engine: WorkflowEngine;
+  let service: WorkflowService;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'workflow-svc-test-'));
+    configDir = path.join(tmpDir, 'config');
+    scopesDir = path.join(tmpDir, 'scopes');
+    defaultConfigPath = path.join(tmpDir, 'default-workflow.json');
+
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.mkdirSync(scopesDir, { recursive: true });
+
+    // Write the default workflow config that the constructor reads
+    fs.writeFileSync(defaultConfigPath, JSON.stringify(DEFAULT_CONFIG));
+
+    // Create scope directories for the default workflow
+    for (const list of DEFAULT_CONFIG.lists) {
+      if (list.hasDirectory) {
+        fs.mkdirSync(path.join(scopesDir, list.id), { recursive: true });
+      }
+    }
+
+    engine = new WorkflowEngine(DEFAULT_CONFIG);
+    service = new WorkflowService(configDir, engine, scopesDir, defaultConfigPath);
+    service.setSocketServer(createMockEmitter() as any);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  // ─── validate() ──────────────────────────────────────────
+
+  describe('validate()', () => {
+    it('passes for valid config', () => {
+      const result = service.validate(DEFAULT_CONFIG);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('fails for invalid config shape', () => {
+      const result = service.validate({ version: 2 } as any);
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it('fails for duplicate list IDs', () => {
+      const config = {
+        ...MINIMAL_CONFIG,
+        lists: [
+          ...MINIMAL_CONFIG.lists,
+          { ...MINIMAL_CONFIG.lists[0] }, // duplicate 'todo'
+        ],
+      };
+      const result = service.validate(config);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.toLowerCase().includes('duplicate'))).toBe(true);
+    });
+
+    it('fails for edges referencing non-existent lists', () => {
+      const config = {
+        ...MINIMAL_CONFIG,
+        edges: [
+          { from: 'todo', to: 'nonexistent', direction: 'forward' as const, command: null, confirmLevel: 'quick' as const, label: 'X', description: 'X' },
+        ],
+      };
+      const result = service.validate(config);
+      expect(result.valid).toBe(false);
+    });
+
+    it('fails for zero entry points', () => {
+      const config = {
+        ...MINIMAL_CONFIG,
+        lists: MINIMAL_CONFIG.lists.map(l => ({ ...l, isEntryPoint: false })),
+      };
+      const result = service.validate(config);
+      expect(result.valid).toBe(false);
+    });
+  });
+
+  // ─── getActive() / updateActive() ────────────────────────
+
+  describe('getActive()', () => {
+    it('returns active workflow config', () => {
+      const config = service.getActive();
+      expect(config.name).toBe(DEFAULT_CONFIG.name);
+      expect(config.version).toBe(1);
+    });
+
+    it('strips _defaultDigest from returned config', () => {
+      const config = service.getActive() as any;
+      expect(config._defaultDigest).toBeUndefined();
+    });
+  });
+
+  describe('updateActive()', () => {
+    it('updates config and returns valid result', () => {
+      const result = service.updateActive(DEFAULT_CONFIG);
+      expect(result.valid).toBe(true);
+    });
+
+    it('rejects invalid config', () => {
+      const result = service.updateActive({ version: 1, name: 'Bad', lists: [], edges: [] } as any);
+      expect(result.valid).toBe(false);
+    });
+  });
+
+  // ─── Presets ──────────────────────────────────────────────
+
+  describe('presets', () => {
+    it('savePreset() creates a preset file', () => {
+      service.savePreset('test-preset');
+      const presets = service.listPresets();
+      expect(presets.some(p => p.name === 'test-preset')).toBe(true);
+    });
+
+    it('listPresets() returns all saved presets', () => {
+      service.savePreset('preset-a');
+      service.savePreset('preset-b');
+      const presets = service.listPresets();
+      expect(presets.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it('getPreset() loads preset by name', () => {
+      service.savePreset('loadable');
+      const config = service.getPreset('loadable');
+      expect(config.version).toBe(1);
+    });
+
+    it('getPreset() throws for non-existent preset', () => {
+      expect(() => service.getPreset('nonexistent')).toThrow();
+    });
+
+    it('deletePreset() removes preset file', () => {
+      service.savePreset('to-delete');
+      service.deletePreset('to-delete');
+      expect(() => service.getPreset('to-delete')).toThrow();
+    });
+
+    it('deletePreset() blocks deletion of "default"', () => {
+      expect(() => service.deletePreset('default')).toThrow();
+    });
+  });
+
+  // ─── previewMigration() ──────────────────────────────────
+
+  describe('previewMigration()', () => {
+    it('detects removed lists', () => {
+      // Preview migrating from DEFAULT_CONFIG (7 lists) to MINIMAL_CONFIG (2 lists)
+      const plan = service.previewMigration(MINIMAL_CONFIG);
+      expect(plan.removedLists.length).toBeGreaterThan(0);
+    });
+
+    it('returns no-op plan when configs have same lists', () => {
+      const plan = service.previewMigration(DEFAULT_CONFIG);
+      expect(plan.valid).toBe(true);
+      expect(plan.removedLists).toHaveLength(0);
+      expect(plan.orphanedScopes).toHaveLength(0);
+    });
+
+    it('returns valid: false for invalid config', () => {
+      const plan = service.previewMigration({ version: 1, name: 'Bad', lists: [], edges: [] } as any);
+      expect(plan.valid).toBe(false);
+    });
+  });
+
+  // ─── getEngine() ─────────────────────────────────────────
+
+  describe('getEngine()', () => {
+    it('returns the active workflow engine', () => {
+      const e = service.getEngine();
+      expect(e).toBeDefined();
+      expect(e.getLists().length).toBeGreaterThan(0);
+    });
+  });
+});

package/server/services/workflow-service.ts

@@ -1,7 +1,7 @@
 import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
-import type { Server } from 'socket.io';
+import type { Emitter } from '../project-emitter.js';
 import type { WorkflowConfig } from '../../shared/workflow-config.js';
 import { createLogger } from '../utils/logger.js';
 
@@ -53,7 +53,7 @@ export class WorkflowService {
   private engine: WorkflowEngine;
   private defaultConfigPath: string;
   private manifestPath: string;
-  private io: Server | null = null;
+  private io: Emitter | null = null;
 
   constructor(configDir: string, engine: WorkflowEngine, scopesDir: string, defaultConfigPath: string) {
     this.presetsDir = path.join(configDir, 'workflows');
@@ -81,13 +81,19 @@ export class WorkflowService {
       this.engine.reload(defaultConfig);
       fs.writeFileSync(this.manifestPath, this.engine.generateShellManifest(), 'utf-8');
     } else {
-      const active = JSON.parse(fs.readFileSync(this.activeConfigPath, 'utf-8')) as WorkflowConfig & { _defaultDigest?: string };
+      const active = JSON.parse(fs.readFileSync(this.activeConfigPath, 'utf-8')) as WorkflowConfig & { _defaultDigest?: string; _customized?: boolean };
       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
         this.writeWithDigest(this.activeConfigPath, defaultConfig, currentDigest);
@@ -96,13 +102,17 @@ export class WorkflowService {
       }
     }
 
-    // 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: Server): void {
+  setSocketServer(io: Emitter): void {
     this.io = io;
   }
 
@@ -110,6 +120,16 @@ export class WorkflowService {
     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. */
+  private isLikelyOldDefault(active: WorkflowConfig, currentDefault: WorkflowConfig): boolean {
+    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: WorkflowConfig): ValidationResult {