@adhdev/daemon-core 0.9.66 → 0.9.67

package/src/mesh/mesh-sync.ts

@@ -0,0 +1,109 @@
+/**
+ * Mesh Sync — Sync local mesh config to/from cloud D1
+ *
+ * When cloud is available, this module pushes local mesh config
+ * to the server and pulls remote meshes that were created from
+ * other machines. The local ~/.adhdev/meshes.json remains the
+ * canonical source; cloud is a persistence/relay layer.
+ *
+ * This is called lazily (not on daemon startup) — only when the
+ * user explicitly opens the mesh page or runs `adhdev mesh sync`.
+ */
+
+import { listMeshes, getMesh, createMesh, deleteMesh, addNode, removeNode } from '../config/mesh-config.js';
+import type { LocalMeshEntry, LocalMeshNodeEntry } from '../repo-mesh-types.js';
+
+export interface MeshSyncTransport {
+    /** GET /api/v1/repo-meshes */
+    listRemoteMeshes(): Promise<{ meshes: RemoteMeshRecord[] }>;
+    /** POST /api/v1/repo-meshes */
+    createRemoteMesh(data: {
+        name: string;
+        repo_identity: string;
+        repo_remote_url?: string;
+        default_branch?: string;
+        policy?: string;
+    }): Promise<{ mesh: RemoteMeshRecord }>;
+    /** DELETE /api/v1/repo-meshes/:id */
+    deleteRemoteMesh(meshId: string): Promise<void>;
+}
+
+export interface RemoteMeshRecord {
+    id: string;
+    name: string;
+    repo_identity: string;
+    repo_remote_url: string | null;
+    default_branch: string | null;
+    policy: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+}
+
+export interface MeshSyncResult {
+    pushed: number;
+    pulled: number;
+    deleted: number;
+    errors: string[];
+}
+
+/**
+ * Push local meshes to cloud (upsert by repo_identity).
+ * Pull remote meshes that don't exist locally.
+ */
+export async function syncMeshes(transport: MeshSyncTransport): Promise<MeshSyncResult> {
+    const result: MeshSyncResult = { pushed: 0, pulled: 0, deleted: 0, errors: [] };
+
+    let remoteMeshes: RemoteMeshRecord[];
+    try {
+        const res = await transport.listRemoteMeshes();
+        remoteMeshes = res.meshes;
+    } catch (e: any) {
+        result.errors.push(`Failed to list remote meshes: ${e.message}`);
+        return result;
+    }
+
+    const localMeshes = listMeshes();
+    const remoteByIdentity = new Map(remoteMeshes.map(m => [m.repo_identity, m]));
+    const localByIdentity = new Map(localMeshes.map(m => [m.repoIdentity, m]));
+
+    // Push: local meshes not in cloud
+    for (const local of localMeshes) {
+        if (!remoteByIdentity.has(local.repoIdentity)) {
+            try {
+                await transport.createRemoteMesh({
+                    name: local.name,
+                    repo_identity: local.repoIdentity,
+                    repo_remote_url: local.repoRemoteUrl,
+                    default_branch: local.defaultBranch,
+                    policy: JSON.stringify(local.policy),
+                });
+                result.pushed++;
+            } catch (e: any) {
+                result.errors.push(`Push failed for "${local.name}": ${e.message}`);
+            }
+        }
+    }
+
+    // Pull: remote meshes not in local
+    for (const remote of remoteMeshes) {
+        if (!localByIdentity.has(remote.repo_identity)) {
+            try {
+                let policy;
+                try { policy = JSON.parse(remote.policy); } catch { policy = undefined; }
+                createMesh({
+                    name: remote.name,
+                    repoIdentity: remote.repo_identity,
+                    repoRemoteUrl: remote.repo_remote_url || undefined,
+                    defaultBranch: remote.default_branch || undefined,
+                    policy,
+                });
+                result.pulled++;
+            } catch (e: any) {
+                result.errors.push(`Pull failed for "${remote.name}": ${e.message}`);
+            }
+        }
+    }
+
+    return result;
+}

package/src/repo-mesh-types.ts

@@ -0,0 +1,212 @@
+/**
+ * Repo Mesh Types — Cross-package type definitions for repo-scoped orchestration
+ *
+ * A Repo Mesh is a repo-scoped execution environment that groups
+ * machines/workspaces around one Git repository identity. A coordinator
+ * agent delegates work to mesh nodes via natural conversation.
+ *
+ * These types are OSS-level and usable without cloud infrastructure.
+ * Import via: import type { ... } from '@adhdev/daemon-core/repo-mesh-types'
+ *
+ * IMPORTANT: This file must remain runtime-free (types only).
+ */
+
+import type { GitRepoStatus, GitCompactSummary } from './git/git-types.js';
+
+// ─── Core Mesh Types ────────────────────────────
+
+export interface RepoMesh {
+    id: string;
+    name: string;
+    repoIdentity: string;
+    repoRemoteUrl?: string;
+    defaultBranch?: string;
+    policy: RepoMeshPolicy;
+    coordinator: RepoMeshCoordinatorConfig;
+    projectContext: ProjectContextSnapshot;
+    nodes: RepoMeshNode[];
+    status: 'active' | 'archived' | 'deleted';
+}
+
+export interface RepoMeshNode {
+    id: string;
+    daemonId: string;
+    machineId?: string;
+    machineLabel: string;
+    workspace: string;
+    repoRoot?: string;
+    git?: GitCompactSummary;
+    providers: string[];
+    detectedCapabilities: RepoMeshNodeCapabilities;
+    userOverrides: Partial<RepoMeshNodeCapabilities>;
+    effectiveCapabilities: RepoMeshNodeCapabilities;
+    policy: RepoMeshNodePolicy;
+    health: RepoMeshNodeHealth;
+    status: 'enabled' | 'disabled' | 'removed';
+}
+
+export type RepoMeshNodeHealth =
+    | 'online'
+    | 'offline'
+    | 'degraded'
+    | 'dirty'
+    | 'wrong_branch'
+    | 'unknown';
+
+// ─── Policy Types ───────────────────────────────
+
+export interface RepoMeshPolicy {
+    requirePreTaskCheckpoint: boolean;
+    requirePostTaskCheckpoint: boolean;
+    requireApprovalForPush: boolean;
+    requireApprovalForDestructiveGit: boolean;
+    dirtyWorkspaceBehavior: 'block' | 'warn' | 'checkpoint_then_continue';
+    maxParallelTasks: number;
+    allowedProviders?: string[];
+}
+
+export interface RepoMeshNodePolicy {
+    readOnly?: boolean;
+    canPush?: boolean;
+    maxConcurrentSessions?: number;
+}
+
+export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {
+    requirePreTaskCheckpoint: false,
+    requirePostTaskCheckpoint: true,
+    requireApprovalForPush: true,
+    requireApprovalForDestructiveGit: true,
+    dirtyWorkspaceBehavior: 'warn',
+    maxParallelTasks: 2,
+};
+
+// ─── Capabilities ───────────────────────────────
+
+export interface RepoMeshNodeCapabilities {
+    platform?: string;
+    packageManagers?: string[];
+    detectedCommands?: DetectedCommand[];
+    canRunLongJobs?: boolean;
+    canRunDocker?: boolean;
+    canRunBrowserE2E?: boolean;
+    canAccessSecrets?: boolean;
+    canPush?: boolean;
+    readOnly?: boolean;
+    userLabels?: string[];
+}
+
+export interface DetectedCommand {
+    command: string;
+    sourcePath: string;
+    confidence: 'high' | 'medium' | 'low';
+    requiresApproval?: boolean;
+}
+
+// ─── Project Context ────────────────────────────
+
+export interface ProjectContextSnapshot {
+    version: number;
+    generatedAt: string;
+    sources: ProjectContextSource[];
+    repo: {
+        identity: string;
+        remoteUrl?: string;
+        defaultBranch?: string;
+        currentBranches: string[];
+    };
+    layout: {
+        packageManager?: string;
+        workspaceFiles: string[];
+        packageRoots: string[];
+        likelyEntryPoints: string[];
+    };
+    commands: {
+        build?: DetectedCommand[];
+        test?: DetectedCommand[];
+        typecheck?: DetectedCommand[];
+        lint?: DetectedCommand[];
+        e2e?: DetectedCommand[];
+    };
+    instructions: {
+        files: string[];
+        summary: string;
+    };
+    conventions: {
+        pathHints: string[];
+        validationNotes: string[];
+        riskyAreas: string[];
+    };
+}
+
+export interface ProjectContextSource {
+    kind: 'daemon_status' | 'git' | 'project_file' | 'instruction_file' | 'user_override' | 'probe_error';
+    nodeId?: string;
+    path?: string;
+    observedAt: string;
+    confidence: 'high' | 'medium' | 'low';
+}
+
+// ─── Coordinator Config ─────────────────────────
+
+export interface RepoMeshCoordinatorConfig {
+    /** Provider to use for coordinator session (e.g. 'claude-cli', 'cursor') */
+    providerType?: string;
+    /** Preferred node to run coordinator on (null = auto) */
+    preferredNodeId?: string;
+    /** Additional system prompt context for coordinator */
+    systemPromptSuffix?: string;
+}
+
+// ─── Local Mesh Config (OSS standalone) ─────────
+
+/**
+ * Local mesh configuration stored in ~/.adhdev/meshes.json
+ * Used by OSS standalone mode without cloud infrastructure.
+ */
+export interface LocalMeshConfig {
+    meshes: LocalMeshEntry[];
+}
+
+export interface LocalMeshEntry {
+    id: string;
+    name: string;
+    repoIdentity: string;
+    repoRemoteUrl?: string;
+    defaultBranch?: string;
+    policy: RepoMeshPolicy;
+    coordinator: RepoMeshCoordinatorConfig;
+    nodes: LocalMeshNodeEntry[];
+    createdAt: string;
+    updatedAt: string;
+}
+
+export interface LocalMeshNodeEntry {
+    id: string;
+    workspace: string;
+    repoRoot?: string;
+    userOverrides: Partial<RepoMeshNodeCapabilities>;
+    policy: RepoMeshNodePolicy;
+    /** For single-machine mesh: same daemon, different worktree */
+    isLocalWorktree?: boolean;
+}
+
+// ─── Mesh Status (runtime, not persisted) ───────
+
+export interface RepoMeshStatus {
+    meshId: string;
+    meshName: string;
+    repoIdentity: string;
+    refreshedAt: string;
+    nodes: RepoMeshNodeStatus[];
+}
+
+export interface RepoMeshNodeStatus {
+    nodeId: string;
+    machineLabel: string;
+    workspace: string;
+    health: RepoMeshNodeHealth;
+    git?: GitRepoStatus;
+    providers: string[];
+    activeSessions: string[];
+    error?: string;
+}