@powerhousedao/vetra-builder-package 5.0.2 → 5.1.0-staging

package/dist/scripts/create-remote-drives.js

@@ -0,0 +1,946 @@
+#!/usr/bin/env tsx
+/**
+ * Create Remote Drives from GitHub Repositories
+ *
+ * This script:
+ * 1. Fetches powerhouse.manifest.json from GitHub repositories
+ * 2. Creates remote drives at localhost:4001/graphql
+ * 3. Creates package documents in each drive with manifest data
+ * 4. Creates document model documents with full specifications
+ *
+ * Usage (from project root):
+ *   npm run create-drives
+ *   OR
+ *   npx tsx scripts/create-remote-drives.ts
+ */
+import { generateId } from "document-model/core";
+import { ReactorBuilder, MemoryStorage, InMemoryCache, SynchronizationManager, DefaultEventEmitter, EventQueueManager, ListenerManager, baseDocumentModels, } from "document-drive";
+import * as documentModels from "../document-models/index.js";
+import * as vetraDocumentModels from "@powerhousedao/vetra/document-models";
+// List of GitHub repository URLs to process
+const GITHUB_REPOS = [
+    // "https://github.com/powerhouse-inc/vetra-builder-package",
+    // "https://github.com/powerhouse-inc/network-admin",
+    // "https://github.com/powerhouse-inc/project-management",
+    // "https://github.com/powerhouse-inc/contributor-billing",
+    // "https://github.com/powerhouse-inc/effective-octo-adventure",
+    // "https://github.com/powerhouse-inc/renown-package",
+    "https://github.com/powerhouse-inc/chatroom-demo",
+    // Add more repository URLs here
+];
+// GraphQL endpoint
+const GRAPHQL_ENDPOINT = "https://switchboard.vetra.io/graphql";
+// const GRAPHQL_ENDPOINT = "http://localhost:4001/graphql";
+/**
+ * Convert string to kebab-case
+ */
+function toKebabCase(str) {
+    return (str
+        // Insert hyphen before uppercase letters
+        .replace(/([a-z])([A-Z])/g, "$1-$2")
+        // Convert to lowercase
+        .toLowerCase()
+        // Replace spaces and other non-alphanumeric chars with hyphens
+        .replace(/[^a-z0-9]+/g, "-")
+        // Remove leading/trailing hyphens
+        .replace(/^-+|-+$/g, ""));
+}
+/**
+ * Fetch document model specs that exist in the repository
+ */
+async function fetchDocumentModelSpecs(repoUrl, documentModels) {
+    const results = [];
+    const seenSpecs = new Set();
+    // Try to fetch each document model JSON file
+    for (const model of documentModels) {
+        try {
+            // Convert model name to kebab-case for filename
+            const filename = toKebabCase(model.name);
+            const rawUrl = repoUrl
+                .replace("https://github.com/", "https://raw.githubusercontent.com/")
+                .replace(/\/$/, "") +
+                `/main/document-models/${filename}/${filename}.json`;
+            const response = await fetch(rawUrl);
+            if (response.ok) {
+                const spec = await response.json();
+                // Deduplicate by spec.id to avoid showing same model multiple times
+                if (!seenSpecs.has(spec.id)) {
+                    seenSpecs.add(spec.id);
+                    results.push({ id: spec.id, name: spec.name, spec });
+                }
+            }
+            else {
+                // Try master branch as fallback
+                const masterUrl = rawUrl.replace("/main/", "/master/");
+                const masterResponse = await fetch(masterUrl);
+                if (masterResponse.ok) {
+                    const spec = await masterResponse.json();
+                    if (!seenSpecs.has(spec.id)) {
+                        seenSpecs.add(spec.id);
+                        results.push({ id: spec.id, name: spec.name, spec });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Skip models that don't exist in this repo
+            continue;
+        }
+    }
+    return results;
+}
+/**
+ * Fetch powerhouse.manifest.json from GitHub repository
+ */
+async function fetchManifest(repoUrl) {
+    // Convert GitHub URL to raw content URL
+    // https://github.com/user/repo -> https://raw.githubusercontent.com/user/repo/main/powerhouse.manifest.json
+    const rawUrl = repoUrl
+        .replace("https://github.com/", "https://raw.githubusercontent.com/")
+        .replace(/\/$/, "") + "/main/powerhouse.manifest.json";
+    console.log(`📥 Fetching manifest from: ${rawUrl}`);
+    try {
+        const response = await fetch(rawUrl);
+        if (!response.ok) {
+            // Try with 'master' branch if 'main' fails
+            const masterUrl = rawUrl.replace("/main/", "/master/");
+            console.log(`  ⚠ Main branch failed, trying master: ${masterUrl}`);
+            const masterResponse = await fetch(masterUrl);
+            if (!masterResponse.ok) {
+                throw new Error(`Failed to fetch manifest: ${response.status} ${response.statusText}`);
+            }
+            const manifest = await masterResponse.json();
+            console.log(`  ✓ Fetched manifest: ${manifest.name}`);
+            return manifest;
+        }
+        const manifest = await response.json();
+        console.log(`  ✓ Fetched manifest: ${manifest.name}`);
+        return manifest;
+    }
+    catch (error) {
+        console.error(`  ✗ Error fetching manifest:`, error);
+        throw error;
+    }
+}
+/**
+ * Create a remote drive via GraphQL mutation (or skip if it already exists)
+ */
+async function createDrive(manifest, repoUrl) {
+    const driveName = manifest.name;
+    const driveId = toKebabCase(manifest.name);
+    const driveSlug = driveId;
+    console.log(`\n📁 Creating drive: ${driveName}`);
+    console.log(`  ID: ${driveId}`);
+    console.log(`  Slug: ${driveSlug}`);
+    const mutation = `
+    mutation AddDrive($id: String, $name: String!, $slug: String, $preferredEditor: String) {
+      addDrive(
+        id: $id
+        name: $name
+        slug: $slug
+        preferredEditor: $preferredEditor
+      ) {
+        id
+        name
+        slug
+        preferredEditor
+      }
+    }
+  `;
+    const variables = {
+        id: driveId,
+        name: driveName,
+        slug: driveSlug,
+        preferredEditor: "vetra-drive-app",
+    };
+    try {
+        const response = await fetch(GRAPHQL_ENDPOINT, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                query: mutation,
+                variables,
+            }),
+        });
+        const result = await response.json();
+        if (result.errors) {
+            // Check if the error is about drive already existing
+            const alreadyExistsError = result.errors.find((err) => err.message?.includes("uses id that already exists"));
+            if (alreadyExistsError) {
+                console.log(`  ℹ Drive already exists, skipping creation`);
+                return driveId;
+            }
+            console.error(`  ✗ GraphQL errors:`, JSON.stringify(result.errors, null, 2));
+            throw new Error(`Failed to create drive: ${JSON.stringify(result.errors)}`);
+        }
+        const createdDrive = result.data?.addDrive;
+        console.log(`  ✓ Drive created successfully`);
+        console.log(`    ID: ${createdDrive.id}`);
+        console.log(`    Name: ${createdDrive.name}`);
+        console.log(`    Slug: ${createdDrive.slug}`);
+        return createdDrive.id;
+    }
+    catch (error) {
+        console.error(`  ✗ Error creating drive:`, error);
+        throw error;
+    }
+}
+/**
+ * Create a package document in the drive
+ */
+async function createPackageDocument(driveId, manifest, repoUrl) {
+    console.log(`\n📦 Creating package document in drive: ${driveId}`);
+    // Using VetraPackage_createDocument mutation
+    const mutation = `
+    mutation VetraPackage_createDocument($driveId: String, $name: String) {
+      VetraPackage_createDocument(driveId: $driveId, name: $name)
+    }
+  `;
+    const variables = {
+        name: manifest.name,
+        driveId: driveId,
+    };
+    try {
+        const response = await fetch(GRAPHQL_ENDPOINT, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                query: mutation,
+                variables,
+            }),
+        });
+        const result = await response.json();
+        if (result.errors) {
+            console.error(`  ✗ GraphQL errors:`, JSON.stringify(result.errors, null, 2));
+            throw new Error(`Failed to create package document: ${JSON.stringify(result.errors)}`);
+        }
+        const documentId = result.data?.VetraPackage_createDocument;
+        console.log(`  ✓ Package document created`);
+        console.log(`    Document ID (PHID): ${documentId}`);
+        return documentId;
+    }
+    catch (error) {
+        console.error(`  ✗ Error creating package document:`, error);
+        throw error;
+    }
+}
+/**
+ * Create an editor document in the drive
+ */
+async function createEditorDocument(driveId, editor) {
+    // Create the editor document
+    const createMutation = `
+    mutation DocumentEditor_createDocument($driveId: String, $name: String!) {
+      DocumentEditor_createDocument(driveId: $driveId, name: $name)
+    }
+  `;
+    const createResponse = await fetch(GRAPHQL_ENDPOINT, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            query: createMutation,
+            variables: {
+                driveId,
+                name: editor.name,
+            },
+        }),
+    });
+    const createResult = await createResponse.json();
+    if (createResult.errors) {
+        throw new Error(`Failed to create editor: ${JSON.stringify(createResult.errors)}`);
+    }
+    const documentId = createResult.data?.DocumentEditor_createDocument;
+    // Set editor name (using ID as fallback)
+    const setNameMutation = `
+    mutation DocumentEditor_setEditorName($driveId: String, $docId: PHID, $input: DocumentEditor_SetEditorNameInput) {
+      DocumentEditor_setEditorName(driveId: $driveId, docId: $docId, input: $input)
+    }
+  `;
+    await fetch(GRAPHQL_ENDPOINT, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            query: setNameMutation,
+            variables: {
+                driveId,
+                docId: documentId,
+                input: { name: editor.id },
+            },
+        }),
+    });
+    // Add document types
+    for (const docType of editor.documentTypes) {
+        const addTypeMutation = `
+      mutation DocumentEditor_addDocumentType($driveId: String, $docId: PHID, $input: DocumentEditor_AddDocumentTypeInput) {
+        DocumentEditor_addDocumentType(driveId: $driveId, docId: $docId, input: $input)
+      }
+    `;
+        await fetch(GRAPHQL_ENDPOINT, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                query: addTypeMutation,
+                variables: {
+                    driveId,
+                    docId: documentId,
+                    input: { documentType: docType },
+                },
+            }),
+        });
+    }
+    return documentId;
+}
+/**
+ * Create a subgraph document in the drive
+ */
+async function createSubgraphDocument(driveId, subgraph) {
+    // Create the subgraph document
+    const createMutation = `
+    mutation SubgraphModule_createDocument($driveId: String, $name: String!) {
+      SubgraphModule_createDocument(driveId: $driveId, name: $name)
+    }
+  `;
+    const createResponse = await fetch(GRAPHQL_ENDPOINT, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            query: createMutation,
+            variables: {
+                driveId,
+                name: subgraph.name,
+            },
+        }),
+    });
+    const createResult = await createResponse.json();
+    if (createResult.errors) {
+        throw new Error(`Failed to create subgraph: ${JSON.stringify(createResult.errors)}`);
+    }
+    const documentId = createResult.data?.SubgraphModule_createDocument;
+    // Set subgraph name (using ID)
+    const setNameMutation = `
+    mutation SubgraphModule_setSubgraphName($driveId: String, $docId: PHID, $input: SubgraphModule_SetSubgraphNameInput) {
+      SubgraphModule_setSubgraphName(driveId: $driveId, docId: $docId, input: $input)
+    }
+  `;
+    await fetch(GRAPHQL_ENDPOINT, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            query: setNameMutation,
+            variables: {
+                driveId,
+                docId: documentId,
+                input: { name: subgraph.id },
+            },
+        }),
+    });
+    return documentId;
+}
+/**
+ * Retry with exponential backoff
+ */
+async function retryWithBackoff(fn, maxRetries = 3, baseDelay = 1000) {
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < maxRetries - 1) {
+                const delay = baseDelay * Math.pow(2, attempt);
+                console.log(`  ⚠ Attempt ${attempt + 1} failed, retrying in ${delay}ms...`);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+    }
+    throw lastError;
+}
+/**
+ * Wait for sync to complete by checking drive state
+ */
+async function waitForSync(driveServer, driveId, timeout = 15000) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+        try {
+            // Try to get the drive - if it succeeds, sync is complete
+            await driveServer.getDrive(driveId);
+            // Add an additional small delay after drive is accessible
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            return;
+        }
+        catch (error) {
+            // Drive not ready yet, wait a bit
+            await new Promise((resolve) => setTimeout(resolve, 300));
+        }
+    }
+    throw new Error(`Sync timeout after ${timeout}ms`);
+}
+// Shared drive server instance
+let sharedDriveServer = null;
+/**
+ * Get or create the shared drive server instance
+ */
+async function getSharedDriveServer() {
+    if (!sharedDriveServer) {
+        const allDocumentModels = [
+            ...baseDocumentModels,
+            ...Object.values(documentModels),
+            ...Object.values(vetraDocumentModels),
+        ];
+        sharedDriveServer = new ReactorBuilder(allDocumentModels).build();
+        await sharedDriveServer.initialize();
+    }
+    return sharedDriveServer;
+}
+/**
+ * Cleanup the shared drive server
+ */
+async function cleanupSharedDriveServer() {
+    if (sharedDriveServer) {
+        if (typeof sharedDriveServer.shutdown === "function") {
+            await sharedDriveServer.shutdown();
+        }
+        sharedDriveServer = null;
+    }
+}
+/**
+ * Register remote drive with local drive server to enable processors
+ */
+async function registerRemoteDrive(driveId) {
+    const SWITCHBOARD_URL = "https://switchboard.vetra.io";
+    const remoteDriveUrl = `${SWITCHBOARD_URL}/d/${driveId}`;
+    // Get shared drive server
+    const driveServer = await getSharedDriveServer();
+    // Add remote drive (with retry logic)
+    await retryWithBackoff(async () => {
+        try {
+            // Check if drive already exists
+            await driveServer.getDrive(driveId);
+            console.log(`  ✓ Drive ${driveId} already registered in local server`);
+        }
+        catch (error) {
+            // Drive doesn't exist, add it
+            console.log(`  📡 Registering remote drive: ${remoteDriveUrl}`);
+            try {
+                await driveServer.addRemoteDrive(remoteDriveUrl, {
+                    availableOffline: true,
+                    listeners: [
+                        {
+                            block: true,
+                            callInfo: {
+                                data: remoteDriveUrl,
+                                name: "switchboard-push",
+                                transmitterType: "SwitchboardPush",
+                            },
+                            filter: {
+                                branch: ["main"],
+                                documentId: ["*"],
+                                documentType: ["*"],
+                                scope: ["global"],
+                            },
+                            listenerId: generateId(),
+                            label: "Switchboard Sync",
+                            system: true,
+                        },
+                    ],
+                    sharingType: "public",
+                    triggers: [],
+                });
+                // Wait for initial sync
+                console.log(`  ⏳ Waiting for drive sync...`);
+                await waitForSync(driveServer, driveId);
+                console.log(`  ✓ Drive registered and synced`);
+            }
+            catch (syncError) {
+                // If sync fails, it might be because the drive is still being created on remote
+                console.log(`  ⚠ Sync warning (may be expected):`, syncError instanceof Error ? syncError.message : String(syncError));
+                // Give it a moment and try to get the drive anyway
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+        }
+    }, 5, 1000);
+}
+/**
+ * Create document model document using drive server sync approach
+ * Steps:
+ * 1. Use shared drive server with ALL document models loaded
+ * 2. Add remote drive for synchronization (if not already added)
+ * 3. Wait for syncing to complete
+ * 4. Create new document
+ * 5. Add operations to populate document
+ * 6. Wait for operations to sync
+ */
+async function createDocumentModelDocumentViaDriveServer(driveId, name, spec) {
+    const SWITCHBOARD_URL = "http://localhost:4001";
+    const remoteDriveUrl = `${SWITCHBOARD_URL}/d/${driveId}`;
+    // Step 1: Get shared drive server
+    const driveServer = await getSharedDriveServer();
+    // Step 2: Add remote drive (with retry logic)
+    await retryWithBackoff(async () => {
+        try {
+            // Check if drive already exists
+            await driveServer.getDrive(driveId);
+            console.log(`  ✓ Drive ${driveId} already exists in local server`);
+        }
+        catch (error) {
+            // Drive doesn't exist, add it
+            console.log(`  📡 Adding remote drive: ${remoteDriveUrl}`);
+            try {
+                await driveServer.addRemoteDrive(remoteDriveUrl, {
+                    availableOffline: true,
+                    listeners: [
+                        {
+                            block: true,
+                            callInfo: {
+                                data: remoteDriveUrl,
+                                name: "switchboard-push",
+                                transmitterType: "SwitchboardPush",
+                            },
+                            filter: {
+                                branch: ["main"],
+                                documentId: ["*"],
+                                documentType: ["*"],
+                                scope: ["global"],
+                            },
+                            listenerId: generateId(),
+                            label: "Switchboard Sync",
+                            system: true,
+                        },
+                    ],
+                    sharingType: "public",
+                    triggers: [],
+                });
+                // Step 3: Wait for initial sync
+                console.log(`  ⏳ Waiting for initial sync...`);
+                await waitForSync(driveServer, driveId);
+                console.log(`  ✓ Sync complete`);
+            }
+            catch (syncError) {
+                // If sync fails, it might be because the drive is still being created on remote
+                console.log(`  ⚠ Sync warning (may be expected):`, syncError instanceof Error ? syncError.message : String(syncError));
+                // Give it a moment and try to get the drive anyway
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+        }
+    }, 5, 1000);
+    // Step 4: Create new document (with retry)
+    const createResult = await retryWithBackoff(async () => {
+        return await driveServer.createDocument({
+            driveId,
+            documentType: "powerhouse/document-model",
+            name,
+            // Don't pass id - let it be auto-generated with signed header
+        });
+    });
+    const documentId = createResult.documentId || createResult.id || createResult;
+    // Small delay to let document creation propagate
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    // Step 5: Add operations from spec to populate the document
+    if (spec.specifications && spec.specifications.length > 0) {
+        const specification = spec.specifications[0];
+        const actions = [];
+        // Add basic metadata
+        actions.push({ type: "SET_MODEL_NAME", input: { name: spec.name } });
+        actions.push({ type: "SET_MODEL_ID", input: { id: spec.id } });
+        actions.push({
+            type: "SET_MODEL_EXTENSION",
+            input: { extension: spec.extension },
+        });
+        actions.push({
+            type: "SET_MODEL_DESCRIPTION",
+            input: { description: spec.description },
+        });
+        actions.push({
+            type: "SET_AUTHOR_NAME",
+            input: { name: spec.author.name },
+        });
+        actions.push({
+            type: "SET_AUTHOR_WEBSITE",
+            input: { website: spec.author.website },
+        });
+        // Add state schema
+        if (specification.state?.global?.schema) {
+            actions.push({
+                type: "SET_STATE_SCHEMA",
+                input: {
+                    schema: specification.state.global.schema,
+                    scope: "global",
+                },
+            });
+        }
+        if (specification.state?.global?.initialValue) {
+            actions.push({
+                type: "SET_INITIAL_STATE",
+                input: {
+                    initialValue: specification.state.global.initialValue,
+                    scope: "global",
+                },
+            });
+        }
+        // Add modules and operations
+        if (specification.modules) {
+            for (const module of specification.modules) {
+                actions.push({
+                    type: "ADD_MODULE",
+                    input: {
+                        id: module.id,
+                        name: module.name,
+                        description: module.description || "",
+                    },
+                });
+                if (module.operations) {
+                    for (const operation of module.operations) {
+                        actions.push({
+                            type: "ADD_OPERATION",
+                            input: {
+                                id: operation.id,
+                                moduleId: module.id,
+                                name: operation.name,
+                                description: operation.description || "",
+                                scope: operation.scope,
+                            },
+                        });
+                        if (operation.schema) {
+                            actions.push({
+                                type: "SET_OPERATION_SCHEMA",
+                                input: {
+                                    id: operation.id,
+                                    schema: operation.schema,
+                                },
+                            });
+                        }
+                        if (operation.reducer) {
+                            actions.push({
+                                type: "SET_OPERATION_REDUCER",
+                                input: {
+                                    id: operation.id,
+                                    reducer: operation.reducer,
+                                },
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // Apply all actions (with retry)
+        await retryWithBackoff(async () => {
+            await driveServer.addActions(documentId, actions);
+        });
+    }
+    // Step 6: Wait for operations to sync (increased delay for large documents)
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    return documentId;
+}
+/**
+ * Create a processor document in the drive
+ */
+async function createProcessorDocument(driveId, processor) {
+    // Create the processor document
+    const createMutation = `
+    mutation ProcessorModule_createDocument($driveId: String, $name: String!) {
+      ProcessorModule_createDocument(driveId: $driveId, name: $name)
+    }
+  `;
+    const createResponse = await fetch(GRAPHQL_ENDPOINT, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            query: createMutation,
+            variables: {
+                driveId,
+                name: processor.name,
+            },
+        }),
+    });
+    const createResult = await createResponse.json();
+    if (createResult.errors) {
+        throw new Error(`Failed to create processor: ${JSON.stringify(createResult.errors)}`);
+    }
+    const documentId = createResult.data?.ProcessorModule_createDocument;
+    // Set processor name (using ID)
+    const setNameMutation = `
+    mutation ProcessorModule_setProcessorName($driveId: String, $docId: PHID, $input: ProcessorModule_SetProcessorNameInput) {
+      ProcessorModule_setProcessorName(driveId: $driveId, docId: $docId, input: $input)
+    }
+  `;
+    await fetch(GRAPHQL_ENDPOINT, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            query: setNameMutation,
+            variables: {
+                driveId,
+                docId: documentId,
+                input: { name: processor.id },
+            },
+        }),
+    });
+    // Add document types
+    for (const docType of processor.documentTypes) {
+        const addTypeMutation = `
+      mutation ProcessorModule_addDocumentType($driveId: String, $docId: PHID, $input: ProcessorModule_AddDocumentTypeInput) {
+        ProcessorModule_addDocumentType(driveId: $driveId, docId: $docId, input: $input)
+      }
+    `;
+        await fetch(GRAPHQL_ENDPOINT, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                query: addTypeMutation,
+                variables: {
+                    driveId,
+                    docId: documentId,
+                    input: { documentType: docType },
+                },
+            }),
+        });
+    }
+    return documentId;
+}
+/**
+ * Set package document fields via GraphQL mutations
+ */
+async function updatePackageDocument(driveId, documentId, manifest, repoUrl) {
+    console.log(`\n⚙️  Updating package document fields...`);
+    // Set basic package info
+    const operations = [
+        {
+            name: "SET_PACKAGE_NAME",
+            mutation: "VetraPackage_setPackageName",
+            input: { name: manifest.name },
+        },
+        {
+            name: "SET_PACKAGE_DESCRIPTION",
+            mutation: "VetraPackage_setPackageDescription",
+            input: { description: manifest.description },
+        },
+        {
+            name: "SET_PACKAGE_CATEGORY",
+            mutation: "VetraPackage_setPackageCategory",
+            input: { category: manifest.category },
+        },
+        {
+            name: "SET_PACKAGE_AUTHOR",
+            mutation: "VetraPackage_setPackageAuthor",
+            input: {
+                name: manifest.publisher.name,
+                website: manifest.publisher.url,
+            },
+        },
+        {
+            name: "SET_PACKAGE_GITHUB_URL",
+            mutation: "VetraPackage_setPackageGithubUrl",
+            input: { url: repoUrl },
+        },
+    ];
+    // Add npm URL if available
+    if (manifest.npmUrl) {
+        operations.push({
+            name: "SET_PACKAGE_NPM_URL",
+            mutation: "VetraPackage_setPackageNpmUrl",
+            input: { url: manifest.npmUrl },
+        });
+    }
+    for (const op of operations) {
+        try {
+            const mutation = `
+        mutation Update($driveId: String, $docId: PHID, $input: VetraPackage_${op.name
+                .split("_")
+                .map((p) => p.charAt(0) + p.slice(1).toLowerCase())
+                .join("")}Input) {
+          ${op.mutation}(driveId: $driveId, docId: $docId, input: $input)
+        }
+      `;
+            const variables = {
+                driveId,
+                docId: documentId,
+                input: op.input,
+            };
+            const response = await fetch(GRAPHQL_ENDPOINT, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    query: mutation,
+                    variables,
+                }),
+            });
+            const result = await response.json();
+            if (result.errors) {
+                console.log(`  ⚠ Skipping ${op.name}: ${result.errors[0]?.message}`);
+            }
+            else {
+                console.log(`  ✓ ${op.name}`);
+            }
+        }
+        catch (error) {
+            console.log(`  ⚠ Skipping ${op.name}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Create editor documents
+    if (manifest.editors && manifest.editors.length > 0) {
+        console.log(`\n  📝 Creating ${manifest.editors.length} editor documents...`);
+        for (let i = 0; i < manifest.editors.length; i++) {
+            const editor = manifest.editors[i];
+            try {
+                await createEditorDocument(driveId, editor);
+                console.log(`    ✓ ${editor.name}`);
+                // Add delay between editor creations (except after the last one)
+                if (i < manifest.editors.length - 1) {
+                    await new Promise((resolve) => setTimeout(resolve, 500));
+                }
+            }
+            catch (error) {
+                console.log(`    ⚠ Failed to create ${editor.name}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    // Create subgraph documents
+    if (manifest.subgraphs && manifest.subgraphs.length > 0) {
+        console.log(`\n  📊 Creating ${manifest.subgraphs.length} subgraph documents...`);
+        for (const subgraph of manifest.subgraphs) {
+            try {
+                await createSubgraphDocument(driveId, subgraph);
+                console.log(`    ✓ ${subgraph.name}`);
+            }
+            catch (error) {
+                console.log(`    ⚠ Failed to create ${subgraph.name}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    // Create processor documents
+    if (manifest.processors && manifest.processors.length > 0) {
+        console.log(`\n  ⚙️  Creating ${manifest.processors.length} processor documents...`);
+        for (const processor of manifest.processors) {
+            try {
+                await createProcessorDocument(driveId, processor);
+                console.log(`    ✓ ${processor.name}`);
+            }
+            catch (error) {
+                console.log(`    ⚠ Failed to create ${processor.name}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    // Create document model documents using drive server sync
+    if (manifest.documentModels && manifest.documentModels.length > 0) {
+        console.log(`\n  📋 Fetching document model specifications from repository...`);
+        const documentModelSpecs = await fetchDocumentModelSpecs(repoUrl, manifest.documentModels);
+        if (documentModelSpecs.length > 0) {
+            console.log(`     Found ${documentModelSpecs.length} document model(s) in this repository`);
+            console.log(`\n  📄 Creating document model documents...`);
+            for (let i = 0; i < documentModelSpecs.length; i++) {
+                const { id, name, spec } = documentModelSpecs[i];
+                try {
+                    await createDocumentModelDocumentViaDriveServer(driveId, name, spec);
+                    const version = spec.specifications?.[0]?.version || "unknown";
+                    const modulesCount = spec.specifications?.[0]?.modules?.length || 0;
+                    const operationsCount = spec.specifications?.[0]?.modules?.reduce((total, mod) => total + (mod.operations?.length || 0), 0) || 0;
+                    console.log(`    ✓ ${name} (v${version}) - ${modulesCount} modules, ${operationsCount} operations`);
+                    // Add delay between document model creations (except after the last one)
+                    if (i < documentModelSpecs.length - 1) {
+                        console.log(`    ⏱  Waiting before next document model...`);
+                        await new Promise((resolve) => setTimeout(resolve, 1500));
+                    }
+                }
+                catch (error) {
+                    console.log(`    ⚠ Failed to create ${name}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        else {
+            console.log(`     ⚠ No document model files found in this repository`);
+            console.log(`     Listed in manifest: ${manifest.documentModels
+                .map((m) => m.name)
+                .join(", ")}`);
+        }
+    }
+}
+/**
+ * Process a single repository
+ */
+async function processRepository(repoUrl) {
+    console.log(`\n${"=".repeat(80)}`);
+    console.log(`Processing: ${repoUrl}`);
+    console.log("=".repeat(80));
+    try {
+        // Step 1: Fetch manifest
+        const manifest = await fetchManifest(repoUrl);
+        // Step 2: Create drive
+        const driveId = await createDrive(manifest, repoUrl);
+        // Step 2.5: Register drive with local server to enable processors
+        console.log(`\n🔌 Registering drive to enable processors...`);
+        await registerRemoteDrive(driveId);
+        // Step 3: Create package document
+        const documentId = await createPackageDocument(driveId, manifest, repoUrl);
+        // Step 4: Update package document with manifest data
+        await updatePackageDocument(driveId, documentId, manifest, repoUrl);
+        console.log(`\n✅ Successfully processed: ${manifest.name}`);
+        console.log(`   Drive ID: ${driveId}`);
+        console.log(`   Document ID: ${documentId}`);
+        console.log(`   Drive URL: http://localhost:4001/d/${driveId}`);
+    }
+    catch (error) {
+        console.error(`\n❌ Failed to process ${repoUrl}:`, error);
+    }
+}
+/**
+ * Main function
+ */
+async function main() {
+    console.log("=== Create Remote Drives from GitHub Repositories ===");
+    console.log(`GraphQL Endpoint: ${GRAPHQL_ENDPOINT}`);
+    console.log(`Repositories to process: ${GITHUB_REPOS.length}`);
+    let successCount = 0;
+    let errorCount = 0;
+    try {
+        for (const repoUrl of GITHUB_REPOS) {
+            try {
+                await processRepository(repoUrl);
+                successCount++;
+            }
+            catch (error) {
+                errorCount++;
+                console.error(`Error processing ${repoUrl}:`, error);
+            }
+        }
+        console.log(`\n${"=".repeat(80)}`);
+        console.log("=== Summary ===");
+        console.log(`Total repositories: ${GITHUB_REPOS.length}`);
+        console.log(`✓ Success: ${successCount}`);
+        console.log(`✗ Errors: ${errorCount}`);
+        console.log("=".repeat(80));
+    }
+    finally {
+        // Cleanup shared drive server
+        console.log("\n🧹 Cleaning up shared drive server...");
+        await cleanupSharedDriveServer();
+        console.log("✓ Cleanup complete");
+    }
+    if (errorCount > 0) {
+        process.exit(1);
+    }
+}
+// Run the script
+main().catch(console.error);