@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/stores/plugin.svelte.js

@@ -0,0 +1,410 @@
+/**
+ * Plugin store using Svelte 5 runes.
+ *
+ * Manages the proposal-based plugin lifecycle (draft → review → testing →
+ * deployed) against a backend "plugin host". The host is expected to expose a
+ * REST + Server-Sent-Events API under a configurable base path (default
+ * `/api/plugins`); see {@link connect} and the fetch helpers below for the
+ * exact contract.
+ *
+ * Note: Svelte 5 modules cannot directly export $derived values.
+ * We use getter functions to expose reactive derived state.
+ */
+// Reactive state
+let state = $state({
+    proposals: [],
+    instances: new Map(),
+    commands: new Map(),
+    panels: new Map(),
+    eventSource: null,
+    connected: false,
+    loadingProposals: false,
+    loadingInstance: null,
+    error: null
+});
+/**
+ * Offline seeding: populate the store with proposals without any network call.
+ * When seeded, connect()/fetchProposals() no-op so an embedded panel renders the
+ * seeded data on a static host (e.g. the docs demo) with no spinner or error.
+ * Internal utility — intentionally NOT re-exported from the package root.
+ */
+let demoOffline = false;
+export function seedProposals(proposals) {
+    demoOffline = true;
+    state.proposals = proposals;
+    state.loadingProposals = false;
+    state.connected = true;
+    state.error = null;
+}
+// Getter functions for derived values (Svelte 5 module-safe)
+export function getProposals() {
+    return state.proposals;
+}
+export function getInstances() {
+    return Array.from(state.instances.values());
+}
+export function getActiveInstances() {
+    return getInstances().filter((i) => i.status === 'active');
+}
+export function getCommands() {
+    return Array.from(state.commands.values());
+}
+export function getPanels() {
+    return Array.from(state.panels.values());
+}
+export function getConnected() {
+    return state.connected;
+}
+export function getLoadingProposals() {
+    return state.loadingProposals;
+}
+export function getLoadingInstance() {
+    return state.loadingInstance;
+}
+export function getError() {
+    return state.error;
+}
+export function getDraftProposals() {
+    return state.proposals.filter((p) => p.status === 'draft');
+}
+export function getReviewingProposals() {
+    return state.proposals.filter((p) => p.status === 'reviewing');
+}
+export function getDeployedProposals() {
+    return state.proposals.filter((p) => p.status === 'deployed');
+}
+// Legacy aliases for backward compatibility
+export const proposals = { get current() { return getProposals(); } };
+export const instances = { get current() { return getInstances(); } };
+export const activeInstances = { get current() { return getActiveInstances(); } };
+export const commands = { get current() { return getCommands(); } };
+export const panels = { get current() { return getPanels(); } };
+export const connected = { get current() { return getConnected(); } };
+export const loadingProposals = { get current() { return getLoadingProposals(); } };
+export const loadingInstance = { get current() { return getLoadingInstance(); } };
+export const error = { get current() { return getError(); } };
+export const draftProposals = { get current() { return getDraftProposals(); } };
+export const reviewingProposals = { get current() { return getReviewingProposals(); } };
+export const deployedProposals = { get current() { return getDeployedProposals(); } };
+// Event handlers
+const eventHandlers = new Map();
+/**
+ * Connect to the plugin host's Server-Sent-Events stream.
+ *
+ * @param endpoint - SSE endpoint on your plugin host. Defaults to
+ *                    `/api/plugins/stream` (same-origin).
+ */
+export function connect(endpoint = '/api/plugins/stream') {
+    if (demoOffline) {
+        state.connected = true;
+        return;
+    }
+    if (state.eventSource) {
+        state.eventSource.close();
+    }
+    const eventSource = new EventSource(endpoint);
+    eventSource.onopen = () => {
+        state.connected = true;
+        state.error = null;
+    };
+    eventSource.onerror = () => {
+        state.connected = false;
+        state.error = 'Connection to plugin server lost';
+    };
+    eventSource.onmessage = (event) => {
+        try {
+            const pluginEvent = JSON.parse(event.data);
+            handleEvent(pluginEvent);
+        }
+        catch {
+            console.error('Failed to parse plugin event');
+        }
+    };
+    state.eventSource = eventSource;
+}
+/**
+ * Disconnect from the event stream
+ */
+export function disconnect() {
+    if (state.eventSource) {
+        state.eventSource.close();
+        state.eventSource = null;
+    }
+    state.connected = false;
+}
+/**
+ * Handle incoming plugin events
+ */
+function handleEvent(event) {
+    // Update proposal state based on event
+    switch (event.type) {
+        case 'created':
+            // Proposal created - refresh list
+            fetchProposals();
+            break;
+        case 'submitted':
+        case 'review_started':
+        case 'approved':
+        case 'rejected':
+        case 'testing_started':
+        case 'deploying':
+        case 'deployed':
+        case 'rolled_back':
+            // Status change - update the proposal
+            updateProposalStatus(event.proposalId, event.type);
+            break;
+        case 'vote_cast':
+            // Vote received - could update UI to show vote progress
+            break;
+        case 'test_completed':
+            // Test completed - could update test results display
+            break;
+        case 'rollout_step':
+            // Rollout progress - could show progress bar
+            break;
+    }
+    // Notify subscribed handlers
+    const handlers = eventHandlers.get(event.type);
+    if (handlers) {
+        handlers.forEach((handler) => handler(event));
+    }
+    // Notify wildcard handlers
+    const wildcardHandlers = eventHandlers.get('*');
+    if (wildcardHandlers) {
+        wildcardHandlers.forEach((handler) => handler(event));
+    }
+}
+/**
+ * Subscribe to plugin events
+ */
+export function onEvent(type, handler) {
+    if (!eventHandlers.has(type)) {
+        eventHandlers.set(type, new Set());
+    }
+    eventHandlers.get(type).add(handler);
+    return () => {
+        eventHandlers.get(type)?.delete(handler);
+    };
+}
+/**
+ * Fetch all proposals from the server
+ */
+export async function fetchProposals() {
+    if (demoOffline) {
+        state.loadingProposals = false;
+        return;
+    }
+    state.loadingProposals = true;
+    state.error = null;
+    try {
+        const response = await fetch('/api/plugins/proposals');
+        if (!response.ok)
+            throw new Error(`Failed to fetch proposals: ${response.status}`);
+        const data = await response.json();
+        state.proposals = data.proposals ?? [];
+    }
+    catch (err) {
+        state.error = err instanceof Error ? err.message : 'Failed to fetch proposals';
+    }
+    finally {
+        state.loadingProposals = false;
+    }
+}
+/**
+ * Create a new plugin proposal
+ */
+export async function createProposal(proposal) {
+    state.error = null;
+    try {
+        const response = await fetch('/api/plugins/proposals', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(proposal)
+        });
+        if (!response.ok)
+            throw new Error(`Failed to create proposal: ${response.status}`);
+        const data = await response.json();
+        state.proposals = [...state.proposals, data];
+        return data.id;
+    }
+    catch (err) {
+        state.error = err instanceof Error ? err.message : 'Failed to create proposal';
+        return null;
+    }
+}
+/**
+ * Submit a proposal for review
+ */
+export async function submitProposal(proposalId) {
+    state.error = null;
+    try {
+        const response = await fetch(`/api/plugins/proposals/${proposalId}/submit`, {
+            method: 'POST'
+        });
+        if (!response.ok)
+            throw new Error(`Failed to submit proposal: ${response.status}`);
+        updateProposalStatus(proposalId, 'submitted');
+        return true;
+    }
+    catch (err) {
+        state.error = err instanceof Error ? err.message : 'Failed to submit proposal';
+        return false;
+    }
+}
+/**
+ * Update local proposal status
+ */
+function updateProposalStatus(proposalId, status) {
+    // Map event types to status if needed
+    const statusMap = {
+        review_started: 'reviewing',
+        testing_started: 'testing'
+    };
+    const newStatus = (statusMap[status] ?? status);
+    state.proposals = state.proposals.map((p) => p.id === proposalId ? { ...p, status: newStatus, updatedAt: new Date() } : p);
+}
+/**
+ * Load and activate a deployed plugin
+ */
+export async function loadPlugin(proposalId) {
+    const proposal = state.proposals.find((p) => p.id === proposalId);
+    if (!proposal || proposal.status !== 'deployed') {
+        state.error = 'Plugin must be deployed before loading';
+        return false;
+    }
+    state.loadingInstance = proposalId;
+    state.error = null;
+    try {
+        // For SSR-rendered components, fetch the component from the server
+        if (proposal.implementation.type === 'component' && proposal.implementation.componentPath) {
+            const response = await fetch(`/api/plugins/plugins/${proposalId}/component?path=${encodeURIComponent(proposal.implementation.componentPath)}`);
+            if (!response.ok)
+                throw new Error('Failed to load plugin component');
+            // The server renders the component and returns it
+            // (server-side rendering performed by the plugin host)
+        }
+        // Create plugin instance
+        const instance = {
+            id: proposalId,
+            manifest: proposalToManifest(proposal),
+            status: 'active'
+        };
+        state.instances.set(proposalId, instance);
+        // Register contributions
+        registerContributions(proposalId, proposal);
+        return true;
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : 'Failed to load plugin';
+        state.error = errorMessage;
+        state.instances.set(proposalId, {
+            id: proposalId,
+            manifest: proposalToManifest(proposal),
+            status: 'error',
+            error: errorMessage
+        });
+        return false;
+    }
+    finally {
+        state.loadingInstance = null;
+    }
+}
+/**
+ * Unload a plugin
+ */
+export function unloadPlugin(proposalId) {
+    const instance = state.instances.get(proposalId);
+    if (!instance)
+        return;
+    // Call dispose if available
+    instance.dispose?.();
+    // Unregister contributions
+    unregisterContributions(proposalId);
+    state.instances.delete(proposalId);
+}
+/**
+ * Convert proposal to manifest format
+ */
+function proposalToManifest(proposal) {
+    return {
+        name: proposal.name,
+        version: `${proposal.version}.0.0`,
+        description: proposal.description,
+        author: proposal.author,
+        category: proposal.category,
+        tags: proposal.tags,
+        permissions: proposal.implementation.permissions
+    };
+}
+/**
+ * Register plugin contributions (commands, panels, etc.)
+ */
+function registerContributions(pluginId, proposal) {
+    // This would parse the plugin and register its contributions
+    // For now, we'll just note that this is where dynamic registration happens
+}
+/**
+ * Unregister plugin contributions
+ */
+function unregisterContributions(pluginId) {
+    // Remove commands registered by this plugin
+    for (const [id] of state.commands) {
+        if (id.startsWith(`${pluginId}:`)) {
+            state.commands.delete(id);
+        }
+    }
+    // Remove panels registered by this plugin
+    for (const [id] of state.panels) {
+        if (id.startsWith(`${pluginId}:`)) {
+            state.panels.delete(id);
+        }
+    }
+}
+/**
+ * Register a command from a plugin
+ */
+export function registerCommand(pluginId, command) {
+    const fullId = `${pluginId}:${command.id}`;
+    state.commands.set(fullId, { ...command, id: fullId });
+}
+/**
+ * Register a panel from a plugin
+ */
+export function registerPanel(pluginId, panel) {
+    const fullId = `${pluginId}:${panel.id}`;
+    state.panels.set(fullId, { ...panel, id: fullId });
+}
+/**
+ * Execute a command
+ */
+export async function executeCommand(commandId) {
+    const command = state.commands.get(commandId);
+    if (!command) {
+        state.error = `Command not found: ${commandId}`;
+        return;
+    }
+    try {
+        await command.handler();
+    }
+    catch (err) {
+        state.error = err instanceof Error ? err.message : 'Command execution failed';
+    }
+}
+/**
+ * Get a proposal by ID
+ */
+export function getProposal(proposalId) {
+    return state.proposals.find((p) => p.id === proposalId);
+}
+/**
+ * Get an instance by ID
+ */
+export function getInstance(pluginId) {
+    return state.instances.get(pluginId);
+}
+/**
+ * Clear error state
+ */
+export function clearError() {
+    state.error = null;
+}

package/dist/stores/vfs.svelte.d.ts

@@ -0,0 +1,123 @@
+/**
+ * VFS store using Svelte 5 runes
+ * Manages workspace state, file tree, locks, and SSE events
+ *
+ * Note: Svelte 5 modules cannot directly export $derived values.
+ * We use getter functions to expose reactive derived state.
+ */
+import type { VFSWorkspace, VFSFileInfo, VFSFileLock, VFSEvent, VFSTransaction, VFSLockStatus, VFSErrorCode } from '../types';
+import { type VFSError } from '../services/error-handling';
+import { type OptimisticResult } from '../services/optimistic';
+export declare function getWorkspace(): VFSWorkspace | null;
+export declare function getWorkspaceLoading(): boolean;
+export declare function getFiles(): VFSFileInfo[];
+export declare function getFileTree(): VFSFileInfo[];
+export declare function getFile(path: string): VFSFileInfo | undefined;
+export declare function getLocks(): VFSFileLock[];
+export declare function getLock(path: string): VFSFileLock | undefined;
+export declare function getLockStatus(path: string): VFSLockStatus;
+export declare function isLocked(path: string): boolean;
+export declare function isLockedByMe(path: string): boolean;
+export declare function isLockedByOther(path: string): boolean;
+export declare function getMyLocks(): VFSFileLock[];
+export declare function getOtherLocks(): VFSFileLock[];
+export declare function getDirtyFiles(): string[];
+export declare function isDirty(path: string): boolean;
+export declare function getActiveTransactions(): VFSTransaction[];
+export declare function getTransactionHistory(): VFSTransaction[];
+export declare function getConnected(): boolean;
+export declare function getSyncing(): boolean;
+export declare function getError(): string | null;
+export declare function getErrorCode(): VFSErrorCode | null;
+export declare function getVersion(): number;
+export declare function getReconnectAttempts(): number;
+export declare function getStructuredError(): VFSError | null;
+export declare function getConflictQueue(): Array<{
+    path: string;
+    localContent: string;
+    serverVersion: number;
+}>;
+export declare function hasConflicts(): boolean;
+export declare function getPendingRetryCount(operationId: string): number;
+export declare function getLockedFiles(): VFSFileInfo[];
+export declare function getMyLockedFiles(): VFSFileInfo[];
+export declare function getDirectories(): VFSFileInfo[];
+export declare function getFilesInDirectory(dirPath: string): VFSFileInfo[];
+export declare const workspace: {
+    readonly current: VFSWorkspace | null;
+};
+export declare const workspaceLoading: {
+    readonly current: boolean;
+};
+export declare const files: {
+    readonly current: VFSFileInfo[];
+};
+export declare const fileTree: {
+    readonly current: VFSFileInfo[];
+};
+export declare const locks: {
+    readonly current: VFSFileLock[];
+};
+export declare const dirtyFiles: {
+    readonly current: string[];
+};
+export declare const activeTransactions: {
+    readonly current: VFSTransaction[];
+};
+export declare const connected: {
+    readonly current: boolean;
+};
+export declare const syncing: {
+    readonly current: boolean;
+};
+export declare const error: {
+    readonly current: string | null;
+};
+export declare function initialize(userId: string, workspaceId?: string): void;
+export declare function loadWorkspace(workspaceId: string): Promise<void>;
+export declare function updateFileInfo(fileInfo: VFSFileInfo): void;
+export declare function removeFileInfo(path: string): void;
+export declare function markDirty(path: string): void;
+export declare function markClean(path: string): void;
+export declare function setFiles(files: VFSFileInfo[]): void;
+/**
+ * Write file content with optimistic update and automatic rollback on failure
+ */
+export declare function writeFileOptimistic(path: string, content: string, options?: {
+    createIfNotExists?: boolean;
+}): Promise<OptimisticResult<VFSFileInfo>>;
+/**
+ * Delete file with optimistic update
+ */
+export declare function deleteFileOptimistic(path: string): Promise<OptimisticResult<void>>;
+/**
+ * Resolve a file conflict
+ */
+export declare function resolveConflict(path: string, resolution: 'use_local' | 'use_server' | 'merge', mergedContent?: string): void;
+/**
+ * Dismiss all conflicts (use server versions)
+ */
+export declare function dismissAllConflicts(): void;
+/**
+ * Retry a failed operation
+ */
+export declare function retryOperation(operationId: string): Promise<boolean>;
+/**
+ * Clear structured error
+ */
+export declare function clearStructuredError(): void;
+export declare function setLock(lock: VFSFileLock): void;
+export declare function removeLock(path: string): void;
+export declare function setLockStatus(path: string, status: VFSLockStatus): void;
+export declare function setLocks(locks: VFSFileLock[]): void;
+export declare function acquireLock(path: string, purpose?: VFSFileLock['purpose']): Promise<VFSFileLock | null>;
+export declare function releaseLock(path: string): Promise<void>;
+export declare function releaseAllMyLocks(): Promise<void>;
+export declare function startTransaction(transaction: VFSTransaction): void;
+export declare function completeTransaction(transactionId: string, status: 'committed' | 'rolledback'): void;
+export declare function connect(workspaceId: string): void;
+export declare function disconnect(): void;
+export declare function onEvent(type: VFSEvent['type'] | '*', handler: (event: VFSEvent) => void): () => void;
+export declare function clearError(): void;
+export declare function reset(): void;
+export declare function setSyncing(syncing: boolean): void;