@setbase/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1023 @@
+// src/types/resource.ts
+var ResourceType = /* @__PURE__ */ ((ResourceType2) => {
+  ResourceType2["DATABASE"] = "database";
+  ResourceType2["CACHE"] = "cache";
+  ResourceType2["STORAGE"] = "storage";
+  ResourceType2["EMAIL"] = "email";
+  ResourceType2["COMPUTE"] = "compute";
+  return ResourceType2;
+})(ResourceType || {});
+var ResourceStatus = /* @__PURE__ */ ((ResourceStatus2) => {
+  ResourceStatus2["PENDING"] = "pending";
+  ResourceStatus2["PROVISIONING"] = "provisioning";
+  ResourceStatus2["READY"] = "ready";
+  ResourceStatus2["UPDATING"] = "updating";
+  ResourceStatus2["DESTROYING"] = "destroying";
+  ResourceStatus2["ERROR"] = "error";
+  return ResourceStatus2;
+})(ResourceStatus || {});
+
+// src/types/deployment.ts
+var DeploymentStatus = /* @__PURE__ */ ((DeploymentStatus2) => {
+  DeploymentStatus2["PENDING"] = "pending";
+  DeploymentStatus2["BUILDING"] = "building";
+  DeploymentStatus2["DEPLOYING"] = "deploying";
+  DeploymentStatus2["READY"] = "ready";
+  DeploymentStatus2["FAILED"] = "failed";
+  return DeploymentStatus2;
+})(DeploymentStatus || {});
+
+// src/providers/factory.ts
+var ProviderFactory = class {
+  /**
+   * Create a provider instance
+   */
+  static async create(_type, providerId, credentials) {
+    try {
+      const module = await import(`@setbase/providers/${providerId}`);
+      const ProviderClass = module.default;
+      const provider = new ProviderClass();
+      await provider.initialize(credentials);
+      return provider;
+    } catch (error) {
+      throw new Error(`Failed to create provider: ${providerId}`, { cause: error });
+    }
+  }
+};
+
+// src/utils/id.ts
+import { nanoid } from "nanoid";
+function generateId() {
+  return nanoid();
+}
+function generateProjectId() {
+  return `proj_${nanoid(16)}`;
+}
+function generateResourceId() {
+  return `res_${nanoid(16)}`;
+}
+
+// src/utils/logger.ts
+var ConsoleLogger = class {
+  debug(message, ...args) {
+    console.debug(`[DEBUG] ${message}`, ...args);
+  }
+  info(message, ...args) {
+    console.info(`[INFO] ${message}`, ...args);
+  }
+  warn(message, ...args) {
+    console.warn(`[WARN] ${message}`, ...args);
+  }
+  error(message, ...args) {
+    console.error(`[ERROR] ${message}`, ...args);
+  }
+};
+var logger = new ConsoleLogger();
+
+// src/orchestrator/resource-graph.ts
+var ResourceGraph = class {
+  nodes = /* @__PURE__ */ new Map();
+  addNode(id, dependencies = []) {
+    this.nodes.set(id, { id, dependencies });
+  }
+  /**
+   * Get resources in topological order (respecting dependencies)
+   */
+  getProvisioningOrder() {
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    const visit = (nodeId) => {
+      if (visited.has(nodeId)) return;
+      const node = this.nodes.get(nodeId);
+      if (!node) return;
+      visited.add(nodeId);
+      for (const dep of node.dependencies) {
+        visit(dep);
+      }
+      result.push(nodeId);
+    };
+    for (const nodeId of this.nodes.keys()) {
+      visit(nodeId);
+    }
+    return result;
+  }
+  /**
+   * Detect circular dependencies
+   */
+  hasCycle() {
+    const visited = /* @__PURE__ */ new Set();
+    const recursionStack = /* @__PURE__ */ new Set();
+    const hasCycleUtil = (nodeId) => {
+      visited.add(nodeId);
+      recursionStack.add(nodeId);
+      const node = this.nodes.get(nodeId);
+      if (node) {
+        for (const dep of node.dependencies) {
+          if (!visited.has(dep)) {
+            if (hasCycleUtil(dep)) return true;
+          } else if (recursionStack.has(dep)) {
+            return true;
+          }
+        }
+      }
+      recursionStack.delete(nodeId);
+      return false;
+    };
+    for (const nodeId of this.nodes.keys()) {
+      if (!visited.has(nodeId)) {
+        if (hasCycleUtil(nodeId)) return true;
+      }
+    }
+    return false;
+  }
+};
+
+// src/orchestrator/command-orchestrator.ts
+var DefaultCommandOrchestrator = class {
+  constructor(stateManager, credentialStore) {
+    this.stateManager = stateManager;
+    this.credentialStore = credentialStore;
+  }
+  stateManager;
+  credentialStore;
+  async initializeProject(manifest) {
+    logger.info("Initializing project", { name: manifest.project.name });
+    const existingState = await this.stateManager.load();
+    if (existingState) {
+      logger.warn("Project already initialized", { projectId: existingState.projectId });
+      return existingState;
+    }
+    const projectState = {
+      version: "1.0",
+      projectId: generateId(),
+      resources: {},
+      deployments: [],
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.stateManager.save(projectState);
+    logger.info("Project initialized", { projectId: projectState.projectId });
+    return projectState;
+  }
+  async provisionResources(manifest) {
+    logger.info("Starting resource provisioning");
+    const state = await this.stateManager.load();
+    if (!state) {
+      throw new Error("Project not initialized. Run init first.");
+    }
+    const graph = new ResourceGraph();
+    const resourceMap = [];
+    if (manifest.resources.database) {
+      resourceMap.push({ id: "database", type: "database" /* DATABASE */, def: manifest.resources.database });
+      graph.addNode("database", manifest.resources.database.dependsOn || []);
+    }
+    if (manifest.resources.cache) {
+      resourceMap.push({ id: "cache", type: "cache" /* CACHE */, def: manifest.resources.cache });
+      graph.addNode("cache", manifest.resources.cache.dependsOn || []);
+    }
+    if (manifest.resources.storage) {
+      resourceMap.push({ id: "storage", type: "storage" /* STORAGE */, def: manifest.resources.storage });
+      graph.addNode("storage", manifest.resources.storage.dependsOn || []);
+    }
+    if (manifest.resources.email) {
+      resourceMap.push({ id: "email", type: "email" /* EMAIL */, def: manifest.resources.email });
+      graph.addNode("email", manifest.resources.email.dependsOn || []);
+    }
+    if (graph.hasCycle()) {
+      throw new Error("Circular dependency detected in resource graph");
+    }
+    const provisioningOrder = graph.getProvisioningOrder();
+    logger.info("Provisioning order determined", { order: provisioningOrder });
+    for (const resourceId of provisioningOrder) {
+      const resource = resourceMap.find((r) => r.id === resourceId);
+      if (!resource) continue;
+      if (state.resources[resourceId]?.status === "ready" /* READY */) {
+        logger.info("Resource already provisioned, skipping", { resourceId });
+        continue;
+      }
+      logger.info("Provisioning resource", { resourceId, type: resource.type });
+      try {
+        const credentials = await this.credentialStore.load(resource.def.provider);
+        if (!credentials) {
+          throw new Error(`No credentials found for provider: ${resource.def.provider}`);
+        }
+        const provider = await ProviderFactory.create(
+          resource.type,
+          resource.def.provider,
+          credentials
+        );
+        const result = await provider.provision(resource.def.config);
+        const resourceState = {
+          type: resource.type,
+          provider: resource.def.provider,
+          resourceId: result.resourceId,
+          status: "ready" /* READY */,
+          metadata: {
+            outputs: result.outputs
+          },
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        state.resources[resourceId] = resourceState;
+        await this.stateManager.save(state);
+        logger.info("Resource provisioned successfully", {
+          resourceId,
+          providerResourceId: result.resourceId
+        });
+      } catch (error) {
+        logger.error("Failed to provision resource", { resourceId, error });
+        state.resources[resourceId] = {
+          type: resource.type,
+          provider: resource.def.provider,
+          resourceId,
+          status: "error" /* ERROR */,
+          metadata: { error: error.message },
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await this.stateManager.save(state);
+        throw error;
+      }
+    }
+    logger.info("All resources provisioned successfully");
+  }
+  async destroyResources() {
+    logger.info("Starting resource destruction");
+    const state = await this.stateManager.load();
+    if (!state) {
+      logger.warn("No project state found, nothing to destroy");
+      return;
+    }
+    const resourceIds = Object.keys(state.resources).reverse();
+    for (const resourceId of resourceIds) {
+      const resourceState = state.resources[resourceId];
+      if (!resourceState) continue;
+      logger.info("Destroying resource", { resourceId });
+      try {
+        const credentials = await this.credentialStore.load(resourceState.provider);
+        if (!credentials) {
+          logger.warn("No credentials found, skipping", {
+            resourceId,
+            provider: resourceState.provider
+          });
+          continue;
+        }
+        const provider = await ProviderFactory.create(
+          resourceState.type,
+          resourceState.provider,
+          credentials
+        );
+        await provider.destroy(resourceState.resourceId);
+        delete state.resources[resourceId];
+        await this.stateManager.save(state);
+        logger.info("Resource destroyed successfully", { resourceId });
+      } catch (error) {
+        logger.error("Failed to destroy resource", { resourceId, error });
+        throw error;
+      }
+    }
+    logger.info("All resources destroyed successfully");
+  }
+  async getState() {
+    const state = await this.stateManager.load();
+    if (!state) {
+      throw new Error("Project not initialized");
+    }
+    return state;
+  }
+};
+
+// src/orchestrator/deployment-orchestrator.ts
+var DefaultDeploymentOrchestrator = class {
+  constructor(stateManager, credentialStore) {
+    this.stateManager = stateManager;
+    this.credentialStore = credentialStore;
+  }
+  stateManager;
+  credentialStore;
+  async deploy(config, options) {
+    logger.info("Starting deployment", { environment: options.environment });
+    const state = await this.stateManager.load();
+    if (!state) {
+      throw new Error("Project not initialized. Run init first.");
+    }
+    const credentials = await this.credentialStore.load(config.provider);
+    if (!credentials) {
+      throw new Error(`No credentials found for provider: ${config.provider}`);
+    }
+    const provider = await ProviderFactory.create(
+      "compute" /* COMPUTE */,
+      config.provider,
+      credentials
+    );
+    const deploymentConfig = config.config;
+    try {
+      const result = await provider.provision(deploymentConfig);
+      const outputs = result.outputs;
+      const deploymentState = {
+        id: generateId(),
+        environment: options.environment,
+        provider: config.provider,
+        status: "ready",
+        url: outputs.url,
+        version: outputs.version,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      state.deployments.push(deploymentState);
+      await this.stateManager.save(state);
+      logger.info("Deployment successful", {
+        deploymentId: deploymentState.id,
+        url: outputs.url
+      });
+      return {
+        id: deploymentState.id,
+        url: outputs.url,
+        status: "ready",
+        version: outputs.version
+      };
+    } catch (error) {
+      logger.error("Deployment failed", { error });
+      throw error;
+    }
+  }
+  async getDeploymentStatus(deploymentId) {
+    const state = await this.stateManager.load();
+    if (!state) {
+      throw new Error("Project not initialized");
+    }
+    const deployment = state.deployments.find((d) => d.id === deploymentId);
+    if (!deployment) {
+      throw new Error(`Deployment not found: ${deploymentId}`);
+    }
+    return deployment.status;
+  }
+  async getLogs(deploymentId, options) {
+    logger.info("Fetching deployment logs", { deploymentId, options });
+    const state = await this.stateManager.load();
+    if (!state) {
+      throw new Error("Project not initialized");
+    }
+    const deployment = state.deployments.find((d) => d.id === deploymentId);
+    if (!deployment) {
+      throw new Error(`Deployment not found: ${deploymentId}`);
+    }
+    const logs = [
+      `[${(/* @__PURE__ */ new Date()).toISOString()}] Deployment ${deploymentId} started`,
+      `[${(/* @__PURE__ */ new Date()).toISOString()}] Building application...`,
+      `[${(/* @__PURE__ */ new Date()).toISOString()}] Build completed successfully`,
+      `[${(/* @__PURE__ */ new Date()).toISOString()}] Deploying to ${deployment.environment}...`,
+      `[${(/* @__PURE__ */ new Date()).toISOString()}] Deployment completed`,
+      `[${(/* @__PURE__ */ new Date()).toISOString()}] Application available at ${deployment.url}`
+    ];
+    if (options?.tail) {
+      return logs.slice(-options.tail);
+    }
+    return logs;
+  }
+};
+
+// src/providers/registry.ts
+var ProviderRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  /**
+   * Register a provider
+   */
+  register(provider) {
+    this.providers.set(provider.id, provider);
+  }
+  /**
+   * Get a provider by ID
+   */
+  get(providerId) {
+    return this.providers.get(providerId);
+  }
+  /**
+   * Get all providers of a specific type
+   */
+  getByType(type) {
+    return Array.from(this.providers.values()).filter((p) => p.type === type);
+  }
+  /**
+   * Check if a provider is registered
+   */
+  has(providerId) {
+    return this.providers.has(providerId);
+  }
+  /**
+   * Get all registered provider IDs
+   */
+  list() {
+    return Array.from(this.providers.keys());
+  }
+  /**
+   * Dynamically load providers
+   */
+  async loadProviders(providerIds) {
+    for (const id of providerIds) {
+      try {
+        const module = await import(`@setbase/providers/${id}`);
+        const ProviderClass = module.default;
+        const provider = new ProviderClass();
+        this.register(provider);
+      } catch (error) {
+        throw new Error(`Failed to load provider: ${id}`, { cause: error });
+      }
+    }
+  }
+};
+
+// src/providers/base/provider.ts
+var BaseProvider = class {
+};
+
+// src/state/state-manager.ts
+import { constants } from "fs";
+import { readFile, writeFile, unlink, access, mkdir } from "fs/promises";
+import { join, dirname } from "path";
+
+// src/errors/index.ts
+var SetbaseError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "SetbaseError";
+    Error.captureStackTrace(this, this.constructor);
+  }
+  code;
+  details;
+};
+var ValidationError = class extends SetbaseError {
+  constructor(message, details) {
+    super(message, "VALIDATION_ERROR", details);
+    this.name = "ValidationError";
+  }
+};
+var ProviderError = class extends SetbaseError {
+  constructor(message, provider, details) {
+    super(message, "PROVIDER_ERROR", details);
+    this.provider = provider;
+    this.name = "ProviderError";
+  }
+  provider;
+};
+var StateError = class extends SetbaseError {
+  constructor(message, details) {
+    super(message, "STATE_ERROR", details);
+    this.name = "StateError";
+  }
+};
+var ManifestError = class extends SetbaseError {
+  constructor(message, details) {
+    super(message, "MANIFEST_ERROR", details);
+    this.name = "ManifestError";
+  }
+};
+var DeploymentError = class extends SetbaseError {
+  constructor(message, details) {
+    super(message, "DEPLOYMENT_ERROR", details);
+    this.name = "DeploymentError";
+  }
+};
+
+// src/state/state-manager.ts
+var FileStateManager = class {
+  constructor(stateFilePath) {
+    this.stateFilePath = stateFilePath;
+  }
+  stateFilePath;
+  async load() {
+    try {
+      const exists = await this.exists();
+      if (!exists) {
+        logger.debug("State file does not exist");
+        return null;
+      }
+      const content = await readFile(this.stateFilePath, "utf-8");
+      const state = JSON.parse(content);
+      logger.debug("State loaded successfully", { projectId: state.projectId });
+      return state;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      throw new StateError("Failed to load state", { error, path: this.stateFilePath });
+    }
+  }
+  async save(state) {
+    try {
+      const dir = dirname(this.stateFilePath);
+      await mkdir(dir, { recursive: true });
+      const stateToSave = {
+        ...state,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const content = JSON.stringify(stateToSave, null, 2);
+      await writeFile(this.stateFilePath, content, "utf-8");
+      logger.debug("State saved successfully", { projectId: state.projectId });
+    } catch (error) {
+      throw new StateError("Failed to save state", { error, path: this.stateFilePath });
+    }
+  }
+  async delete() {
+    try {
+      const exists = await this.exists();
+      if (!exists) {
+        logger.debug("State file does not exist, nothing to delete");
+        return;
+      }
+      await unlink(this.stateFilePath);
+      logger.debug("State deleted successfully");
+    } catch (error) {
+      throw new StateError("Failed to delete state", { error, path: this.stateFilePath });
+    }
+  }
+  async exists() {
+    try {
+      await access(this.stateFilePath, constants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function createStateManager(projectDir = process.cwd()) {
+  const stateFilePath = join(projectDir, ".setbase", "state.json");
+  return new FileStateManager(stateFilePath);
+}
+
+// src/state/credential-store.ts
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
+import { constants as constants2 } from "fs";
+import { readFile as readFile2, writeFile as writeFile2, access as access2, mkdir as mkdir2 } from "fs/promises";
+import { join as join2, dirname as dirname2 } from "path";
+var EncryptedCredentialStore = class {
+  constructor(credentialsFilePath, passphrase) {
+    this.credentialsFilePath = credentialsFilePath;
+    this.passphrase = passphrase;
+  }
+  credentialsFilePath;
+  passphrase;
+  algorithm = "aes-256-gcm";
+  keyLength = 32;
+  ivLength = 16;
+  saltLength = 32;
+  tagLength = 16;
+  async save(providerId, credentials) {
+    try {
+      const credFile = await this.loadCredentialsFile() || this.createEmptyCredentialsFile();
+      credFile.providers[providerId] = credentials;
+      await this.saveCredentialsFile(credFile);
+      logger.debug("Credentials saved", { providerId });
+    } catch (error) {
+      throw new StateError(`Failed to save credentials for provider: ${providerId}`, { error });
+    }
+  }
+  async load(providerId) {
+    try {
+      const credFile = await this.loadCredentialsFile();
+      if (!credFile) {
+        return null;
+      }
+      const credentials = credFile.providers[providerId];
+      return credentials ? credentials : null;
+    } catch (error) {
+      throw new StateError(`Failed to load credentials for provider: ${providerId}`, { error });
+    }
+  }
+  async delete(providerId) {
+    try {
+      const credFile = await this.loadCredentialsFile();
+      if (!credFile) {
+        return;
+      }
+      delete credFile.providers[providerId];
+      await this.saveCredentialsFile(credFile);
+      logger.debug("Credentials deleted", { providerId });
+    } catch (error) {
+      throw new StateError(`Failed to delete credentials for provider: ${providerId}`, { error });
+    }
+  }
+  async has(providerId) {
+    const credentials = await this.load(providerId);
+    return credentials !== null;
+  }
+  async list() {
+    const credFile = await this.loadCredentialsFile();
+    return credFile ? Object.keys(credFile.providers) : [];
+  }
+  /**
+   * Load and decrypt credentials file
+   */
+  async loadCredentialsFile() {
+    try {
+      const exists = await this.fileExists();
+      if (!exists) {
+        return null;
+      }
+      const encrypted = await readFile2(this.credentialsFilePath, "utf-8");
+      const decrypted = this.decrypt(encrypted);
+      return JSON.parse(decrypted);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Encrypt and save credentials file
+   */
+  async saveCredentialsFile(credFile) {
+    const dir = dirname2(this.credentialsFilePath);
+    await mkdir2(dir, { recursive: true });
+    const json = JSON.stringify(credFile, null, 2);
+    const encrypted = this.encrypt(json);
+    await writeFile2(this.credentialsFilePath, encrypted, "utf-8");
+  }
+  /**
+   * Check if credentials file exists
+   */
+  async fileExists() {
+    try {
+      await access2(this.credentialsFilePath, constants2.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Create empty credentials file structure
+   */
+  createEmptyCredentialsFile() {
+    return {
+      version: "1.0",
+      encrypted: true,
+      providers: {}
+    };
+  }
+  /**
+   * Encrypt data using AES-256-GCM
+   */
+  encrypt(data) {
+    const salt = randomBytes(this.saltLength);
+    const iv = randomBytes(this.ivLength);
+    const key = scryptSync(this.passphrase, salt, this.keyLength);
+    const cipher = createCipheriv(this.algorithm, key, iv);
+    const encrypted = Buffer.concat([cipher.update(data, "utf-8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    const result = Buffer.concat([salt, iv, tag, encrypted]);
+    return result.toString("base64");
+  }
+  /**
+   * Decrypt data using AES-256-GCM
+   */
+  decrypt(encrypted) {
+    const buffer = Buffer.from(encrypted, "base64");
+    const salt = buffer.subarray(0, this.saltLength);
+    const iv = buffer.subarray(this.saltLength, this.saltLength + this.ivLength);
+    const tag = buffer.subarray(
+      this.saltLength + this.ivLength,
+      this.saltLength + this.ivLength + this.tagLength
+    );
+    const data = buffer.subarray(this.saltLength + this.ivLength + this.tagLength);
+    const key = scryptSync(this.passphrase, salt, this.keyLength);
+    const decipher = createDecipheriv(this.algorithm, key, iv);
+    decipher.setAuthTag(tag);
+    const decrypted = Buffer.concat([decipher.update(data), decipher.final()]);
+    return decrypted.toString("utf-8");
+  }
+};
+function createCredentialStore(projectDir = process.cwd(), passphrase) {
+  const credentialsFilePath = join2(projectDir, ".setbase", "credentials.json");
+  const phrase = passphrase || process.env.SETBASE_PASSPHRASE || "default-passphrase";
+  return new EncryptedCredentialStore(credentialsFilePath, phrase);
+}
+
+// src/manifest/parser.ts
+import { constants as constants3 } from "fs";
+import { readFile as readFile3, writeFile as writeFile3, access as access3, mkdir as mkdir3 } from "fs/promises";
+import { join as join3, dirname as dirname3 } from "path";
+var DefaultManifestParser = class {
+  async parse(filePath) {
+    try {
+      const content = await readFile3(filePath, "utf-8");
+      return await this.parseString(content);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new ManifestError(`Manifest file not found: ${filePath}`);
+      }
+      throw new ManifestError("Failed to read manifest file", { error, filePath });
+    }
+  }
+  async parseString(content) {
+    try {
+      const manifest = JSON.parse(content);
+      if (!manifest.version) {
+        throw new ManifestError("Manifest missing required field: version");
+      }
+      if (manifest.version !== "1.0") {
+        throw new ManifestError(`Unsupported manifest version: ${manifest.version}`);
+      }
+      if (!manifest.project) {
+        throw new ManifestError("Manifest missing required field: project");
+      }
+      if (!manifest.project.name) {
+        throw new ManifestError("Manifest missing required field: project.name");
+      }
+      if (!manifest.project.runtime) {
+        throw new ManifestError("Manifest missing required field: project.runtime");
+      }
+      logger.debug("Manifest parsed successfully", { project: manifest.project.name });
+      return manifest;
+    } catch (error) {
+      if (error instanceof ManifestError) {
+        throw error;
+      }
+      if (error instanceof SyntaxError) {
+        throw new ManifestError("Invalid JSON in manifest file", { error });
+      }
+      throw new ManifestError("Failed to parse manifest", { error });
+    }
+  }
+  async write(filePath, manifest) {
+    try {
+      const dir = dirname3(filePath);
+      await mkdir3(dir, { recursive: true });
+      const content = JSON.stringify(manifest, null, 2);
+      await writeFile3(filePath, content, "utf-8");
+      logger.debug("Manifest written successfully", { filePath });
+    } catch (error) {
+      throw new ManifestError("Failed to write manifest file", { error, filePath });
+    }
+  }
+  async exists(filePath) {
+    try {
+      await access3(filePath, constants3.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function createManifestParser() {
+  return new DefaultManifestParser();
+}
+async function loadManifest(projectDir = process.cwd()) {
+  const parser = createManifestParser();
+  const manifestPath = join3(projectDir, "setbase.json");
+  return parser.parse(manifestPath);
+}
+async function saveManifest(manifest, projectDir = process.cwd()) {
+  const parser = createManifestParser();
+  const manifestPath = join3(projectDir, "setbase.json");
+  return parser.write(manifestPath, manifest);
+}
+
+// src/manifest/schema.ts
+import { z } from "zod";
+var projectConfigSchema = z.object({
+  name: z.string().min(3).max(50).regex(/^[a-z0-9-]+$/),
+  description: z.string().optional(),
+  runtime: z.enum(["node", "python", "go"]),
+  framework: z.string().optional()
+});
+var databaseConfigSchema = z.object({
+  region: z.string().optional(),
+  instanceType: z.string().optional(),
+  storage: z.number().optional(),
+  version: z.string().optional()
+});
+var cacheConfigSchema = z.object({
+  region: z.string().optional(),
+  maxMemory: z.string().optional(),
+  evictionPolicy: z.enum(["allkeys-lru", "volatile-lru"]).optional()
+});
+var storageConfigSchema = z.object({
+  region: z.string().optional(),
+  public: z.boolean().optional(),
+  cors: z.object({
+    allowedOrigins: z.array(z.string()),
+    allowedMethods: z.array(z.string()).optional(),
+    allowedHeaders: z.array(z.string()).optional()
+  }).optional()
+});
+var emailConfigSchema = z.object({
+  domain: z.string(),
+  fromName: z.string().optional(),
+  replyTo: z.string().email().optional()
+});
+var computeConfigSchema = z.object({
+  runtime: z.enum(["node", "python", "go"]),
+  buildCommand: z.string().optional(),
+  startCommand: z.string(),
+  environmentVariables: z.record(z.string()).optional(),
+  region: z.string().optional(),
+  healthCheck: z.string().optional()
+});
+var resourceDefinitionSchema = z.object({
+  provider: z.string(),
+  config: z.record(z.unknown()),
+  dependsOn: z.array(z.string()).optional()
+});
+var resourceDefinitionsSchema = z.object({
+  database: resourceDefinitionSchema.optional(),
+  cache: resourceDefinitionSchema.optional(),
+  storage: resourceDefinitionSchema.optional(),
+  email: resourceDefinitionSchema.optional()
+});
+var deploymentConfigSchema = z.object({
+  provider: z.string(),
+  config: computeConfigSchema
+});
+var manifestSchema = z.object({
+  $schema: z.string().optional(),
+  version: z.literal("1.0"),
+  project: projectConfigSchema,
+  resources: resourceDefinitionsSchema,
+  deployment: deploymentConfigSchema.optional()
+});
+
+// src/manifest/validator.ts
+var DefaultManifestValidator = class {
+  async validate(manifest) {
+    const result = manifestSchema.safeParse(manifest);
+    if (result.success) {
+      logger.debug("Manifest validation passed");
+      return {
+        valid: true,
+        errors: []
+      };
+    }
+    const errors = result.error.errors.map((error) => ({
+      path: error.path.join("."),
+      message: error.message
+    }));
+    logger.warn("Manifest validation failed", { errors });
+    return {
+      valid: false,
+      errors
+    };
+  }
+};
+function createManifestValidator() {
+  return new DefaultManifestValidator();
+}
+async function validateManifest(manifest) {
+  const validator = createManifestValidator();
+  const result = await validator.validate(manifest);
+  if (!result.valid) {
+    const errorMessage = result.errors.map((e) => `${e.path}: ${e.message}`).join("\n");
+    throw new Error(`Manifest validation failed:
+${errorMessage}`);
+  }
+}
+
+// src/environment/env-manager.ts
+import { writeFile as writeFile4 } from "fs/promises";
+var DefaultEnvironmentManager = class {
+  constructor(stateManager, envAggregator) {
+    this.stateManager = stateManager;
+    this.envAggregator = envAggregator;
+  }
+  stateManager;
+  envAggregator;
+  async getEnvironmentVariables(environment) {
+    logger.info("Getting environment variables", { environment });
+    const state = await this.stateManager.load();
+    if (!state) {
+      throw new Error("Project not initialized");
+    }
+    const resourceEnvVars = await this.envAggregator.aggregate(state);
+    const envVars = {
+      NODE_ENV: environment,
+      ENVIRONMENT: environment,
+      PROJECT_ID: state.projectId,
+      ...resourceEnvVars
+    };
+    return envVars;
+  }
+  async toDotenv(environment) {
+    const vars = await this.getEnvironmentVariables(environment);
+    const lines = Object.entries(vars).map(([key, value]) => {
+      const escapedValue = value.includes(" ") || value.includes("#") || value.includes("=") ? `"${value.replace(/"/g, '\\"')}"` : value;
+      return `${key}=${escapedValue}`;
+    });
+    return lines.join("\n");
+  }
+  async toJSON(environment) {
+    const vars = await this.getEnvironmentVariables(environment);
+    return JSON.stringify(vars, null, 2);
+  }
+  async writeToFile(environment, filePath, format) {
+    logger.info("Writing environment variables to file", { environment, filePath, format });
+    const content = format === "env" ? await this.toDotenv(environment) : await this.toJSON(environment);
+    await writeFile4(filePath, content, "utf-8");
+    logger.info("Environment variables written successfully", { filePath });
+  }
+};
+
+// src/environment/env-aggregator.ts
+var DefaultEnvironmentAggregator = class {
+  constructor(credentialStore) {
+    this.credentialStore = credentialStore;
+  }
+  credentialStore;
+  async aggregate(state) {
+    logger.info("Aggregating environment variables from resources");
+    const envVars = {};
+    for (const [resourceName, resourceState] of Object.entries(state.resources)) {
+      try {
+        const credentials = await this.credentialStore.load(resourceState.provider);
+        if (!credentials) {
+          logger.warn("No credentials found for provider, skipping", {
+            resource: resourceName,
+            provider: resourceState.provider
+          });
+          continue;
+        }
+        const provider = await ProviderFactory.create(
+          resourceState.type,
+          resourceState.provider,
+          credentials
+        );
+        const resourceEnvVars = await provider.getEnvironmentVariables(resourceState.resourceId);
+        const prefix = resourceName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+        for (const [key, value] of Object.entries(resourceEnvVars)) {
+          envVars[key] = value;
+          envVars[`${prefix}_${key}`] = value;
+        }
+        logger.debug("Collected environment variables", {
+          resource: resourceName,
+          count: Object.keys(resourceEnvVars).length
+        });
+      } catch (error) {
+        logger.error("Failed to get environment variables from resource", {
+          resource: resourceName,
+          error
+        });
+      }
+    }
+    logger.info("Environment variable aggregation complete", {
+      totalVars: Object.keys(envVars).length
+    });
+    return envVars;
+  }
+};
+
+// src/utils/validation.ts
+var PROJECT_NAME_REGEX = /^[a-z0-9-]{3,50}$/;
+var RESOURCE_NAME_REGEX = /^[a-z0-9-_]{3,50}$/;
+function validateProjectName(name) {
+  if (!PROJECT_NAME_REGEX.test(name)) {
+    throw new ValidationError(
+      "Project name must be 3-50 characters long and contain only lowercase letters, numbers, and hyphens",
+      { name }
+    );
+  }
+}
+function validateResourceName(name) {
+  if (!RESOURCE_NAME_REGEX.test(name)) {
+    throw new ValidationError(
+      "Resource name must be 3-50 characters long and contain only lowercase letters, numbers, hyphens, and underscores",
+      { name }
+    );
+  }
+}
+export {
+  BaseProvider,
+  DefaultCommandOrchestrator,
+  DefaultDeploymentOrchestrator,
+  DefaultEnvironmentAggregator,
+  DefaultEnvironmentManager,
+  DefaultManifestParser,
+  DefaultManifestValidator,
+  DeploymentError,
+  DeploymentStatus,
+  EncryptedCredentialStore,
+  FileStateManager,
+  ManifestError,
+  ProviderError,
+  ProviderFactory,
+  ProviderRegistry,
+  ResourceGraph,
+  ResourceStatus,
+  ResourceType,
+  SetbaseError,
+  StateError,
+  ValidationError,
+  createCredentialStore,
+  createManifestParser,
+  createManifestValidator,
+  createStateManager,
+  generateId,
+  generateProjectId,
+  generateResourceId,
+  loadManifest,
+  logger,
+  manifestSchema,
+  saveManifest,
+  validateManifest,
+  validateProjectName,
+  validateResourceName
+};
+//# sourceMappingURL=index.js.map