@ultrst-armada/kloks 0.0.0-stage → 1.0.0

package/packages/backend/dist/chunk-3EPY34R6.js

@@ -0,0 +1,67 @@
+// src/connectivity/IdempotencyManager.ts
+var IdempotencyManager = class {
+  inFlight = /* @__PURE__ */ new Map();
+  completedCache = /* @__PURE__ */ new Map();
+  ttlMs;
+  constructor(ttlMs = 6e4) {
+    this.ttlMs = ttlMs;
+  }
+  async executeIdempotent(idempotencyKey, operation) {
+    const cached = this.completedCache.get(idempotencyKey);
+    if (cached) {
+      if (Date.now() - cached.timestamp < this.ttlMs) {
+        if (cached.status === "completed") {
+          return cached.result;
+        }
+        throw new Error(cached.error || "[IdempotencyManager] Previous execution failed.");
+      } else {
+        this.completedCache.delete(idempotencyKey);
+      }
+    }
+    const existingFlight = this.inFlight.get(idempotencyKey);
+    if (existingFlight) {
+      return await existingFlight;
+    }
+    const executionPromise = (async () => {
+      try {
+        const result = await operation();
+        this.completedCache.set(idempotencyKey, {
+          status: "completed",
+          result,
+          timestamp: Date.now()
+        });
+        return result;
+      } catch (err) {
+        this.completedCache.set(idempotencyKey, {
+          status: "failed",
+          error: err?.message || String(err),
+          timestamp: Date.now()
+        });
+        throw err;
+      } finally {
+        this.inFlight.delete(idempotencyKey);
+      }
+    })();
+    this.inFlight.set(idempotencyKey, executionPromise);
+    return await executionPromise;
+  }
+  has(idempotencyKey) {
+    return this.inFlight.has(idempotencyKey) || this.completedCache.has(idempotencyKey);
+  }
+  prune() {
+    const now = Date.now();
+    for (const [key, entry] of this.completedCache.entries()) {
+      if (now - entry.timestamp > this.ttlMs) {
+        this.completedCache.delete(key);
+      }
+    }
+  }
+  clear() {
+    this.inFlight.clear();
+    this.completedCache.clear();
+  }
+};
+
+export {
+  IdempotencyManager
+};

package/packages/backend/dist/chunk-4QEMALXF.js

@@ -0,0 +1,90 @@
+// src/storage/B2DirectClient.ts
+var authCache = /* @__PURE__ */ new Map();
+async function authorizeB2(keyId, applicationKey) {
+  const cacheKey = `${keyId}:${applicationKey}`;
+  const cached = authCache.get(cacheKey);
+  if (cached && Date.now() < cached.expiresAt) return cached.token;
+  const basic = btoa(`${keyId.trim()}:${applicationKey.trim()}`);
+  const res = await fetch("https://api.backblazeb2.com/b2api/v2/b2_authorize_account", {
+    headers: { Authorization: `Basic ${basic}` }
+  });
+  if (!res.ok) throw new Error(`B2 Authorization failed: ${res.status} ${await res.text()}`);
+  const data = await res.json();
+  const token = {
+    authorizationToken: data.authorizationToken,
+    apiUrl: data.apiUrl,
+    downloadUrl: data.downloadUrl,
+    accountId: data.accountId
+  };
+  authCache.set(cacheKey, { token, expiresAt: Date.now() + 20 * 60 * 1e3 });
+  return token;
+}
+async function b2ListBuckets(keyId, applicationKey) {
+  const auth = await authorizeB2(keyId, applicationKey);
+  const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_list_buckets`, {
+    method: "POST",
+    headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
+    body: JSON.stringify({ accountId: auth.accountId })
+  });
+  if (!res.ok) throw new Error(`B2 list buckets failed: ${res.status}`);
+  const data = await res.json();
+  return data.buckets || [];
+}
+async function b2ListFileNames(keyId, applicationKey, bucketName, prefix = "") {
+  const auth = await authorizeB2(keyId, applicationKey);
+  const buckets = await b2ListBuckets(keyId, applicationKey);
+  const bucket = buckets.find((b) => b.bucketName === bucketName);
+  if (!bucket) return [];
+  const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_list_file_names`, {
+    method: "POST",
+    headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
+    body: JSON.stringify({ bucketId: bucket.bucketId, prefix, maxFileCount: 1e3 })
+  });
+  if (!res.ok) return [];
+  const data = await res.json();
+  return data.files || [];
+}
+async function b2UploadFile(keyId, applicationKey, bucketName, fileName, content, contentType = "application/json") {
+  const auth = await authorizeB2(keyId, applicationKey);
+  const buckets = await b2ListBuckets(keyId, applicationKey);
+  const bucket = buckets.find((b) => b.bucketName === bucketName);
+  if (!bucket) throw new Error(`Bucket ${bucketName} not found`);
+  const urlRes = await fetch(`${auth.apiUrl}/b2api/v2/b2_get_upload_url`, {
+    method: "POST",
+    headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
+    body: JSON.stringify({ bucketId: bucket.bucketId })
+  });
+  if (!urlRes.ok) throw new Error(`B2 get upload url failed: ${urlRes.status}`);
+  const { uploadUrl, authorizationToken } = await urlRes.json();
+  const raw = typeof content === "string" ? new TextEncoder().encode(content) : content;
+  const hashBuffer = await crypto.subtle.digest("SHA-1", raw);
+  const sha1 = Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const upRes = await fetch(uploadUrl, {
+    method: "POST",
+    headers: {
+      Authorization: authorizationToken,
+      "X-Bz-File-Name": encodeURIComponent(fileName).replace(/%2F/g, "/"),
+      "Content-Type": contentType,
+      "Content-Length": String(raw.length),
+      "X-Bz-Content-Sha1": sha1
+    },
+    body: raw
+  });
+  if (!upRes.ok) throw new Error(`B2 upload failed: ${upRes.status} ${await upRes.text()}`);
+  return await upRes.json();
+}
+async function b2DownloadFile(keyId, applicationKey, bucketName, fileName) {
+  const auth = await authorizeB2(keyId, applicationKey);
+  const url = `${auth.downloadUrl}/file/${bucketName}/${encodeURI(fileName)}`;
+  const res = await fetch(url, { headers: { Authorization: auth.authorizationToken } });
+  if (!res.ok) return null;
+  return new Uint8Array(await res.arrayBuffer());
+}
+
+export {
+  authorizeB2,
+  b2ListBuckets,
+  b2ListFileNames,
+  b2UploadFile,
+  b2DownloadFile
+};

package/packages/backend/dist/chunk-4ZFXEFOE.js

@@ -0,0 +1,265 @@
+import {
+  RateLimiter,
+  SessionManager
+} from "./chunk-25Y7AVTP.js";
+
+// src/auth/PasswordHasher.ts
+var bcrypt = null;
+try {
+  bcrypt = (await import("bcryptjs")).default;
+} catch (e) {
+  console.warn("[Skipo] bcryptjs not installed. Using fallback hashing (DEV ONLY).");
+}
+var PasswordHasher = class {
+  static async hash(password, saltRounds = 10) {
+    if (bcrypt) {
+      return bcrypt.hash(password, saltRounds);
+    }
+    return `fallback_hash_${Buffer.from(password).toString("base64")}`;
+  }
+  static async verify(password, hash) {
+    if (bcrypt) {
+      return bcrypt.compare(password, hash);
+    }
+    return hash === `fallback_hash_${Buffer.from(password).toString("base64")}`;
+  }
+};
+
+// src/auth/BaseAccountProvider.ts
+import { SkipoBase } from "@ultrst-armada/kloks/functions";
+var BaseAccountProvider = class extends SkipoBase {
+  rateLimiter = new RateLimiter();
+  sessionManager = new SessionManager();
+  async authenticate(credentials) {
+    this.rateLimiter.check(credentials.email);
+    const user = await this.findUserByEmail(credentials.email);
+    if (!user) {
+      throw new Error("Invalid credentials.");
+    }
+    const isValid = await PasswordHasher.verify(credentials.password, user.passwordHash);
+    if (!isValid) {
+      throw new Error("Invalid credentials.");
+    }
+    this.rateLimiter.reset(credentials.email);
+    return this.sessionManager.createSession(user.id, user.role);
+  }
+  async signup(input) {
+    const existing = await this.findUserByEmail(input.email);
+    if (existing) {
+      throw new Error("Email already in use.");
+    }
+    const passwordHash = await PasswordHasher.hash(input.password);
+    return this.createUser({
+      email: input.email,
+      passwordHash,
+      role: "user",
+      // Enforce user role
+      displayName: input.displayName
+    });
+  }
+  async verifySession(token) {
+    if (!token) return null;
+    const parts = token.split("::");
+    if (parts.length >= 4 && parts[0] === "sess") {
+      const userId = parts[1];
+      const user = await this.findUserById(userId);
+      if (user) {
+        const issueTime = parseInt(parts[2], 10);
+        if (Date.now() - issueTime < 864e5) {
+          return {
+            token,
+            userId: user.id,
+            role: user.role,
+            expiresAt: issueTime + 864e5
+          };
+        }
+      }
+    }
+    return null;
+  }
+};
+
+// src/auth/LocalAccountProvider.ts
+import { promises as fs } from "fs";
+import path from "path";
+var LocalAccountProvider = class extends BaseAccountProvider {
+  filePath;
+  users = /* @__PURE__ */ new Map();
+  isLoaded = false;
+  constructor(filePath = ".skipo/accounts.json") {
+    super();
+    this.filePath = path.resolve(filePath);
+  }
+  async load() {
+    if (this.isLoaded) return;
+    try {
+      await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+      const data = await fs.readFile(this.filePath, "utf-8");
+      const parsed = JSON.parse(data);
+      for (const [id, user] of Object.entries(parsed)) {
+        this.users.set(id, user);
+      }
+    } catch (e) {
+      if (e.code !== "ENOENT") {
+        throw e;
+      }
+    }
+    this.isLoaded = true;
+  }
+  async persist() {
+    const data = Object.fromEntries(this.users);
+    await fs.writeFile(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+  }
+  async findUserByEmail(email) {
+    await this.load();
+    for (const user of this.users.values()) {
+      if (user.email === email) return user;
+    }
+    return null;
+  }
+  async findUserById(id) {
+    await this.load();
+    return this.users.get(id) || null;
+  }
+  async createUser(data) {
+    await this.load();
+    const isFirst = this.users.size === 0;
+    const user = {
+      id: `usr_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`,
+      email: data.email,
+      passwordHash: data.passwordHash,
+      role: isFirst ? "admin" : data.role,
+      displayName: data.displayName,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    this.users.set(user.id, user);
+    await this.persist();
+    return user;
+  }
+  async updateUser(id, data) {
+    await this.load();
+    const user = this.users.get(id);
+    if (!user) throw new Error("User not found");
+    const updated = { ...user, ...data, updatedAt: Date.now() };
+    this.users.set(id, updated);
+    await this.persist();
+    return updated;
+  }
+  async listUsers() {
+    await this.load();
+    return Array.from(this.users.values());
+  }
+};
+
+// src/auth/AdminGuard.ts
+import { SkipoBase as SkipoBase2 } from "@ultrst-armada/kloks/functions";
+var AdminGuard = class _AdminGuard extends SkipoBase2 {
+  static async verify(authHeaderOrToken, provider) {
+    const session = await _AdminGuard.verifyUser(authHeaderOrToken, provider);
+    if (session.role !== "admin") {
+      throw new Error("Forbidden: Admin access required.");
+    }
+    return session;
+  }
+  static async verifyUser(authHeaderOrToken, provider) {
+    const token = authHeaderOrToken?.startsWith("Bearer ") ? authHeaderOrToken.substring(7).trim() : authHeaderOrToken?.trim() || null;
+    const session = await provider.verifySession(token);
+    if (!session) {
+      throw new Error("Unauthorized: Invalid or missing session token.");
+    }
+    return session;
+  }
+};
+
+// src/auth/UnifiedAuthCore.ts
+import bcrypt2 from "bcryptjs";
+async function loginSystemUser(email, rawPass, isAdmin, queryDb) {
+  const normEmail = (email || "").trim().toLowerCase();
+  const password = (rawPass || "").trim();
+  if (!normEmail || !password) {
+    return { success: false, status: 400, error: "Email and password are required" };
+  }
+  try {
+    if (isAdmin) {
+      const credRes = await queryDb(`SELECT * FROM "ultrst-credentials" WHERE id = 'system' LIMIT 1`, []);
+      if (credRes.rows.length > 0) {
+        const cred = credRes.rows[0];
+        const matchEmail = (cred.admin_email || "").toLowerCase() === normEmail;
+        const matchPass = cred.admin_password === password || cred.admin_password && bcrypt2.compareSync(password, cred.admin_password);
+        if (matchEmail && matchPass) {
+          return {
+            success: true,
+            status: 200,
+            token: `adm_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+            user: { id: "admin_sys", email: cred.admin_email, username: "System Admin", name: "System Admin", role: "admin", status: "ACTIVE" }
+          };
+        }
+      }
+    }
+    const uRes = await queryDb(`SELECT * FROM "ultrst-users" WHERE LOWER(email) = $1 LIMIT 1`, [normEmail]);
+    if (uRes.rows.length === 0) {
+      return { success: false, status: 401, error: "Invalid email or password" };
+    }
+    const user = uRes.rows[0];
+    const hash = user.password_hash || "";
+    let isMatch = false;
+    if (hash.startsWith("$2a$") || hash.startsWith("$2b$")) {
+      isMatch = bcrypt2.compareSync(password, hash);
+    } else {
+      isMatch = hash === password;
+    }
+    if (!isMatch) {
+      return { success: false, status: 401, error: "Invalid email or password" };
+    }
+    if (isAdmin && user.role !== "admin") {
+      return { success: false, status: 403, error: "Insufficient administrative privileges" };
+    }
+    return {
+      success: true,
+      status: 200,
+      token: `usr_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+      user: {
+        id: user.id,
+        email: user.email,
+        username: user.username || user.name || user.email.split("@")[0],
+        name: user.name || user.username || "Ecosystem User",
+        role: user.role || "user",
+        status: user.status || "ACTIVE",
+        appProfiles: typeof user.app_profiles === "string" ? JSON.parse(user.app_profiles) : user.app_profiles || {}
+      }
+    };
+  } catch (err) {
+    return { success: false, status: 500, error: err.message };
+  }
+}
+async function resolveUserFromToken(tokenOrUserId, queryDb) {
+  if (!tokenOrUserId) return null;
+  let targetId = tokenOrUserId;
+  if (targetId.startsWith("Bearer ")) targetId = targetId.slice(7).trim();
+  if (targetId.startsWith("sess::")) {
+    const parts = targetId.split("::");
+    if (parts[1]) targetId = parts[1];
+  }
+  const res = await queryDb(`SELECT * FROM "ultrst-users" WHERE id = $1 OR LOWER(email) = LOWER($1) LIMIT 1`, [targetId]);
+  if (res.rows.length === 0) return null;
+  const u = res.rows[0];
+  return {
+    id: u.id,
+    email: u.email,
+    username: u.username || u.name || u.email.split("@")[0],
+    name: u.name || u.username || "Ecosystem User",
+    role: u.role || "user",
+    status: u.status || "ACTIVE",
+    appProfiles: typeof u.app_profiles === "string" ? JSON.parse(u.app_profiles) : u.app_profiles || {}
+  };
+}
+
+export {
+  PasswordHasher,
+  BaseAccountProvider,
+  LocalAccountProvider,
+  AdminGuard,
+  loginSystemUser,
+  resolveUserFromToken
+};

package/packages/backend/dist/chunk-53WQNION.js

@@ -0,0 +1,278 @@
+import {
+  createService,
+  createServiceDefinition
+} from "./chunk-KPUGS64G.js";
+import {
+  formatCanonicalWorkspaceFolderName,
+  sanitizeWorkspaceName
+} from "./chunk-FZKBTF34.js";
+import {
+  StorageAdapterFactory
+} from "./chunk-J2J24JVC.js";
+import {
+  RateLimiter,
+  SessionManager
+} from "./chunk-25Y7AVTP.js";
+import {
+  ExecutableBackendFacade,
+  WorkerExecutionBoundary
+} from "./chunk-QGHDJGYS.js";
+
+// src/krnl-services.ts
+var AuthServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.auth",
+  name: "AuthService",
+  version: "1.0.0",
+  state: {
+    initial: { activeSessions: 0 }
+  },
+  operations: {
+    createSession: {
+      id: "AuthService.createSession",
+      name: "createSession",
+      handler: async (input) => {
+        const sm = new SessionManager();
+        return sm.createSession(input.userId, input.role ?? "user");
+      }
+    },
+    checkRateLimit: {
+      id: "AuthService.checkRateLimit",
+      name: "checkRateLimit",
+      handler: async (input) => {
+        const limiter = new RateLimiter(input.windowMs ?? 6e4, input.maxRequests ?? 60);
+        limiter.check(input.key);
+        return { allowed: true, key: input.key };
+      }
+    }
+  }
+});
+var authServiceInstance = createService(AuthServiceDefinition);
+var AuthServiceFacade = {
+  id: AuthServiceDefinition.id,
+  name: AuthServiceDefinition.name,
+  version: AuthServiceDefinition.version,
+  runtime: "server",
+  deployment: "local",
+  definition: AuthServiceDefinition,
+  createInstance: () => createService(AuthServiceDefinition),
+  execute: async (op, input) => {
+    await authServiceInstance.start();
+    return authServiceInstance.call(op, input);
+  }
+};
+var StorageServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.storage",
+  name: "StorageService",
+  version: "1.0.0",
+  operations: {
+    resolveAdapterType: {
+      id: "StorageService.resolveAdapterType",
+      name: "resolveAdapterType",
+      handler: async (input) => {
+        const normalized = input.provider === "local" ? "local_fs" : input.provider;
+        if (normalized === "local_fs") {
+          const adapter = StorageAdapterFactory.create({
+            provider: "local_fs",
+            basePath: input.basePath ?? "/tmp/kloks-storage"
+          });
+          return { provider: "local", initialized: Boolean(adapter) };
+        }
+        return { provider: input.provider, initialized: true };
+      }
+    }
+  }
+});
+var storageServiceInstance = createService(StorageServiceDefinition);
+var StorageServiceFacade = {
+  id: StorageServiceDefinition.id,
+  name: StorageServiceDefinition.name,
+  version: StorageServiceDefinition.version,
+  runtime: "server",
+  deployment: "local",
+  definition: StorageServiceDefinition,
+  createInstance: () => createService(StorageServiceDefinition),
+  execute: async (op, input) => {
+    await storageServiceInstance.start();
+    return storageServiceInstance.call(op, input);
+  }
+};
+var WorkspaceServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.workspace",
+  name: "WorkspaceService",
+  version: "1.0.0",
+  operations: {
+    validateWorkspaceConfig: {
+      id: "WorkspaceService.validateWorkspaceConfig",
+      name: "validateWorkspaceConfig",
+      handler: async (input) => {
+        const sanitized = sanitizeWorkspaceName(input.name);
+        const folderName = formatCanonicalWorkspaceFolderName(
+          input.appName ?? "app",
+          input.userName ?? "user",
+          sanitized
+        );
+        return {
+          valid: Boolean(input.id && sanitized),
+          workspaceId: input.id,
+          name: sanitized,
+          folderName,
+          storageType: input.storageType ?? "local"
+        };
+      }
+    }
+  }
+});
+var workspaceServiceInstance = createService(WorkspaceServiceDefinition);
+var WorkspaceServiceFacade = {
+  id: WorkspaceServiceDefinition.id,
+  name: WorkspaceServiceDefinition.name,
+  version: WorkspaceServiceDefinition.version,
+  runtime: "server",
+  deployment: "local",
+  definition: WorkspaceServiceDefinition,
+  createInstance: () => createService(WorkspaceServiceDefinition),
+  execute: async (op, input) => {
+    await workspaceServiceInstance.start();
+    return workspaceServiceInstance.call(op, input);
+  }
+};
+var ControlPlaneServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.controlPlane",
+  name: "ControlPlaneService",
+  version: "1.0.0",
+  operations: {
+    status: {
+      id: "ControlPlaneService.status",
+      name: "status",
+      handler: async () => ({
+        healthy: true,
+        timestamp: Date.now()
+      })
+    }
+  }
+});
+var controlPlaneServiceInstance = createService(ControlPlaneServiceDefinition);
+var ControlPlaneServiceFacade = {
+  id: ControlPlaneServiceDefinition.id,
+  name: ControlPlaneServiceDefinition.name,
+  version: ControlPlaneServiceDefinition.version,
+  runtime: "server",
+  deployment: "local",
+  definition: ControlPlaneServiceDefinition,
+  createInstance: () => createService(ControlPlaneServiceDefinition),
+  execute: async (op, input) => {
+    await controlPlaneServiceInstance.start();
+    return controlPlaneServiceInstance.call(op, input);
+  }
+};
+var ExecutionServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.execution",
+  name: "ExecutionService",
+  version: "1.0.0",
+  operations: {
+    createWorkerBoundary: {
+      id: "ExecutionService.createWorkerBoundary",
+      name: "createWorkerBoundary",
+      handler: async (input) => {
+        const facade = new ExecutableBackendFacade(input.name);
+        const worker = new WorkerExecutionBoundary(`${input.name}Worker`, facade);
+        return {
+          facadeName: facade.name,
+          workerReady: Boolean(worker)
+        };
+      }
+    }
+  }
+});
+var executionServiceInstance = createService(ExecutionServiceDefinition);
+var ExecutionServiceFacade = {
+  id: ExecutionServiceDefinition.id,
+  name: ExecutionServiceDefinition.name,
+  version: ExecutionServiceDefinition.version,
+  runtime: "server",
+  deployment: "local",
+  definition: ExecutionServiceDefinition,
+  createInstance: () => createService(ExecutionServiceDefinition),
+  execute: async (op, input) => {
+    await executionServiceInstance.start();
+    return executionServiceInstance.call(op, input);
+  }
+};
+var DatabaseServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.database",
+  name: "DatabaseService",
+  version: "1.0.0",
+  operations: {
+    query: {
+      id: "DatabaseService.query",
+      name: "query",
+      handler: async (input) => {
+        return { rows: [], sql: input.sql, executedAt: Date.now() };
+      }
+    },
+    isHealthy: {
+      id: "DatabaseService.isHealthy",
+      name: "isHealthy",
+      handler: async () => ({ healthy: true })
+    }
+  }
+});
+var databaseServiceInstance = createService(DatabaseServiceDefinition);
+var DatabaseServiceFacade = {
+  id: DatabaseServiceDefinition.id,
+  name: DatabaseServiceDefinition.name,
+  version: DatabaseServiceDefinition.version,
+  runtime: "server",
+  deployment: "local",
+  definition: DatabaseServiceDefinition,
+  createInstance: () => createService(DatabaseServiceDefinition),
+  execute: async (op, input) => {
+    await databaseServiceInstance.start();
+    return databaseServiceInstance.call(op, input);
+  }
+};
+var GeminiServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.gemini",
+  name: "GeminiService",
+  version: "1.0.0",
+  operations: {
+    generateText: {
+      id: "GeminiService.generateText",
+      name: "generateText",
+      handler: async (input) => {
+        return { text: `[GeminiResponse] Generated response for: ${input.prompt}`, model: input.model ?? "gemini-2.5-flash", timestamp: Date.now() };
+      }
+    }
+  }
+});
+var geminiServiceInstance = createService(GeminiServiceDefinition);
+var GeminiServiceFacade = {
+  id: GeminiServiceDefinition.id,
+  name: GeminiServiceDefinition.name,
+  version: GeminiServiceDefinition.version,
+  runtime: "server",
+  deployment: "remote",
+  definition: GeminiServiceDefinition,
+  createInstance: () => createService(GeminiServiceDefinition),
+  execute: async (op, input) => {
+    await geminiServiceInstance.start();
+    return geminiServiceInstance.call(op, input);
+  }
+};
+
+export {
+  AuthServiceDefinition,
+  AuthServiceFacade,
+  StorageServiceDefinition,
+  StorageServiceFacade,
+  WorkspaceServiceDefinition,
+  WorkspaceServiceFacade,
+  ControlPlaneServiceDefinition,
+  ControlPlaneServiceFacade,
+  ExecutionServiceDefinition,
+  ExecutionServiceFacade,
+  DatabaseServiceDefinition,
+  DatabaseServiceFacade,
+  GeminiServiceDefinition,
+  GeminiServiceFacade
+};