@creact-labs/creact 0.1.8 → 0.2.0

package/dist/runtime/state-machine.d.ts

@@ -0,0 +1,95 @@
+/**
+ * StateMachine - Resource lifecycle tracking and deployment orchestration
+ *
+ * Tracks:
+ * - Individual resource states (pending → applying → deployed)
+ * - Deployment lifecycle (start → checkpoint → complete/fail)
+ * - Resume capability from crash
+ */
+import type { Backend, DeploymentState, ResourceState, SerializedNode } from '../provider/backend';
+export interface StateMachineOptions {
+    user?: string;
+    enableAuditLog?: boolean;
+}
+/**
+ * StateMachine manages deployment lifecycle and resource states
+ */
+export declare class StateMachine {
+    private backend;
+    private resourceStates;
+    private options;
+    constructor(backend: Backend, options?: StateMachineOptions);
+    /**
+     * Get the current state of a resource
+     */
+    getResourceState(nodeId: string): ResourceState;
+    /**
+     * Set the state of a resource
+     */
+    setResourceState(nodeId: string, state: ResourceState): void;
+    /**
+     * Restore resource states from persisted nodes
+     */
+    restoreResourceStates(nodes: SerializedNode[]): void;
+    /**
+     * Clear all resource states
+     */
+    clearResourceStates(): void;
+    /**
+     * Start a new deployment
+     */
+    startDeployment(stackName: string, nodes: SerializedNode[], changeStats?: {
+        creates: number;
+        updates: number;
+        deletes: number;
+    }): Promise<void>;
+    /**
+     * Update a node's outputs in persisted state (for crash recovery)
+     * This is the real checkpoint - nodes with outputs are considered deployed
+     */
+    updateNodeOutputs(stackName: string, nodeId: string, outputs: Record<string, any>): Promise<void>;
+    /**
+     * Mark a node as currently being applied (for crash recovery)
+     */
+    markApplying(stackName: string, nodeId: string): Promise<void>;
+    /**
+     * Clear the applying marker after successful apply
+     */
+    clearApplying(stackName: string): Promise<void>;
+    /**
+     * Record a resource being applied
+     */
+    recordResourceApplied(stackName: string, nodeId: string, outputs: Record<string, any>): Promise<void>;
+    /**
+     * Record a resource being destroyed
+     */
+    recordResourceDestroyed(stackName: string, nodeId: string): Promise<void>;
+    /**
+     * Complete a successful deployment
+     */
+    completeDeployment(stackName: string, nodes: SerializedNode[]): Promise<void>;
+    /**
+     * Record a failed deployment
+     */
+    failDeployment(stackName: string, error: Error): Promise<void>;
+    /**
+     * Check if a deployment can be resumed
+     */
+    canResume(stackName: string): Promise<boolean>;
+    /**
+     * Get the node that was being applied when crash occurred
+     */
+    getInterruptedNodeId(stackName: string): Promise<string | null>;
+    /**
+     * Get previous deployment state
+     */
+    getPreviousState(stackName: string): Promise<DeploymentState | null>;
+    /**
+     * Acquire deployment lock (if backend supports it)
+     */
+    acquireLock(stackName: string, holder: string, ttlSeconds?: number): Promise<boolean>;
+    /**
+     * Release deployment lock (if backend supports it)
+     */
+    releaseLock(stackName: string): Promise<void>;
+}

package/dist/runtime/state-machine.js

@@ -0,0 +1,209 @@
+/**
+ * StateMachine - Resource lifecycle tracking and deployment orchestration
+ *
+ * Tracks:
+ * - Individual resource states (pending → applying → deployed)
+ * - Deployment lifecycle (start → checkpoint → complete/fail)
+ * - Resume capability from crash
+ */
+/**
+ * StateMachine manages deployment lifecycle and resource states
+ */
+export class StateMachine {
+    backend;
+    resourceStates = new Map();
+    options;
+    constructor(backend, options = {}) {
+        this.backend = backend;
+        this.options = options;
+    }
+    /**
+     * Get the current state of a resource
+     */
+    getResourceState(nodeId) {
+        return this.resourceStates.get(nodeId) ?? 'pending';
+    }
+    /**
+     * Set the state of a resource
+     */
+    setResourceState(nodeId, state) {
+        this.resourceStates.set(nodeId, state);
+    }
+    /**
+     * Restore resource states from persisted nodes
+     */
+    restoreResourceStates(nodes) {
+        this.resourceStates.clear();
+        for (const node of nodes) {
+            // If node has outputs, it was previously deployed
+            const state = node.state ?? (node.outputs ? 'deployed' : 'pending');
+            this.resourceStates.set(node.id, state);
+        }
+    }
+    /**
+     * Clear all resource states
+     */
+    clearResourceStates() {
+        this.resourceStates.clear();
+    }
+    /**
+     * Start a new deployment
+     */
+    async startDeployment(stackName, nodes, changeStats) {
+        const state = {
+            nodes,
+            status: 'applying',
+            stackName,
+            lastDeployedAt: Date.now(),
+            user: this.options.user,
+        };
+        await this.backend.saveState(stackName, state);
+        if (this.options.enableAuditLog && this.backend.appendAuditLog) {
+            await this.backend.appendAuditLog(stackName, {
+                timestamp: Date.now(),
+                action: 'deploy_start',
+                user: this.options.user,
+                details: changeStats,
+            });
+        }
+    }
+    /**
+     * Update a node's outputs in persisted state (for crash recovery)
+     * This is the real checkpoint - nodes with outputs are considered deployed
+     */
+    async updateNodeOutputs(stackName, nodeId, outputs) {
+        const state = await this.backend.getState(stackName);
+        if (state) {
+            const node = state.nodes.find((n) => n.id === nodeId);
+            if (node) {
+                node.outputs = outputs;
+                await this.backend.saveState(stackName, state);
+            }
+        }
+    }
+    /**
+     * Mark a node as currently being applied (for crash recovery)
+     */
+    async markApplying(stackName, nodeId) {
+        const state = await this.backend.getState(stackName);
+        if (state) {
+            state.applyingNodeId = nodeId;
+            await this.backend.saveState(stackName, state);
+        }
+    }
+    /**
+     * Clear the applying marker after successful apply
+     */
+    async clearApplying(stackName) {
+        const state = await this.backend.getState(stackName);
+        if (state) {
+            state.applyingNodeId = undefined;
+            await this.backend.saveState(stackName, state);
+        }
+    }
+    /**
+     * Record a resource being applied
+     */
+    async recordResourceApplied(stackName, nodeId, outputs) {
+        this.setResourceState(nodeId, 'deployed');
+        if (this.options.enableAuditLog && this.backend.appendAuditLog) {
+            await this.backend.appendAuditLog(stackName, {
+                timestamp: Date.now(),
+                action: 'resource_applied',
+                nodeId,
+                user: this.options.user,
+                details: { outputKeys: Object.keys(outputs) },
+            });
+        }
+    }
+    /**
+     * Record a resource being destroyed
+     */
+    async recordResourceDestroyed(stackName, nodeId) {
+        this.resourceStates.delete(nodeId);
+        if (this.options.enableAuditLog && this.backend.appendAuditLog) {
+            await this.backend.appendAuditLog(stackName, {
+                timestamp: Date.now(),
+                action: 'resource_destroyed',
+                nodeId,
+                user: this.options.user,
+            });
+        }
+    }
+    /**
+     * Complete a successful deployment
+     */
+    async completeDeployment(stackName, nodes) {
+        const state = {
+            nodes,
+            status: 'deployed',
+            stackName,
+            lastDeployedAt: Date.now(),
+            user: this.options.user,
+        };
+        await this.backend.saveState(stackName, state);
+        if (this.options.enableAuditLog && this.backend.appendAuditLog) {
+            await this.backend.appendAuditLog(stackName, {
+                timestamp: Date.now(),
+                action: 'deploy_complete',
+                user: this.options.user,
+                details: { nodeCount: nodes.length },
+            });
+        }
+    }
+    /**
+     * Record a failed deployment
+     */
+    async failDeployment(stackName, error) {
+        const state = await this.backend.getState(stackName);
+        if (state) {
+            state.status = 'failed';
+            await this.backend.saveState(stackName, state);
+        }
+        if (this.options.enableAuditLog && this.backend.appendAuditLog) {
+            await this.backend.appendAuditLog(stackName, {
+                timestamp: Date.now(),
+                action: 'deploy_failed',
+                user: this.options.user,
+                details: { error: error.message },
+            });
+        }
+    }
+    /**
+     * Check if a deployment can be resumed
+     */
+    async canResume(stackName) {
+        const state = await this.backend.getState(stackName);
+        return state?.status === 'applying';
+    }
+    /**
+     * Get the node that was being applied when crash occurred
+     */
+    async getInterruptedNodeId(stackName) {
+        const state = await this.backend.getState(stackName);
+        return state?.applyingNodeId ?? null;
+    }
+    /**
+     * Get previous deployment state
+     */
+    async getPreviousState(stackName) {
+        return this.backend.getState(stackName);
+    }
+    /**
+     * Acquire deployment lock (if backend supports it)
+     */
+    async acquireLock(stackName, holder, ttlSeconds = 300) {
+        if (this.backend.acquireLock) {
+            return this.backend.acquireLock(stackName, holder, ttlSeconds);
+        }
+        return true; // No locking support, allow
+    }
+    /**
+     * Release deployment lock (if backend supports it)
+     */
+    async releaseLock(stackName) {
+        if (this.backend.releaseLock) {
+            await this.backend.releaseLock(stackName);
+        }
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared types
+ */
+export type { JSXElement } from './jsx/jsx-runtime';
+export type { Context } from './primitives/context';
+export type { InstanceNode, OutputAccessors } from './primitives/instance';
+export type { SetStoreFunction } from './primitives/store';
+export type { AuditLogEntry, Backend, DeploymentState, DeploymentStatus, ResourceState, SerializedNode, } from './provider/backend';
+export type { Provider } from './provider/interface';
+export type { Accessor, Computation, Setter, Signal } from './reactive/signal';
+export type { Fiber } from './runtime/fiber';
+export type { ChangeSet, DependencyGraph } from './runtime/reconcile';
+export type { StateMachineOptions } from './runtime/state-machine';

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Shared types
+ */
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@creact-labs/creact",
-  "version": "0.1.8",
-  "description": "CReact - React for Infrastructure. Render JSX to CloudDOM.",
+  "version": "0.2.0",
+  "description": "Declarative universal reactive runtime",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "typesVersions": {
@@ -26,26 +26,20 @@
     "prepublishOnly": "npm run build"
   },
   "keywords": [
-    "infrastructure",
-    "infrastructure-as-code",
-    "iac",
+    "reactive",
+    "declarative",
+    "runtime",
     "jsx",
-    "react",
+    "ai-agents",
+    "automation",
+    "orchestration",
+    "workflow",
+    "infrastructure-as-code",
     "cloud",
-    "terraform",
-    "aws",
-    "kubernetes",
     "devops",
     "deployment",
-    "orchestration",
-    "clouddom",
     "reconciler",
-    "reactive",
-    "pulumi",
-    "cdk",
-    "helm",
-    "multi-cloud",
-    "declarative"
+    "multi-cloud"
   ],
   "author": "Daniel Coutinho Ribeiro <dcoutinho.96@gmail.com>",
   "license": "Apache-2.0",
@@ -67,25 +61,18 @@
   ],
   "devDependencies": {
     "@eslint/js": "^9.37.0",
-    "@types/better-sqlite3": "^7.6.13",
-    "@types/cli-progress": "^3.11.6",
     "@types/node": "^20.0.0",
     "@typescript-eslint/eslint-plugin": "^8.45.0",
     "@typescript-eslint/parser": "^8.45.0",
-    "better-sqlite3": "^12.4.1",
     "eslint": "^9.37.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.4",
     "prettier": "^3.6.2",
-    "ts-node": "^10.9.2",
     "typescript": "^5.0.0",
     "typescript-eslint": "^8.45.0",
     "vitest": "^3.2.4"
   },
   "dependencies": {
-    "chalk": "^4.1.2",
-    "cli-progress": "^3.12.0",
-    "ora": "^5.4.1",
     "tsx": "^4.20.6"
   }
 }

package/dist/cli/commands/BuildCommand.d.ts

@@ -1,40 +0,0 @@
-/**
-
- * Licensed under the Apache License, Version 2.0 (the "License");
-
- * you may not use this file except in compliance with the License.
-
- * You may obtain a copy of the License at
-
- *
-
- *     http://www.apache.org/licenses/LICENSE-2.0
-
- *
-
- * Unless required by applicable law or agreed to in writing, software
-
- * distributed under the License is distributed on an "AS IS" BASIS,
-
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-
- * See the License for the specific language governing permissions and
-
- * limitations under the License.
-
- *
-
- * Copyright 2025 Daniel Coutinho Ribeiro
-
- */
-/**
- * Build Command - builds CloudDOM from entry file
- */
-import { BaseCommand, CommandResult } from '../core/BaseCommand';
-export declare class BuildCommand extends BaseCommand {
-    getName(): string;
-    getDescription(): string;
-    execute(): Promise<CommandResult>;
-    private printVerboseOutput;
-    private countResources;
-}

package/dist/cli/commands/BuildCommand.js

@@ -1,151 +0,0 @@
-"use strict";
-/**
-
- * Licensed under the Apache License, Version 2.0 (the "License");
-
- * you may not use this file except in compliance with the License.
-
- * You may obtain a copy of the License at
-
- *
-
- *     http://www.apache.org/licenses/LICENSE-2.0
-
- *
-
- * Unless required by applicable law or agreed to in writing, software
-
- * distributed under the License is distributed on an "AS IS" BASIS,
-
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-
- * See the License for the specific language governing permissions and
-
- * limitations under the License.
-
- *
-
- * Copyright 2025 Daniel Coutinho Ribeiro
-
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildCommand = void 0;
-/**
- * Build Command - builds CloudDOM from entry file
- */
-const BaseCommand_1 = require("../core/BaseCommand");
-const CLIContext_1 = require("../core/CLIContext");
-const Output_1 = require("../../utils/Output");
-const Logger_1 = require("../../utils/Logger");
-const logger = Logger_1.LoggerFactory.getLogger('cli');
-class BuildCommand extends BaseCommand_1.BaseCommand {
-    getName() {
-        return 'build';
-    }
-    getDescription() {
-        return 'Build CloudDOM from entry file';
-    }
-    async execute() {
-        const output = (0, Output_1.createOutputManager)({
-            json: this.json,
-            quiet: !!this.context.flags.quiet,
-            verbose: this.verbose,
-        });
-        try {
-            // Find entry file
-            logger.debug('BuildCommand: Starting execution');
-            let entryPath;
-            try {
-                entryPath = CLIContext_1.CLIContextManager.findEntryFile(this.context.flags.entry);
-                logger.debug(`BuildCommand: Entry file resolved to ${entryPath}`);
-            }
-            catch (error) {
-                output.showError('Entry file resolution failed', {
-                    cause: error.message,
-                    stackTrace: this.verbose ? error.stack : undefined,
-                });
-                return { exitCode: 1 };
-            }
-            // Load entry file and create CLI instance
-            output.showInfo('Loading entry file and configuring providers...');
-            let result;
-            try {
-                result = await CLIContext_1.CLIContextManager.createCLIInstance(entryPath, this.verbose);
-                logger.debug(`BuildCommand: CloudDOM built with ${result.cloudDOM.length} resources`);
-            }
-            catch (error) {
-                output.showError('Failed to load entry file and configure providers', {
-                    cause: error.message,
-                    stackTrace: this.verbose ? error.stack : undefined,
-                });
-                return { exitCode: 1 };
-            }
-            output.showSuccess('Entry file loaded and providers configured');
-            // Success output
-            const message = `Build complete: ${result.cloudDOM.length} resources`;
-            if (this.verbose && !this.json) {
-                this.printVerboseOutput(result, output);
-            }
-            output.showSuccess(message);
-            if (this.json) {
-                console.log(JSON.stringify({
-                    status: 'success',
-                    resourceCount: result.cloudDOM.length,
-                    entryFile: entryPath,
-                    stackName: result.stackName,
-                    resources: result.cloudDOM.map((node) => ({
-                        id: node.id,
-                        type: node.construct?.name || 'Unknown',
-                        path: node.path,
-                    })),
-                }, null, 2));
-            }
-            return { exitCode: 0 };
-        }
-        catch (error) {
-            output.showError('Build failed', {
-                cause: error.message,
-                stackTrace: this.verbose ? error.stack : undefined,
-            });
-            return { exitCode: 1 };
-        }
-    }
-    printVerboseOutput(result, output) {
-        console.log('\nCloudDOM Summary:');
-        const resourceCounts = this.countResources(result.cloudDOM);
-        if (Object.keys(resourceCounts).length === 0) {
-            console.log('  No resources found');
-        }
-        else {
-            for (const [type, count] of Object.entries(resourceCounts)) {
-                console.log(`  ${type}: ${count}`);
-            }
-        }
-        // Show first few resource IDs for debugging
-        if (result.cloudDOM.length > 0) {
-            console.log('\nResource IDs:');
-            const sampleIds = result.cloudDOM.slice(0, 5).map((node) => node.id);
-            sampleIds.forEach((id) => {
-                console.log(`  • ${id}`);
-            });
-            if (result.cloudDOM.length > 5) {
-                console.log(`  ... and ${result.cloudDOM.length - 5} more`);
-            }
-        }
-    }
-    countResources(cloudDOM) {
-        const counts = {};
-        const walk = (nodes) => {
-            for (const node of nodes) {
-                const type = node.construct?.name || 'Unknown';
-                counts[type] = (counts[type] || 0) + 1;
-                if (node.children && node.children.length > 0) {
-                    walk(node.children);
-                }
-            }
-        };
-        walk(cloudDOM);
-        return counts;
-    }
-}
-exports.BuildCommand = BuildCommand;

package/dist/cli/commands/DeployCommand.d.ts

@@ -1,38 +0,0 @@
-/**
-
- * Licensed under the Apache License, Version 2.0 (the "License");
-
- * you may not use this file except in compliance with the License.
-
- * You may obtain a copy of the License at
-
- *
-
- *     http://www.apache.org/licenses/LICENSE-2.0
-
- *
-
- * Unless required by applicable law or agreed to in writing, software
-
- * distributed under the License is distributed on an "AS IS" BASIS,
-
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-
- * See the License for the specific language governing permissions and
-
- * limitations under the License.
-
- *
-
- * Copyright 2025 Daniel Coutinho Ribeiro
-
- */
-/**
- * Deploy Command - deploys CloudDOM to cloud provider
- */
-import { BaseCommand, CommandResult } from '../core/BaseCommand';
-export declare class DeployCommand extends BaseCommand {
-    getName(): string;
-    getDescription(): string;
-    execute(): Promise<CommandResult>;
-}