@highstate/designer 0.2.2 → 0.3.3

package/.output/server/chunks/routes/api/_trpc_.mjs

@@ -0,0 +1,1067 @@
+import process from 'node:process';globalThis._importMeta_=globalThis._importMeta_||{url:"file:///_entry.js",env:process.env};import { e as eventHandler, r as readBody, t as toWebRequest, d as defineLazyEventHandler } from '../../nitro/nitro.mjs';
+import { resolveResponse } from '@trpc/server/http';
+import { initTRPC, TRPCError } from '@trpc/server';
+import { z } from 'zod';
+import { createConsola as createConsola$1 } from 'consola/core';
+import { fileURLToPath } from 'node:url';
+import { EventEmitter, on } from 'node:events';
+import { Worker } from 'node:worker_threads';
+import { basename, relative, dirname } from 'node:path';
+import Watcher from 'watcher';
+import { BetterLock } from 'better-lock';
+import { resolve } from 'import-meta-resolve';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { pickBy, mapValues, debounce } from 'remeda';
+import { findWorkspaceDir, readPackageJSON } from 'pkg-types';
+import { addDependency } from 'nypm';
+import 'node:http';
+import 'node:https';
+import 'node:fs';
+
+// src/server/index.ts
+function getPath(event) {
+  const { params } = event.context;
+  if (typeof params?.trpc === "string") {
+    return params.trpc;
+  }
+  if (params?.trpc && Array.isArray(params.trpc)) {
+    return params.trpc.join("/");
+  }
+  return null;
+}
+function createNuxtApiHandler(opts) {
+  return eventHandler(async (event) => {
+    const createContext = async (innerOpts) => {
+      return await opts.createContext?.(event, innerOpts);
+    };
+    const { req } = event.node;
+    const path = getPath(event);
+    if (event.method === "POST") {
+      req.body = await readBody(event);
+    }
+    const httpResponse = await resolveResponse({
+      ...opts,
+      req: toWebRequest(event),
+      error: null,
+      createContext,
+      path,
+      onError(o) {
+        opts.onError?.({
+          ...o,
+          req
+        });
+      }
+    });
+    return httpResponse;
+  });
+}
+
+const t = initTRPC.context().create();
+const publicProcedure = t.procedure;
+const router = t.router;
+t.middleware;
+
+const stateRouter = router({
+  get: publicProcedure.input(
+    z.object({
+      projectId: z.string()
+    })
+  ).query(async ({ input, ctx }) => {
+    const operator = await ctx.operatorManager.get(input.projectId);
+    return operator.state;
+  }),
+  watchCurrentOperation: publicProcedure.input(
+    z.object({
+      projectId: z.string()
+    })
+  ).subscription(async function* ({ input, ctx, signal }) {
+    const operator = await ctx.operatorManager.get(input.projectId);
+    yield* operator.watchCurrentOperation(signal);
+  }),
+  watchInstanceStates: publicProcedure.input(
+    z.object({
+      projectId: z.string()
+    })
+  ).subscription(async function* ({ input, ctx, signal }) {
+    const operator = await ctx.operatorManager.get(input.projectId);
+    yield* operator.watchInstanceStates(signal);
+  })
+});
+
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+var _a;
+class LocalPulumiProjectHost {
+  constructor() {
+    __publicField$4(this, "lock", new BetterLock());
+    __publicField$4(this, "password", (_a = process.env.PULUMI_CONFIG_PASSPHRASE) != null ? _a : "");
+  }
+  hasPassword() {
+    return !!this.password;
+  }
+  setPassword(password) {
+    this.password = password;
+  }
+  async runInline(projectName, stackName, program, fn) {
+    return this.lock.acquire(`${projectName}.${stackName}`, async () => {
+      const { LocalWorkspace } = await import('@pulumi/pulumi/automation');
+      const stack = await LocalWorkspace.createOrSelectStack(
+        {
+          projectName,
+          stackName,
+          program
+        },
+        {
+          projectSettings: {
+            name: projectName,
+            runtime: "nodejs"
+          },
+          envVars: { PULUMI_CONFIG_PASSPHRASE: this.password }
+        }
+      );
+      return await fn(stack);
+    });
+  }
+  async runLocal(projectName, stackName, programPathResolver, fn) {
+    return this.lock.acquire(`${projectName}.${stackName}`, async () => {
+      const { LocalWorkspace } = await import('@pulumi/pulumi/automation');
+      const stack = await LocalWorkspace.createOrSelectStack(
+        {
+          stackName,
+          workDir: await programPathResolver()
+        },
+        {
+          envVars: { PULUMI_CONFIG_PASSPHRASE: this.password }
+        }
+      );
+      return await fn(stack);
+    });
+  }
+}
+
+const instanceStatusSchema = z.enum([
+  "not_created",
+  "updating",
+  "destroying",
+  "refreshing",
+  "created",
+  "error"
+]);
+const instanceStateSchema = z.object({
+  key: z.string(),
+  parentKey: z.string().optional(),
+  status: instanceStatusSchema,
+  resources: z.number(),
+  totalResources: z.number(),
+  error: z.string().optional(),
+  message: z.string().optional()
+});
+const operationType = z.enum(["update", "destroy", "recreate", "refresh"]);
+const projectOperation = z.object({
+  type: operationType,
+  instanceIds: z.array(z.string())
+});
+const projectStateSchema = z.object({
+  currentOperation: projectOperation.optional(),
+  instances: z.record(instanceStateSchema.optional())
+});
+const positionSchema = z.object({
+  x: z.number(),
+  y: z.number()
+});
+const outputRefSchema = z.object({
+  instanceId: z.string(),
+  output: z.string()
+});
+const instanceModelSchema = z.object({
+  id: z.string().nanoid(),
+  type: z.string(),
+  name: z.string(),
+  position: positionSchema,
+  args: z.record(z.any()),
+  inputs: z.record(z.union([outputRefSchema, z.array(outputRefSchema)]))
+});
+
+const stringArrayType = z.string().transform((args) => args.split(",").map((arg) => arg.trim()));
+
+async function resolveMainLocalProject(projectPath, projectName) {
+  if (!projectPath) {
+    projectPath = await findWorkspaceDir();
+  }
+  if (!projectName) {
+    const packageJson = await readPackageJSON(projectPath);
+    projectName = packageJson.name;
+  }
+  if (!projectName) {
+    projectName = basename(projectPath);
+  }
+  return [projectPath, projectName];
+}
+
+class SecretAccessDeniedError extends Error {
+  constructor(projectId, key) {
+    super(`Access to the secrets of component "${projectId}.${key}" is denied.`);
+  }
+}
+
+const localSecretBackendConfig = z.object({
+  HIGHSTATE_BACKEND_SECRET_PROJECT_PATH: z.string().optional(),
+  HIGHSTATE_BACKEND_SECRET_PROJECT_NAME: z.string().optional()
+});
+class LocalSecretBackend {
+  constructor(projectPath, projectName, pulumiProjectHost) {
+    this.projectPath = projectPath;
+    this.projectName = projectName;
+    this.pulumiProjectHost = pulumiProjectHost;
+  }
+  get(projectId, componentKey) {
+    return this.pulumiProjectHost.runLocal(
+      this.projectName,
+      projectId,
+      () => this.projectPath,
+      async (stack) => {
+        const config = await stack.getAllConfig();
+        const componentSecrets = pickBy(config, (_, key) => key.startsWith(`${componentKey}.`));
+        return mapValues(componentSecrets, (value) => value.value);
+      }
+    );
+  }
+  set(projectId, componentKey, values) {
+    return this.pulumiProjectHost.runLocal(
+      this.projectName,
+      projectId,
+      () => this.projectPath,
+      async (stack) => {
+        const componentSecrets = mapValues(values, (value, key) => ({
+          key: `${componentKey}.${key}`,
+          value
+        }));
+        const config = await stack.getAllConfig();
+        Object.assign(config, componentSecrets);
+        await stack.setAllConfig(config);
+      }
+    );
+  }
+  static async create(config, pulumiProjectHost) {
+    const [projectPath, projectName] = await resolveMainLocalProject(
+      config.HIGHSTATE_BACKEND_SECRET_PROJECT_PATH,
+      config.HIGHSTATE_BACKEND_SECRET_PROJECT_NAME
+    );
+    return new LocalSecretBackend(projectPath, projectName, pulumiProjectHost);
+  }
+}
+
+const secretBackendConfig = z.object({
+  HIGHSTATE_BACKEND_SECRET_TYPE: z.enum(["local"]).default("local"),
+  ...localSecretBackendConfig.shape
+});
+function createSecretBackend(config, pulumiProjectHost) {
+  return LocalSecretBackend.create(config, pulumiProjectHost);
+}
+
+const basicReporter = {
+  log(logObj) {
+    (console[logObj.type] || console.log)(...logObj.args);
+  }
+};
+function createConsola(options = {}) {
+  return createConsola$1({
+    reporters: [basicReporter],
+    ...options
+  });
+}
+const consola = createConsola();
+consola.consola = consola;
+
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+const localLibraryBackendConfig = z.object({
+  HIGHSTATE_BACKEND_LIBRARY_LOCAL_MODULES: stringArrayType.default("@highstate/library")
+});
+class LocalLibraryBackend {
+  constructor(modulePaths) {
+    this.modulePaths = modulePaths;
+    __publicField$3(this, "watcher");
+    __publicField$3(this, "lock", new BetterLock());
+    __publicField$3(this, "eventEmitter", new EventEmitter());
+    __publicField$3(this, "library", null);
+    this.watcher = new Watcher(modulePaths, { recursive: true, ignoreInitial: true });
+    this.watcher.on("all", (event, path) => {
+      const prefixPath = modulePaths.find((modulePath) => path.startsWith(modulePath));
+      consola.info("Library event:", event, relative(prefixPath, path));
+      void this.updateLibrary();
+    });
+    consola.info("Library watchers set to:", modulePaths);
+  }
+  async loadLibrary() {
+    if (this.library) {
+      return this.library;
+    }
+    return await this.updateLibrary();
+  }
+  async *watchLibrary(signal) {
+    for await (const [library] of on(this.eventEmitter, "library", { signal })) {
+      yield library;
+    }
+  }
+  async evaluateInstances(instances, instanceIds) {
+    const worker = this.createWorker("library-evaluator", {
+      modulePaths: this.modulePaths,
+      instances,
+      instanceIds
+    });
+    for await (const [registrations] of on(worker, "message")) {
+      return registrations;
+    }
+    throw new Error("Worker ended without sending registrations.");
+  }
+  async updateLibrary() {
+    return await this.lock.acquire(async () => {
+      const worker = this.createWorker("library-loader", { modulePaths: this.modulePaths });
+      for await (const [library] of on(worker, "message")) {
+        this.eventEmitter.emit("library", library);
+        this.library = library;
+        consola.success("Library reloaded");
+        return this.library;
+      }
+      throw new Error("Worker ended without sending library model.");
+    });
+  }
+  createWorker(module, workerData) {
+    const workerPathUrl = resolve(`@highstate/backend/${module}`, globalThis._importMeta_.url);
+    const workerPath = fileURLToPath(workerPathUrl);
+    return new Worker(workerPath, { workerData });
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  static async create(config) {
+    const modulePaths = [];
+    for (const module of config.HIGHSTATE_BACKEND_LIBRARY_LOCAL_MODULES) {
+      const url = resolve(module, globalThis._importMeta_.url);
+      let path = fileURLToPath(url);
+      if (basename(path).includes(".")) {
+        path = dirname(path);
+      }
+      modulePaths.push(path);
+    }
+    return new LocalLibraryBackend(modulePaths);
+  }
+}
+
+const libraryBackendConfig = z.object({
+  HIGHSTATE_BACKEND_LIBRARY_TYPE: z.enum(["local"]).default("local"),
+  ...localLibraryBackendConfig.shape
+});
+function createLibraryBackend(config) {
+  switch (config.HIGHSTATE_BACKEND_LIBRARY_TYPE) {
+    case "local": {
+      return LocalLibraryBackend.create(config);
+    }
+  }
+}
+
+const localProjectBackendConfig = z.object({
+  HIGHSTATE_BACKEND_PROJECT_BLUEPRINTS_DIR: z.string().default("blueprints")
+});
+const blueprintModelSchema = z.object({
+  instances: z.record(instanceModelSchema)
+});
+class LocalProjectBackend {
+  constructor(blueprintsDir) {
+    this.blueprintsDir = blueprintsDir;
+  }
+  async getInstances(projectId) {
+    try {
+      const blueprint = await this.loadBlueprint(projectId);
+      return blueprint.instances;
+    } catch (error) {
+      console.error("Failed to read blueprint", error);
+      return {};
+    }
+  }
+  async updateInstance(projectId, instance) {
+    try {
+      const blueprint = await this.loadBlueprint(projectId);
+      blueprint.instances[instance.id] = instance;
+      await this.writeBlueprint(projectId, blueprint);
+    } catch (error) {
+      console.error("Failed to update blueprint instance", error);
+    }
+  }
+  async deleteInstance(projectId, instanceId) {
+    try {
+      const blueprint = await this.loadBlueprint(projectId);
+      delete blueprint.instances[instanceId];
+      await this.writeBlueprint(projectId, blueprint);
+    } catch (error) {
+      console.error("Failed to delete blueprint instance", error);
+    }
+  }
+  getBlueprintPath(projectId) {
+    return `${this.blueprintsDir}/${projectId}.json`;
+  }
+  async loadBlueprint(projectId) {
+    const blueprintPath = this.getBlueprintPath(projectId);
+    try {
+      const content = await readFile(blueprintPath, "utf-8");
+      return blueprintModelSchema.parse(JSON.parse(content));
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        return { instances: {} };
+      }
+      throw error;
+    }
+  }
+  async writeBlueprint(projectId, blueprint) {
+    const blueprintPath = this.getBlueprintPath(projectId);
+    const content = JSON.stringify(blueprint, void 0, 2);
+    await writeFile(blueprintPath, content);
+  }
+  static async create(config) {
+    await mkdir(config.HIGHSTATE_BACKEND_PROJECT_BLUEPRINTS_DIR, { recursive: true });
+    return new LocalProjectBackend(config.HIGHSTATE_BACKEND_PROJECT_BLUEPRINTS_DIR);
+  }
+}
+
+const projectBackendConfig = z.object({
+  HIGHSTATE_BACKEND_PROJECT_TYPE: z.enum(["local"]).default("local"),
+  ...localProjectBackendConfig.shape
+});
+function createProjectBackend(config) {
+  return LocalProjectBackend.create(config);
+}
+
+const localStateBackendConfig = z.object({
+  HIGHSTATE_BACKEND_STATE_PROJECT_PATH: z.string().optional(),
+  HIGHSTATE_BACKEND_STATE_PROJECT_NAME: z.string().optional()
+});
+class LocalStateBackend {
+  constructor(projectName, pulumiProjectHost) {
+    this.projectName = projectName;
+    this.pulumiProjectHost = pulumiProjectHost;
+  }
+  get(projectId) {
+    return this.pulumiProjectHost.runInline(
+      this.projectName,
+      projectId,
+      () => Promise.resolve(),
+      (stack) => this.getAllState(stack)
+    );
+  }
+  set(projectId, state) {
+    return this.pulumiProjectHost.runInline(
+      this.projectName,
+      projectId,
+      () => Promise.resolve(),
+      async (stack) => {
+        await stack.setConfig("state", { value: JSON.stringify(state) });
+        await stack.up();
+      }
+    );
+  }
+  async getAllState(stack) {
+    const history = await stack.history(1);
+    if (!history.length) {
+      return { instances: {} };
+    }
+    if (!history[0].config["state"]) {
+      return { instances: {} };
+    }
+    const jsonValue = JSON.parse(history[0].config["state"].value);
+    return projectStateSchema.parse(jsonValue);
+  }
+  static async create(config, pulumiProjectHost) {
+    const [, projectName] = await resolveMainLocalProject(
+      config.HIGHSTATE_BACKEND_STATE_PROJECT_PATH,
+      config.HIGHSTATE_BACKEND_STATE_PROJECT_NAME
+    );
+    return new LocalStateBackend(projectName, pulumiProjectHost);
+  }
+}
+
+const stateBackendConfig = z.object({
+  HIGHSTATE_BACKEND_STATE_TYPE: z.enum(["local"]).default("local"),
+  ...localStateBackendConfig.shape
+});
+function createStateBackend(config, pulumiProjectHost) {
+  return LocalStateBackend.create(config, pulumiProjectHost);
+}
+
+const configSchema = z.object({
+  ...libraryBackendConfig.shape,
+  ...projectBackendConfig.shape,
+  ...secretBackendConfig.shape,
+  ...stateBackendConfig.shape
+});
+async function loadConfig(env = process.env, useDotenv = true) {
+  if (useDotenv) {
+    await import('dotenv/config');
+  }
+  return configSchema.parse(env);
+}
+
+function isUnitModel(model) {
+  return "source" in model;
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+class ProjectOperator {
+  constructor(projectId, state, runnerBackend, stateBackend, libraryBackend, projectBackend, secretBackend) {
+    this.projectId = projectId;
+    this.state = state;
+    this.runnerBackend = runnerBackend;
+    this.stateBackend = stateBackend;
+    this.libraryBackend = libraryBackend;
+    this.projectBackend = projectBackend;
+    this.secretBackend = secretBackend;
+    __publicField$2(this, "unitPromises", /* @__PURE__ */ new Map());
+    __publicField$2(this, "eventEmitter", new EventEmitter());
+    __publicField$2(this, "debouncedUpdateState", debounce(() => this.stateBackend.set(this.projectId, this.state), {
+      waitMs: 1e3,
+      maxWaitMs: 1e4
+    }));
+    __publicField$2(this, "abortController", new AbortController());
+  }
+  async *watchInstanceStates(signal) {
+    for await (const [state] of on(this.eventEmitter, "state", { signal })) {
+      yield state;
+    }
+  }
+  async *watchCurrentOperation(signal) {
+    for await (const [operation] of on(this.eventEmitter, "operation", { signal })) {
+      yield operation;
+    }
+  }
+  /**
+   * Launches the project operation.
+   * Throws an error if the operation is already running.
+   *
+   * @param operation The operation to launch.
+   */
+  launch(operation) {
+    if (this.state.currentOperation) {
+      throw new Error("An operation is already running.");
+    }
+    this.abortController = new AbortController();
+    this.updateCurrentOperation(operation);
+    void this.operate().finally(() => {
+      this.updateCurrentOperation(void 0);
+    });
+  }
+  /**
+   * Cancels the current operation.
+   * Does nothing if no operation is running.
+   */
+  cancel() {
+    if (!this.state.currentOperation) {
+      return;
+    }
+    this.abortController.abort();
+  }
+  async operate() {
+    await this.debouncedUpdateState.flush();
+    const operation = this.state.currentOperation;
+    const instances = await this.projectBackend.getInstances(this.projectId);
+    const library = await this.libraryBackend.loadLibrary();
+    const registrations = await this.libraryBackend.evaluateInstances(
+      instances,
+      operation.instanceIds
+    );
+    const promises = [];
+    for (const registration of Object.values(registrations)) {
+      const promise = this.upUnit(library, registrations, registration);
+      promises.push(promise);
+    }
+    await Promise.all(promises);
+  }
+  async upUnit(library, registrations, registration) {
+    const model = library.components[registration.type];
+    if (!isUnitModel(model)) {
+      throw new Error(`The component "${registration.type}" is not a unit.`);
+    }
+    const key = `${registration.type}.${registration.name}`;
+    const dependencyPromises = [];
+    for (const dependency of registration.dependencies) {
+      const state = this.state.instances[dependency];
+      if ((state == null ? void 0 : state.status) === "created") {
+        continue;
+      }
+      const dependencyPromise = this.getOrCreateUnitPromise(
+        key,
+        () => this.upUnit(library, registrations, registrations[dependency])
+      );
+      dependencyPromises.push(dependencyPromise);
+    }
+    await Promise.all(dependencyPromises);
+    await this.runnerBackend.update({
+      projectName: registration.type,
+      stackName: registration.name,
+      config: await this.getUnitConfig(model, key, registration),
+      source: model.source
+    });
+    const stream = this.runnerBackend.watch({
+      projectName: registration.type,
+      stackName: registration.name,
+      finalStatuses: ["created", "error"]
+    });
+    await this.watchStateStream(stream);
+  }
+  async getUnitConfig(model, key, registration) {
+    const secrets = await this.secretBackend.get(this.projectId, `${model.type}.${key}`);
+    return {
+      ...registration.config,
+      ...secrets
+    };
+  }
+  async watchStateStream(stream) {
+    let state;
+    for await (state of stream) {
+      this.updateInstanceState(state);
+    }
+    if (!state) {
+      throw new Error("The stream ended without emitting any state.");
+    }
+    if (state.status === "error") {
+      throw new Error(`The operation on unit "${state.key}" failed.`);
+    }
+  }
+  updateCurrentOperation(operation) {
+    this.state.currentOperation = operation;
+    this.eventEmitter.emit("operation", operation);
+    void this.debouncedUpdateState.call();
+  }
+  updateInstanceState(state) {
+    this.state.instances[state.key] = state;
+    this.eventEmitter.emit("state", state);
+    void this.debouncedUpdateState.call();
+  }
+  getOrCreateUnitPromise(unitKey, fn) {
+    let promise = this.unitPromises.get(unitKey);
+    if (!promise) {
+      promise = fn().then(() => {
+        this.unitPromises.delete(unitKey);
+      });
+      this.unitPromises.set(unitKey, promise);
+    }
+    return promise;
+  }
+  static async create(projectId, runnerBackend, stateBackend, libraryBackend, projectBackend, secretBackend) {
+    const state = await stateBackend.get(projectId);
+    return new ProjectOperator(
+      projectId,
+      state,
+      runnerBackend,
+      stateBackend,
+      libraryBackend,
+      projectBackend,
+      secretBackend
+    );
+  }
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+class OperatorManager {
+  constructor(runnerBackend, stateBackend, libraryBackend, projectBackend, secretBackend) {
+    this.runnerBackend = runnerBackend;
+    this.stateBackend = stateBackend;
+    this.libraryBackend = libraryBackend;
+    this.projectBackend = projectBackend;
+    this.secretBackend = secretBackend;
+    __publicField$1(this, "operators", /* @__PURE__ */ new Map());
+    __publicField$1(this, "lock", new BetterLock());
+  }
+  async get(projectId) {
+    return await this.lock.acquire(projectId, async () => {
+      let orchestrator = this.operators.get(projectId);
+      if (!orchestrator) {
+        orchestrator = await ProjectOperator.create(
+          projectId,
+          this.runnerBackend,
+          this.stateBackend,
+          this.libraryBackend,
+          this.projectBackend,
+          this.secretBackend
+        );
+        this.operators.set(projectId, orchestrator);
+      }
+      return orchestrator;
+    });
+  }
+}
+
+class InvalidInstanceStatusError extends Error {
+  constructor(currentStatus, expectedStatuses) {
+    const expectedString = expectedStatuses.join(", ");
+    super(`The current state is "${currentStatus}", but it should be one of "${expectedString}".`);
+    this.currentStatus = currentStatus;
+    this.expectedStatuses = expectedStatuses;
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class LocalRunnerBackend {
+  constructor() {
+    __publicField(this, "host", new LocalPulumiProjectHost());
+    __publicField(this, "events", new EventEmitter());
+    __publicField(this, "states", /* @__PURE__ */ new Map());
+  }
+  async *watch(options) {
+    const stream = on(
+      //
+      this.events,
+      `state:${LocalRunnerBackend.getInstanceKey(options)}`,
+      { signal: options.signal }
+    );
+    for await (const [state] of stream) {
+      yield state;
+      if (options.finalStatuses.includes(state.status)) {
+        return;
+      }
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async update(options) {
+    const currentStatus = this.validateStatus(options, [
+      "not_created",
+      "updating",
+      "created",
+      "error"
+    ]);
+    if (currentStatus === "updating") {
+      return;
+    }
+    void this.host.runLocal(
+      options.projectName,
+      options.stackName,
+      () => LocalRunnerBackend.resolveProjectPath(options.source),
+      async (stack) => {
+        const configMap = mapValues(options.config, (value) => ({ value }));
+        await stack.setAllConfig(configMap);
+        const state = {
+          key: LocalRunnerBackend.getInstanceKey(options),
+          status: "updating",
+          resources: 0,
+          totalResources: 0
+        };
+        this.updateState(state);
+        try {
+          await stack.up({
+            onEvent: (event) => {
+              if (event.resourcePreEvent) {
+                state.totalResources++;
+                this.updateState(state);
+                return;
+              }
+              if (event.resOutputsEvent) {
+                state.resources++;
+                this.updateState(state);
+                return;
+              }
+            },
+            onOutput: (message) => {
+              state.message = message;
+              this.updateState(state);
+            },
+            signal: options.signal
+          });
+          state.status = "created";
+          this.updateState(state);
+        } catch (e) {
+          state.status = "error";
+          state.error = e instanceof Error ? e.message : String(e);
+          this.updateState(state);
+        }
+      }
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async destroy(options) {
+    const currentStatus = this.validateStatus(options, [
+      "not_created",
+      "destroying",
+      "created",
+      "error"
+    ]);
+    if (currentStatus === "destroying" || currentStatus === "not_created") {
+      return;
+    }
+    void this.host.runLocal(
+      options.projectName,
+      options.stackName,
+      () => LocalRunnerBackend.resolveProjectPath(options.source),
+      async (stack) => {
+        var _a;
+        const stackSumary = await stack.workspace.stack();
+        const resources = (_a = stackSumary == null ? void 0 : stackSumary.resourceCount) != null ? _a : 0;
+        const state = {
+          key: LocalRunnerBackend.getInstanceKey(options),
+          status: "destroying",
+          resources,
+          totalResources: resources
+        };
+        this.updateState(state);
+        try {
+          await stack.destroy({
+            onEvent: (event) => {
+              if (event.resOutputsEvent) {
+                state.resources--;
+                this.updateState(state);
+                return;
+              }
+            },
+            signal: options.signal
+          });
+          state.status = "not_created";
+          this.updateState(state);
+        } catch (e) {
+          state.status = "error";
+          state.error = e instanceof Error ? e.message : String(e);
+          this.updateState(state);
+        }
+      }
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async refresh(options) {
+    const currentStatus = this.validateStatus(options, [
+      "not_created",
+      "created",
+      "refreshing",
+      "error"
+    ]);
+    if (currentStatus === "refreshing") {
+      return;
+    }
+    void this.host.runLocal(
+      options.projectName,
+      options.stackName,
+      () => LocalRunnerBackend.resolveProjectPath(options.source),
+      async (stack) => {
+        var _a;
+        const stackSumary = await stack.workspace.stack();
+        const resources = (_a = stackSumary == null ? void 0 : stackSumary.resourceCount) != null ? _a : 0;
+        const state = {
+          key: LocalRunnerBackend.getInstanceKey(options),
+          status: "refreshing",
+          resources,
+          totalResources: resources
+        };
+        this.updateState(state);
+        try {
+          await stack.refresh({
+            onEvent: (event) => {
+              if (event.resOutputsEvent) {
+                if (event.resOutputsEvent.metadata.op === "create") {
+                  state.resources++;
+                  this.updateState(state);
+                  return;
+                }
+                if (event.resOutputsEvent.metadata.op === "delete") {
+                  state.totalResources--;
+                  this.updateState(state);
+                  return;
+                }
+                return;
+              }
+            },
+            signal: options.signal
+          });
+          state.status = "created";
+          this.updateState(state);
+        } catch (e) {
+          state.status = "error";
+          state.error = e instanceof Error ? e.message : String(e);
+          this.updateState(state);
+        }
+      }
+    );
+  }
+  updateState(state) {
+    this.states.set(state.key, state);
+    this.events.emit(`state:${state.key}`, state);
+  }
+  validateStatus(options, expectedStatuses) {
+    const key = LocalRunnerBackend.getInstanceKey(options);
+    const existingState = this.states.get(key);
+    if (!existingState) {
+      return;
+    }
+    if (!expectedStatuses.includes(existingState.status)) {
+      throw new InvalidInstanceStatusError(existingState.status, expectedStatuses);
+    }
+    return existingState.status;
+  }
+  static getInstanceKey(options) {
+    return `${options.projectName}.${options.stackName}`;
+  }
+  static async resolveProjectPath(source) {
+    await addDependency(source.package);
+    const url = resolve(source.package, globalThis._importMeta_.url);
+    const path = fileURLToPath(url);
+    const projectPath = dirname(path);
+    return projectPath;
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  static async create() {
+    return new LocalRunnerBackend();
+  }
+}
+
+function createRunnerBackend() {
+  return LocalRunnerBackend.create();
+}
+
+async function createServices(config) {
+  config != null ? config : config = await loadConfig();
+  const pulumiProjectHost = new LocalPulumiProjectHost();
+  const libraryBackend = await createLibraryBackend(config);
+  const secretBackend = await createSecretBackend(config, pulumiProjectHost);
+  const runnerBackend = await createRunnerBackend();
+  const projectBackend = await createProjectBackend(config);
+  const stateBackend = await createStateBackend(config, pulumiProjectHost);
+  const operatorManager = new OperatorManager(
+    runnerBackend,
+    stateBackend,
+    libraryBackend,
+    projectBackend,
+    secretBackend
+  );
+  consola.success("Backend services initialized");
+  return {
+    libraryBackend,
+    secretBackend,
+    runnerBackend,
+    projectBackend,
+    stateBackend,
+    operatorManager
+  };
+}
+
+const secretRouter = router({
+  get: publicProcedure.input(
+    z.object({
+      projectId: z.string(),
+      instanceKey: z.string()
+    })
+  ).query(async ({ input, ctx }) => {
+    try {
+      return await ctx.secretBackend.get(input.projectId, input.instanceKey);
+    } catch (e) {
+      if (e instanceof SecretAccessDeniedError) {
+        throw new TRPCError({
+          code: "FORBIDDEN",
+          message: "Access to the secret is denied",
+          cause: e
+        });
+      }
+      throw e;
+    }
+  }),
+  set: publicProcedure.input(
+    z.object({
+      projectId: z.string(),
+      instanceKey: z.string(),
+      values: z.record(z.string())
+    })
+  ).mutation(async ({ input, ctx }) => {
+    try {
+      await ctx.secretBackend.set(input.projectId, input.instanceKey, input.values);
+    } catch (e) {
+      if (e instanceof SecretAccessDeniedError) {
+        throw new TRPCError({
+          code: "FORBIDDEN",
+          message: "Access to the secret is denied",
+          cause: e
+        });
+      }
+      throw e;
+    }
+  })
+});
+
+const projectRouter = router({
+  getInstances: publicProcedure.input(
+    z.object({
+      projectId: z.string()
+    })
+  ).query(async ({ input, ctx }) => {
+    return await ctx.projectBackend.getInstances(input.projectId);
+  }),
+  updateInstance: publicProcedure.input(
+    z.object({
+      projectId: z.string(),
+      instance: instanceModelSchema
+    })
+  ).mutation(async ({ input, ctx }) => {
+    await ctx.projectBackend.updateInstance(input.projectId, input.instance);
+  }),
+  deleteInstance: publicProcedure.input(
+    z.object({
+      projectId: z.string(),
+      instanceKey: z.string()
+    })
+  ).mutation(async ({ input, ctx }) => {
+    await ctx.projectBackend.deleteInstance(input.projectId, input.instanceKey);
+  })
+});
+
+const libraryRouter = router({
+  get: publicProcedure.query(async ({ ctx }) => {
+    return await ctx.libraryBackend.loadLibrary();
+  }),
+  canWatch: publicProcedure.query(async ({ ctx }) => {
+    return !!ctx.libraryBackend.watchLibrary;
+  }),
+  watch: publicProcedure.subscription(async function* ({ ctx, signal }) {
+    if (!ctx.libraryBackend.watchLibrary) {
+      return;
+    }
+    yield* ctx.libraryBackend.watchLibrary(signal);
+  })
+});
+
+const viewportSchema = z.object({
+  x: z.number(),
+  y: z.number(),
+  zoom: z.number()
+});
+let viewport = { x: 0, y: 0, zoom: 1 };
+const workspaceRouter = router({
+  viewport: publicProcedure.query(() => {
+    return viewport;
+  }),
+  setViewport: publicProcedure.input(viewportSchema).mutation(({ input }) => {
+    viewport = input;
+  })
+});
+
+const appRouter = router({
+  secret: secretRouter,
+  state: stateRouter,
+  project: projectRouter,
+  library: libraryRouter,
+  workspace: workspaceRouter
+});
+
+const _trpc_ = defineLazyEventHandler(async () => {
+  const services = await createServices();
+  return createNuxtApiHandler({
+    router: appRouter,
+    createContext: () => ({
+      ...services
+    }),
+    onError: (error) => {
+      console.error("Server Error", error);
+    }
+  });
+});
+
+export { _trpc_ as default };
+//# sourceMappingURL=_trpc_.mjs.map