@objectstack/cloud-connection 9.3.0

package/dist/index.cjs

@@ -0,0 +1,1833 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CLOUD_CONNECTION_UI_BUNDLE: () => CLOUD_CONNECTION_UI_BUNDLE,
+  CloudConnectionPlugin: () => CloudConnectionPlugin,
+  CloudConnectionSettingsPage: () => CloudConnectionSettingsPage,
+  ConnectionCredentialStore: () => ConnectionCredentialStore,
+  DEFAULT_CLOUD_URL: () => DEFAULT_CLOUD_URL,
+  DEFAULT_CONNECTION_CREDENTIAL_PATH: () => DEFAULT_CONNECTION_CREDENTIAL_PATH,
+  DEFAULT_INSTALLED_PACKAGES_DIR: () => DEFAULT_INSTALLED_PACKAGES_DIR,
+  LocalManifestSource: () => LocalManifestSource,
+  MARKETPLACE_BROWSE_UI_BUNDLE: () => MARKETPLACE_BROWSE_UI_BUNDLE,
+  MARKETPLACE_INSTALLED_UI_BUNDLE: () => MARKETPLACE_INSTALLED_UI_BUNDLE,
+  MarketplaceInstallLocalPlugin: () => MarketplaceInstallLocalPlugin,
+  MarketplaceProxyPlugin: () => MarketplaceProxyPlugin,
+  RuntimeConfigPlugin: () => RuntimeConfigPlugin,
+  createCloudConnectionPlugin: () => createCloudConnectionPlugin,
+  publicMarketplaceKeyForApiPath: () => publicMarketplaceKeyForApiPath,
+  resolveCloudUrl: () => resolveCloudUrl,
+  resolveMarketplacePublicBaseUrl: () => resolveMarketplacePublicBaseUrl
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/cloud-url.ts
+var DEFAULT_CLOUD_URL = "https://cloud.objectos.ai";
+function resolveCloudUrl(explicit) {
+  const raw = (explicit ?? process.env.OS_CLOUD_URL ?? "").trim();
+  const lower = raw.toLowerCase();
+  if (lower === "off" || lower === "none" || lower === "local" || lower === "disabled") {
+    return "";
+  }
+  const picked = raw || DEFAULT_CLOUD_URL;
+  return picked.replace(/\/+$/, "");
+}
+
+// src/marketplace-public-url.ts
+function resolveMarketplacePublicBaseUrl(explicit) {
+  const raw = (explicit ?? process.env.OS_MARKETPLACE_PUBLIC_BASE_URL ?? "").trim();
+  const lower = raw.toLowerCase();
+  if (!raw || lower === "off" || lower === "none" || lower === "disabled" || lower === "false") {
+    return "";
+  }
+  return raw.replace(/\/+$/, "");
+}
+function publicMarketplaceKeyForApiPath(pathname) {
+  const prefix = "/api/v1/marketplace/packages";
+  if (pathname === prefix) return "packages.json";
+  if (!pathname.startsWith(`${prefix}/`)) return null;
+  const tail = pathname.slice(prefix.length + 1);
+  if (!tail) return null;
+  const parts = tail.split("/");
+  if (parts.length === 1) {
+    const id = decodeURIComponent(parts[0] ?? "");
+    if (!id) return null;
+    return `packages/${encodeURIComponent(id)}.json`;
+  }
+  if (parts.length === 4 && parts[1] === "versions" && parts[3] === "manifest") {
+    const id = decodeURIComponent(parts[0] ?? "");
+    const versionId = decodeURIComponent(parts[2] ?? "");
+    if (!id || !versionId) return null;
+    return `packages/${encodeURIComponent(id)}/versions/${encodeURIComponent(versionId)}/manifest.json`;
+  }
+  return null;
+}
+
+// src/marketplace-ui.ts
+var MARKETPLACE_BROWSE_UI_BUNDLE = {
+  id: "com.objectstack.cloud-connection.marketplace-browse-ui",
+  namespace: "sys",
+  version: "0.1.0",
+  type: "plugin",
+  scope: "system",
+  name: "Marketplace Browse UI",
+  description: "Setup navigation for the public marketplace catalog (browse).",
+  navigationContributions: [
+    {
+      app: "setup",
+      group: "group_apps",
+      priority: 100,
+      items: [
+        { id: "nav_marketplace_browse", type: "url", label: "Browse Marketplace", url: "/apps/setup/system/marketplace", icon: "store" }
+      ]
+    }
+  ]
+};
+var MarketplaceInstalledPage = {
+  name: "marketplace_installed",
+  label: "Installed Apps",
+  type: "app",
+  template: "default",
+  kind: "full",
+  isDefault: false,
+  regions: [
+    {
+      name: "header",
+      width: "full",
+      components: [
+        {
+          type: "page:header",
+          properties: {
+            title: "Installed Apps",
+            subtitle: "Marketplace packages currently installed into this runtime's kernel.",
+            icon: "package-check"
+          }
+        }
+      ]
+    },
+    {
+      name: "main",
+      width: "large",
+      components: [
+        { type: "marketplace:installed-list", properties: {} }
+      ]
+    }
+  ]
+};
+var MARKETPLACE_INSTALLED_UI_BUNDLE = {
+  id: "com.objectstack.cloud-connection.marketplace-installed-ui",
+  namespace: "sys",
+  version: "0.2.0",
+  type: "plugin",
+  scope: "system",
+  name: "Marketplace Installed UI",
+  description: "Installed Apps page + Setup navigation for locally-installed marketplace packages.",
+  pages: [MarketplaceInstalledPage],
+  navigationContributions: [
+    {
+      app: "setup",
+      group: "group_apps",
+      priority: 110,
+      items: [
+        { id: "nav_marketplace_installed", type: "page", pageName: "marketplace_installed", label: "Installed Apps", icon: "package-check" }
+      ]
+    }
+  ]
+};
+
+// src/marketplace-proxy-plugin.ts
+var MARKETPLACE_PREFIX = "/api/v1/marketplace";
+var DEFAULT_LRU_MAX = 200;
+var LIST_TTL_MS = 30 * 60 * 1e3;
+var PACKAGE_TTL_MS = 2 * 60 * 60 * 1e3;
+var VERSION_TTL_MS = 24 * 60 * 60 * 1e3;
+function ttlForPath(pathname) {
+  if (/\/packages\/[^/]+\/versions\//.test(pathname)) return VERSION_TTL_MS;
+  if (/\/packages\/[^/]+/.test(pathname)) return PACKAGE_TTL_MS;
+  return LIST_TTL_MS;
+}
+var LruTtlCache = class {
+  constructor(max) {
+    this.max = max;
+    this.map = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    const entry = this.map.get(key);
+    if (!entry) return void 0;
+    this.map.delete(key);
+    this.map.set(key, entry);
+    return entry;
+  }
+  set(key, entry) {
+    if (this.map.has(key)) this.map.delete(key);
+    this.map.set(key, entry);
+    while (this.map.size > this.max) {
+      const oldest = this.map.keys().next().value;
+      if (oldest === void 0) break;
+      this.map.delete(oldest);
+    }
+  }
+  clear() {
+    this.map.clear();
+  }
+};
+var MarketplaceProxyPlugin = class _MarketplaceProxyPlugin {
+  constructor(config = {}) {
+    this.name = "com.objectstack.runtime.marketplace-proxy";
+    this.version = "1.1.0";
+    this.init = async (_ctx) => {
+    };
+    this.start = async (ctx) => {
+      ctx.hook("kernel:ready", async () => {
+        try {
+          const manifest = ctx.getService("manifest");
+          manifest?.register?.(MARKETPLACE_BROWSE_UI_BUNDLE);
+        } catch {
+        }
+        let httpServer;
+        try {
+          httpServer = ctx.getService("http-server");
+        } catch {
+          ctx.logger?.warn?.("[MarketplaceProxyPlugin] http-server not available \u2014 marketplace routes not mounted");
+          return;
+        }
+        if (!httpServer || typeof httpServer.getRawApp !== "function") {
+          ctx.logger?.warn?.("[MarketplaceProxyPlugin] http-server missing getRawApp() \u2014 marketplace routes not mounted");
+          return;
+        }
+        const rawApp = httpServer.getRawApp();
+        const cloudUrl = this.cloudUrl;
+        const publicBaseUrl = this.publicBaseUrl;
+        const cache = this.cache;
+        if (publicBaseUrl) {
+          ctx.logger?.info?.(`[MarketplaceProxyPlugin] public R2 fast-path enabled \u2192 ${publicBaseUrl}`);
+        }
+        const handler = async (c, next) => {
+          if (!cloudUrl) {
+            return c.json({
+              success: false,
+              error: {
+                code: "marketplace_unavailable",
+                message: "No control-plane URL configured for this runtime (OS_CLOUD_URL)."
+              }
+            }, 503);
+          }
+          try {
+            const incomingUrl = new URL(c.req.url);
+            if (incomingUrl.pathname.startsWith(`${MARKETPLACE_PREFIX}/install-local`)) {
+              return next();
+            }
+            const method = String(c.req.method ?? "GET").toUpperCase();
+            if (publicBaseUrl && (method === "GET" || method === "HEAD")) {
+              const r2Resp = await tryPublicMarketplaceFetch(
+                publicBaseUrl,
+                incomingUrl,
+                method,
+                c.req.header("accept"),
+                ctx.logger
+              );
+              if (r2Resp) return r2Resp;
+            }
+            const target = `${cloudUrl}${incomingUrl.pathname}${incomingUrl.search}`;
+            if (method !== "GET" && method !== "HEAD") {
+              return next();
+            }
+            const accept = c.req.header("accept") ?? "application/json";
+            const acceptLang = c.req.header("accept-language") ?? "";
+            const cacheKey = `${incomingUrl.pathname}${incomingUrl.search}|al=${acceptLang}|a=${accept}`;
+            const reqCacheCtl = (c.req.header("cache-control") ?? "").toLowerCase();
+            const bypass = !cache || reqCacheCtl.includes("no-cache") || reqCacheCtl.includes("no-store");
+            const now = Date.now();
+            if (cache && !bypass) {
+              const hit = cache.get(cacheKey);
+              if (hit && hit.expiresAt > now) {
+                return buildCachedResponse(hit, method, "HIT");
+              }
+              if (hit) {
+                const revalHeaders = {
+                  "Accept": accept,
+                  "User-Agent": `objectos-marketplace-proxy/${_MarketplaceProxyPlugin.prototype.version ?? "1.0.0"}`
+                };
+                if (acceptLang) revalHeaders["Accept-Language"] = acceptLang;
+                if (hit.etag) revalHeaders["If-None-Match"] = hit.etag;
+                if (hit.lastModified) revalHeaders["If-Modified-Since"] = hit.lastModified;
+                const revalResp = await fetch(target, { method: "GET", headers: revalHeaders });
+                if (revalResp.status === 304) {
+                  hit.expiresAt = now + hit.ttlMs;
+                  const newEtag = revalResp.headers.get("etag");
+                  const newLm = revalResp.headers.get("last-modified");
+                  if (newEtag) hit.etag = newEtag;
+                  if (newLm) hit.lastModified = newLm;
+                  cache.set(cacheKey, hit);
+                  return buildCachedResponse(hit, method, "REVALIDATED");
+                }
+                return await consumeAndMaybeCache(revalResp, cacheKey, incomingUrl.pathname, method, cache);
+              }
+            }
+            const reqHeaders = {
+              // Strip the inbound Host header — fetch will set
+              // it to the cloud host. Forward only the
+              // identifying headers cloud might log.
+              "Accept": accept,
+              "User-Agent": `objectos-marketplace-proxy/${_MarketplaceProxyPlugin.prototype.version ?? "1.0.0"}`
+            };
+            if (acceptLang) reqHeaders["Accept-Language"] = acceptLang;
+            const resp = await fetch(target, { method: "GET", headers: reqHeaders });
+            if (bypass || !cache) {
+              return await passthroughResponse(resp, method, bypass ? "BYPASS" : "MISS");
+            }
+            return await consumeAndMaybeCache(resp, cacheKey, incomingUrl.pathname, method, cache);
+          } catch (err) {
+            const errObj = err instanceof Error ? err : new Error(err?.message ?? String(err));
+            ctx.logger?.error?.("[MarketplaceProxyPlugin] proxy failed", errObj);
+            return c.json({
+              success: false,
+              error: {
+                code: "marketplace_proxy_failed",
+                message: err?.message ?? String(err)
+              }
+            }, 502);
+          }
+        };
+        if (typeof rawApp.all === "function") {
+          rawApp.all(`${MARKETPLACE_PREFIX}/*`, handler);
+        } else {
+          for (const m of ["get", "head"]) {
+            try {
+              rawApp[m]?.(`${MARKETPLACE_PREFIX}/*`, handler);
+            } catch {
+            }
+          }
+        }
+        ctx.logger?.info?.(`[MarketplaceProxyPlugin] mounted at ${MARKETPLACE_PREFIX}/* \u2192 ${cloudUrl || "(unconfigured)"} (cache=${this.cache ? "on" : "off"})`);
+      });
+    };
+    this.cloudUrl = resolveCloudUrl(config.controlPlaneUrl);
+    this.publicBaseUrl = resolveMarketplacePublicBaseUrl(config.publicMarketplaceBaseUrl);
+    const envFlag = (process.env.OS_MARKETPLACE_CACHE ?? "").trim().toLowerCase();
+    const envDisabled = ["off", "false", "0", "no", "disable", "disabled"].includes(envFlag);
+    const disabled = config.cacheDisabled ?? envDisabled;
+    this.cache = disabled ? null : new LruTtlCache(Math.max(8, config.cacheMaxEntries ?? DEFAULT_LRU_MAX));
+  }
+};
+async function tryPublicMarketplaceFetch(publicBaseUrl, incomingUrl, method, acceptHeader, logger) {
+  const key = publicMarketplaceKeyForApiPath(incomingUrl.pathname);
+  if (!key) return null;
+  const target = `${publicBaseUrl}/${key}`;
+  let resp;
+  try {
+    resp = await fetch(target, {
+      method: "GET",
+      headers: {
+        "Accept": acceptHeader || "application/json",
+        "User-Agent": `objectos-marketplace-proxy/public-r2`
+      }
+    });
+  } catch (err) {
+    logger?.warn?.(`[MarketplaceProxyPlugin] public R2 fetch failed (${target}): ${err?.message ?? err}`);
+    return null;
+  }
+  if (resp.status === 404) return null;
+  if (!resp.ok) {
+    logger?.warn?.(`[MarketplaceProxyPlugin] public R2 ${target} returned ${resp.status} \u2014 falling back to cloud`);
+    return null;
+  }
+  const isList = key === "packages.json";
+  const hasFilters = isList && (incomingUrl.searchParams.has("q") || incomingUrl.searchParams.has("category") || incomingUrl.searchParams.has("limit") || incomingUrl.searchParams.has("offset"));
+  if (!hasFilters) {
+    const headers2 = new Headers();
+    const ct = resp.headers.get("content-type") ?? "application/json; charset=utf-8";
+    headers2.set("content-type", ct);
+    const cc = resp.headers.get("cache-control");
+    if (cc) headers2.set("cache-control", cc);
+    const etag = resp.headers.get("etag");
+    if (etag) headers2.set("etag", etag);
+    headers2.set("x-cache", "PUBLIC-R2");
+    const body2 = method === "HEAD" ? null : resp.body;
+    return new Response(body2, { status: 200, headers: headers2 });
+  }
+  let snapshot;
+  try {
+    snapshot = await resp.json();
+  } catch (err) {
+    logger?.warn?.(`[MarketplaceProxyPlugin] public R2 list snapshot parse failed: ${err?.message ?? err}`);
+    return null;
+  }
+  const items = Array.isArray(snapshot?.data?.items) ? snapshot.data.items : [];
+  const q = (incomingUrl.searchParams.get("q") ?? "").trim().toLowerCase();
+  const category = (incomingUrl.searchParams.get("category") ?? "").trim();
+  const limit = Math.min(Math.max(Number(incomingUrl.searchParams.get("limit") ?? 50), 1), 100);
+  const offset = Math.max(Number(incomingUrl.searchParams.get("offset") ?? 0), 0);
+  let filtered = items;
+  if (q) {
+    filtered = filtered.filter((r) => {
+      const dn = String(r?.display_name ?? "").toLowerCase();
+      const mid = String(r?.manifest_id ?? "").toLowerCase();
+      return dn.includes(q) || mid.includes(q);
+    });
+  }
+  if (category) {
+    filtered = filtered.filter((r) => String(r?.category ?? "") === category);
+  }
+  const total = filtered.length;
+  const page = filtered.slice(offset, offset + limit);
+  const body = JSON.stringify({ success: true, data: { items: page, total, limit, offset } });
+  const headers = new Headers({
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "public, max-age=30",
+    "x-cache": "PUBLIC-R2-FILTERED"
+  });
+  return new Response(method === "HEAD" ? null : body, { status: 200, headers });
+}
+var PASSTHROUGH_HEADERS = ["content-type", "cache-control", "etag", "last-modified", "vary"];
+function collectHeaders(src) {
+  const out = {};
+  for (const h of PASSTHROUGH_HEADERS) {
+    const v = src.headers.get(h);
+    if (v) out[h] = v;
+  }
+  return out;
+}
+function buildCachedResponse(entry, method, xCache) {
+  const headers = new Headers(entry.headers);
+  headers.set("X-Cache", xCache);
+  const ageSec = Math.max(0, Math.floor((entry.expiresAt - entry.ttlMs - Date.now()) / -1e3));
+  headers.set("Age", String(Math.max(0, ageSec)));
+  const body = method === "HEAD" ? null : entry.body;
+  return new Response(body, { status: entry.status, headers });
+}
+async function passthroughResponse(resp, method, xCache) {
+  const headers = new Headers(collectHeaders(resp));
+  headers.set("X-Cache", xCache);
+  if (method === "HEAD") {
+    try {
+      await resp.arrayBuffer();
+    } catch {
+    }
+    return new Response(null, { status: resp.status, headers });
+  }
+  const body = await resp.arrayBuffer();
+  return new Response(body, { status: resp.status, headers });
+}
+async function consumeAndMaybeCache(resp, key, pathname, method, cache) {
+  const body = await resp.arrayBuffer();
+  const headers = collectHeaders(resp);
+  if (resp.status >= 200 && resp.status < 300) {
+    const ttlMs = ttlForPath(pathname);
+    const entry = {
+      status: resp.status,
+      body,
+      headers,
+      etag: resp.headers.get("etag") ?? void 0,
+      lastModified: resp.headers.get("last-modified") ?? void 0,
+      expiresAt: Date.now() + ttlMs,
+      ttlMs
+    };
+    cache.set(key, entry);
+  }
+  const respHeaders = new Headers(headers);
+  respHeaders.set("X-Cache", "MISS");
+  const outBody = method === "HEAD" ? null : body;
+  return new Response(outBody, { status: resp.status, headers: respHeaders });
+}
+
+// src/marketplace-install-local-plugin.ts
+var import_types = require("@objectstack/types");
+
+// src/local-manifest-source.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var DEFAULT_INSTALLED_PACKAGES_DIR = ".objectstack/installed-packages";
+function safeFilename(manifestId) {
+  return manifestId.replace(/[^a-zA-Z0-9._-]/g, "_") + ".json";
+}
+var LocalManifestSource = class {
+  constructor(storageDir) {
+    this.dir = storageDir ? (0, import_node_path.resolve)(storageDir) : (0, import_node_path.resolve)(process.cwd(), DEFAULT_INSTALLED_PACKAGES_DIR);
+  }
+  /** Every valid entry in the ledger (corrupt files are skipped). */
+  list() {
+    if (!(0, import_node_fs.existsSync)(this.dir)) return [];
+    const out = [];
+    for (const name of (0, import_node_fs.readdirSync)(this.dir)) {
+      if (!name.endsWith(".json")) continue;
+      try {
+        const raw = (0, import_node_fs.readFileSync)((0, import_node_path.join)(this.dir, name), "utf8");
+        out.push(JSON.parse(raw));
+      } catch {
+      }
+    }
+    return out;
+  }
+  /** Read one entry; null when absent or unreadable. */
+  read(manifestId) {
+    const file = this.fileFor(manifestId);
+    if (!(0, import_node_fs.existsSync)(file)) return null;
+    try {
+      return JSON.parse((0, import_node_fs.readFileSync)(file, "utf8"));
+    } catch {
+      return null;
+    }
+  }
+  /** Whether the ledger holds an entry for this manifest id. */
+  has(manifestId) {
+    return (0, import_node_fs.existsSync)(this.fileFor(manifestId));
+  }
+  /** Create or replace an entry (upsert by manifestId). */
+  write(entry) {
+    (0, import_node_fs.mkdirSync)(this.dir, { recursive: true });
+    (0, import_node_fs.writeFileSync)(this.fileFor(entry.manifestId), JSON.stringify(entry, null, 2), "utf8");
+  }
+  /** Remove an entry. Returns false when it was not present. */
+  remove(manifestId) {
+    const file = this.fileFor(manifestId);
+    if (!(0, import_node_fs.existsSync)(file)) return false;
+    (0, import_node_fs.unlinkSync)(file);
+    return true;
+  }
+  fileFor(manifestId) {
+    return (0, import_node_path.join)(this.dir, safeFilename(manifestId));
+  }
+};
+
+// src/connection-credential-store.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var DEFAULT_CONNECTION_CREDENTIAL_PATH = ".objectstack/cloud-connection.json";
+var ConnectionCredentialStore = class {
+  constructor(path) {
+    this.path = path ? (0, import_node_path2.resolve)(path) : (0, import_node_path2.resolve)(process.cwd(), DEFAULT_CONNECTION_CREDENTIAL_PATH);
+  }
+  /**
+   * Read the stored credential; null when absent or unreadable.
+   *
+   * An IDENTITY RESIDUAL — `runtimeToken: ''` with a `runtimeId` — is a
+   * valid record: unbind leaves one behind so a later re-bind to the same
+   * org claims the same registration (ADR runtime-identity-binding §2.1).
+   * Callers already treat the empty token as "no credential".
+   */
+  read() {
+    if (!(0, import_node_fs2.existsSync)(this.path)) return null;
+    try {
+      const parsed = JSON.parse((0, import_node_fs2.readFileSync)(this.path, "utf8"));
+      if (!parsed || typeof parsed.runtimeToken !== "string") return null;
+      if (!parsed.runtimeToken && !(typeof parsed.runtimeId === "string" && parsed.runtimeId)) return null;
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  /** Persist (replace) the credential. Written 0600 — it is a secret. */
+  write(credential) {
+    (0, import_node_fs2.mkdirSync)((0, import_node_path2.dirname)(this.path), { recursive: true });
+    (0, import_node_fs2.writeFileSync)(this.path, JSON.stringify(credential, null, 2), { encoding: "utf8", mode: 384 });
+  }
+  /** Remove the credential (unbind). Returns false when nothing was stored. */
+  clear() {
+    if (!(0, import_node_fs2.existsSync)(this.path)) return false;
+    (0, import_node_fs2.unlinkSync)(this.path);
+    return true;
+  }
+};
+
+// src/marketplace-install-local-plugin.ts
+var ROUTE_BASE = "/api/v1/marketplace/install-local";
+var MarketplaceInstallLocalPlugin = class {
+  constructor(config = {}) {
+    this.name = "com.objectstack.runtime.marketplace-install-local";
+    this.version = "1.0.0";
+    this.init = async (_ctx) => {
+    };
+    this.start = async (ctx) => {
+      ctx.hook("kernel:ready", async () => {
+        try {
+          const manifest = ctx.getService("manifest");
+          manifest?.register?.(MARKETPLACE_INSTALLED_UI_BUNDLE);
+        } catch {
+        }
+        await this.rehydrate(ctx);
+        let httpServer;
+        try {
+          httpServer = ctx.getService("http-server");
+        } catch {
+          ctx.logger?.warn?.("[MarketplaceInstallLocal] http-server not available \u2014 install endpoints not mounted");
+          return;
+        }
+        if (!httpServer || typeof httpServer.getRawApp !== "function") {
+          ctx.logger?.warn?.("[MarketplaceInstallLocal] http-server missing getRawApp() \u2014 install endpoints not mounted");
+          return;
+        }
+        const rawApp = httpServer.getRawApp();
+        const postHandler = async (c) => this.handleInstall(c, ctx);
+        const getHandler = async (c) => this.handleList(c);
+        const deleteHandler = async (c) => this.handleUninstall(c, ctx);
+        const reseedHandler = async (c) => this.handleReseed(c, ctx);
+        const purgeHandler = async (c) => this.handlePurge(c, ctx);
+        if (typeof rawApp.post === "function") rawApp.post(ROUTE_BASE, postHandler);
+        if (typeof rawApp.get === "function") rawApp.get(ROUTE_BASE, getHandler);
+        if (typeof rawApp.delete === "function") rawApp.delete(`${ROUTE_BASE}/:manifestId`, deleteHandler);
+        if (typeof rawApp.post === "function") {
+          rawApp.post(`${ROUTE_BASE}/:manifestId/reseed-sample-data`, reseedHandler);
+          rawApp.post(`${ROUTE_BASE}/:manifestId/purge-sample-data`, purgeHandler);
+        }
+        ctx.logger?.info?.(`[MarketplaceInstallLocal] mounted at ${ROUTE_BASE} (storage: ${this.storageDir})`);
+      });
+    };
+    /**
+     * Re-register every cached manifest with the kernel's manifest service.
+     * Safe to call on a kernel that already has the same manifest_id (the
+     * underlying ObjectQL registry overwrites by id, but we still warn so
+     * a developer can spot the dev-time clash between their config.ts and
+     * a marketplace package).
+     */
+    this.rehydrate = async (ctx) => {
+      const entries = this.readAll();
+      if (entries.length === 0) return;
+      let manifestService = null;
+      try {
+        manifestService = ctx.getService("manifest");
+      } catch {
+        ctx.logger?.warn?.("[MarketplaceInstallLocal] no `manifest` service \u2014 rehydrate skipped");
+        return;
+      }
+      for (const entry of entries) {
+        try {
+          manifestService.register(entry.manifest);
+          try {
+            const ql = ctx.getService("objectql");
+            if (ql && typeof ql.syncSchemas === "function") await ql.syncSchemas();
+          } catch {
+          }
+          await this.applySideEffects(ctx, entry.manifest, { seedNow: false });
+          ctx.logger?.info?.(`[MarketplaceInstallLocal] rehydrated ${entry.manifestId}@${entry.version}`);
+        } catch (err) {
+          ctx.logger?.error?.(`[MarketplaceInstallLocal] rehydrate failed for ${entry.manifestId}`, err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+    };
+    this.handleInstall = async (c, ctx) => {
+      const userId = await this.requireAuthenticatedUser(c, ctx);
+      if (!userId) {
+        return c.json({ success: false, error: { code: "unauthorized", message: "Authentication required to install packages." } }, 401);
+      }
+      let body = {};
+      try {
+        body = await c.req.json();
+      } catch {
+      }
+      const inlineManifest = body?.manifest && typeof body.manifest === "object" ? body.manifest : null;
+      const normalizeBundle = (m) => {
+        if (m && !m.id && !m.name && m.manifest && typeof m.manifest === "object" && (m.manifest.id || m.manifest.name)) {
+          const { manifest: meta, ...sections } = m;
+          return { ...meta, ...sections };
+        }
+        return m;
+      };
+      let manifest;
+      let resolvedVersionId;
+      let version;
+      let packageId;
+      if (inlineManifest) {
+        manifest = normalizeBundle(inlineManifest);
+        packageId = String(manifest.id ?? manifest.name ?? "").trim();
+        version = String(manifest.version ?? "unknown");
+        resolvedVersionId = String(body?.versionId ?? version);
+        if (!packageId) {
+          return c.json({ success: false, error: { code: "invalid_manifest", message: 'Inline manifest must have an "id" or "name".' } }, 400);
+        }
+      } else {
+        if (!this.cloudUrl) {
+          return c.json({ success: false, error: { code: "marketplace_unavailable", message: "OS_CLOUD_URL not configured." } }, 503);
+        }
+        packageId = String(body?.packageId ?? "").trim();
+        const versionId = String(body?.versionId ?? "latest").trim() || "latest";
+        if (!packageId) {
+          return c.json({ success: false, error: { code: "bad_request", message: "packageId is required." } }, 400);
+        }
+        let payload;
+        const publicBase = resolveMarketplacePublicBaseUrl();
+        const fetchAttempts = [];
+        if (publicBase) {
+          fetchAttempts.push({
+            label: "public-r2",
+            url: `${publicBase}/packages/${encodeURIComponent(packageId)}/versions/${encodeURIComponent(versionId)}/manifest.json`
+          });
+        }
+        fetchAttempts.push({
+          label: "cloud",
+          url: `${this.cloudUrl}/api/v1/marketplace/packages/${encodeURIComponent(packageId)}/versions/${encodeURIComponent(versionId)}/manifest`
+        });
+        const cloudCredential = (process.env.OS_CLOUD_API_KEY ?? "").trim() || this.credentials.read()?.runtimeToken || "";
+        let lastErrStatus = 0;
+        let lastErrText = "";
+        for (const attempt of fetchAttempts) {
+          try {
+            const headers = { Accept: "application/json" };
+            if (attempt.label === "cloud" && cloudCredential) headers.Authorization = `Bearer ${cloudCredential}`;
+            const resp = await fetch(attempt.url, { headers });
+            if (!resp.ok) {
+              lastErrStatus = resp.status;
+              lastErrText = (await resp.text().catch(() => "")).slice(0, 200);
+              if (attempt.label === "public-r2" && resp.status === 404) {
+                ctx.logger?.info?.(`[MarketplaceInstallLocal] public-r2 miss for ${packageId}@${versionId}, falling back to cloud`);
+                continue;
+              }
+              if (attempt.label === "public-r2" && resp.status >= 500) {
+                ctx.logger?.warn?.(`[MarketplaceInstallLocal] public-r2 ${resp.status}, falling back to cloud`);
+                continue;
+              }
+              break;
+            }
+            payload = await resp.json();
+            lastErrStatus = 0;
+            break;
+          } catch (err) {
+            if (attempt.label === "public-r2") {
+              ctx.logger?.warn?.(`[MarketplaceInstallLocal] public-r2 fetch error: ${err?.message ?? err}, falling back to cloud`);
+              continue;
+            }
+            return c.json({
+              success: false,
+              error: { code: "cloud_fetch_failed", message: err?.message ?? String(err) }
+            }, 502);
+          }
+        }
+        if (!payload) {
+          return c.json({
+            success: false,
+            error: { code: "cloud_fetch_failed", message: `Cloud returned ${lastErrStatus}: ${lastErrText}` }
+          }, lastErrStatus === 404 ? 404 : 502);
+        }
+        const data = payload?.data ?? payload;
+        manifest = normalizeBundle(data?.manifest);
+        resolvedVersionId = String(data?.version_id ?? versionId);
+        version = String(data?.version ?? "unknown");
+      }
+      const manifestId = String(manifest?.id ?? manifest?.name ?? "");
+      if (!manifest || !manifestId) {
+        return c.json({ success: false, error: { code: "invalid_manifest", message: "Invalid manifest payload." } }, inlineManifest ? 400 : 502);
+      }
+      const conflict = this.findConflict(ctx, manifestId);
+      if (conflict === "user-code") {
+        return c.json({
+          success: false,
+          error: {
+            code: "manifest_conflict",
+            message: `manifest_id "${manifestId}" is already defined by this runtime's local code. Refusing to overwrite. Uninstall the local definition first.`
+          }
+        }, 409);
+      }
+      try {
+        const manifestService = ctx.getService("manifest");
+        manifestService.register(manifest);
+      } catch (err) {
+        if (inlineManifest) {
+          return c.json({
+            success: false,
+            error: { code: "register_failed", message: `Failed to register imported manifest: ${err?.message ?? err}` }
+          }, 422);
+        }
+        ctx.logger?.warn?.(`[MarketplaceInstallLocal] hot-register failed for ${manifestId} (will load on next restart): ${err?.message ?? err}`);
+      }
+      const entry = {
+        packageId,
+        versionId: resolvedVersionId,
+        manifestId,
+        version,
+        manifest,
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        installedBy: userId,
+        withSampleData: false
+      };
+      try {
+        this.ledger.write(entry);
+      } catch (err) {
+        return c.json({
+          success: false,
+          error: { code: "storage_failed", message: `Failed to persist manifest: ${err?.message ?? err}` }
+        }, 500);
+      }
+      try {
+        const ql = ctx.getService("objectql");
+        if (ql && typeof ql.syncSchemas === "function") {
+          await ql.syncSchemas();
+          ctx.logger?.info?.(`[MarketplaceInstallLocal] syncSchemas() ran after registering ${manifestId}`);
+        }
+      } catch (err) {
+        ctx.logger?.warn?.(`[MarketplaceInstallLocal] syncSchemas failed for ${manifestId}: ${err?.message ?? err}`);
+      }
+      const seededSummary = await this.applySideEffects(ctx, manifest, { seedNow: true, c });
+      if (seededSummary.seeded.mode === "inline" && (seededSummary.seeded.inserted ?? 0) + (seededSummary.seeded.updated ?? 0) > 0) {
+        entry.withSampleData = true;
+        try {
+          this.ledger.write(entry);
+        } catch {
+        }
+      }
+      return c.json({
+        success: true,
+        data: {
+          manifestId,
+          version,
+          versionId: resolvedVersionId,
+          installedAt: entry.installedAt,
+          hotLoaded: true,
+          upgradedFrom: conflict === "marketplace" ? "previous-marketplace-version" : null,
+          translationsLoaded: seededSummary.translationsLoaded,
+          seeded: seededSummary.seeded,
+          note: "App is now available in this runtime. Refresh the console to see it in the app switcher."
+        }
+      }, 200);
+    };
+    this.handleList = async (c) => {
+      const entries = this.readAll();
+      return c.json({
+        success: true,
+        data: {
+          items: entries.map((e) => ({
+            packageId: e.packageId,
+            versionId: e.versionId,
+            manifestId: e.manifestId,
+            version: e.version,
+            installedAt: e.installedAt,
+            installedBy: e.installedBy,
+            withSampleData: e.withSampleData ?? false
+          })),
+          total: entries.length,
+          storageDir: this.storageDir
+        }
+      }, 200);
+    };
+    this.handleUninstall = async (c, ctx) => {
+      const userId = await this.requireAuthenticatedUser(c, ctx);
+      if (!userId) {
+        return c.json({ success: false, error: { code: "unauthorized", message: "Authentication required." } }, 401);
+      }
+      const manifestId = String(c.req.param?.("manifestId") ?? c.req.params?.manifestId ?? "").trim();
+      if (!manifestId) {
+        return c.json({ success: false, error: { code: "bad_request", message: "manifestId path param required." } }, 400);
+      }
+      if (!this.ledger.has(manifestId)) {
+        return c.json({ success: false, error: { code: "not_found", message: `No marketplace install for ${manifestId}.` } }, 404);
+      }
+      try {
+        this.ledger.remove(manifestId);
+      } catch (err) {
+        return c.json({ success: false, error: { code: "storage_failed", message: err?.message ?? String(err) } }, 500);
+      }
+      ctx.logger?.info?.(`[MarketplaceInstallLocal] uninstalled ${manifestId} (cached manifest removed; restart runtime to unload from running kernel)`);
+      return c.json({
+        success: true,
+        data: {
+          manifestId,
+          note: "Cached manifest removed. The app remains loaded in the running kernel until the next restart (the kernel API does not support unregistering apps in-place)."
+        }
+      }, 200);
+    };
+    /**
+     * Detect whether `manifestId` is already known to the kernel and classify
+     * the source so we can refuse vs upgrade gracefully.
+     *
+     *   'none'         — fresh install
+     *   'marketplace'  — previously installed by this plugin (allow upgrade)
+     *   'user-code'    — defined by AppPlugin from objectstack.config.ts
+     *                    (refuse to avoid silently overwriting authored code)
+     */
+    this.findConflict = (ctx, manifestId) => {
+      if (this.ledger.has(manifestId)) {
+        return "marketplace";
+      }
+      try {
+        const ql = ctx.getService("objectql");
+        const packages = ql?.registry?.getAllPackages?.() ?? [];
+        const hit = packages.find(
+          (p) => (p?.manifest?.id ?? p?.id ?? p?.manifest?.name) === manifestId
+        );
+        if (hit) return "user-code";
+      } catch {
+      }
+      return "none";
+    };
+    /**
+     * Pull a userId out of the request's better-auth session, if any.
+     * Returns null when there is no signed-in user. v1 does not check
+     * admin role — UI gating + the auth requirement is sufficient for
+     * dev / single-tenant runtimes. Stricter checks can be layered on
+     * via a middleware in cloud-hosted multi-tenant deployments.
+     */
+    /**
+     * POST /api/v1/marketplace/install-local/:manifestId/reseed-sample-data
+     *
+     * Re-runs SeedLoaderService against the cached manifest's `data` arrays.
+     * Idempotent (upsert by id). Useful when:
+     *   • The user installed an app and skipped sample data
+     *   • A purge was undone
+     *   • The user wants a clean baseline back after editing demo rows
+     *
+     * Multi-tenant: requires an active organization on the session (same
+     * rule as install seed path).
+     */
+    this.handleReseed = async (c, ctx) => {
+      const userId = await this.requireAuthenticatedUser(c, ctx);
+      if (!userId) {
+        return c.json({ success: false, error: { code: "unauthorized", message: "Authentication required." } }, 401);
+      }
+      const manifestId = String(c.req.param?.("manifestId") ?? c.req.params?.manifestId ?? "").trim();
+      if (!manifestId) {
+        return c.json({ success: false, error: { code: "bad_request", message: "manifestId path param required." } }, 400);
+      }
+      if (!this.ledger.has(manifestId)) {
+        return c.json({ success: false, error: { code: "not_found", message: `No marketplace install for ${manifestId}.` } }, 404);
+      }
+      const entry = this.ledger.read(manifestId);
+      if (!entry) {
+        return c.json({ success: false, error: { code: "storage_failed", message: "Failed to read manifest cache." } }, 500);
+      }
+      const summary = await this.applySideEffects(ctx, entry.manifest, { seedNow: true, c });
+      if (summary.seeded.mode === "skipped") {
+        return c.json({
+          success: false,
+          error: {
+            code: "reseed_skipped",
+            message: `Reseed did not run: ${summary.seeded.reason ?? "unknown reason"}`
+          }
+        }, 400);
+      }
+      try {
+        entry.withSampleData = true;
+        this.ledger.write(entry);
+      } catch {
+      }
+      return c.json({
+        success: true,
+        data: {
+          manifestId,
+          inserted: summary.seeded.inserted ?? 0,
+          updated: summary.seeded.updated ?? 0,
+          errors: summary.seeded.errors ?? 0,
+          withSampleData: true
+        }
+      }, 200);
+    };
+    /**
+     * POST /api/v1/marketplace/install-local/:manifestId/purge-sample-data
+     *
+     * Deletes every record whose id is declared in the cached manifest's
+     * seed datasets. Uses the `driver` service directly to bypass ACL /
+     * lifecycle hooks (same pattern as cloud purge). User-created records
+     * are never touched — only ids declared in the package's bundled
+     * datasets are removed. Already-deleted rows count as `skipped`.
+     */
+    this.handlePurge = async (c, ctx) => {
+      const userId = await this.requireAuthenticatedUser(c, ctx);
+      if (!userId) {
+        return c.json({ success: false, error: { code: "unauthorized", message: "Authentication required." } }, 401);
+      }
+      const manifestId = String(c.req.param?.("manifestId") ?? c.req.params?.manifestId ?? "").trim();
+      if (!manifestId) {
+        return c.json({ success: false, error: { code: "bad_request", message: "manifestId path param required." } }, 400);
+      }
+      if (!this.ledger.has(manifestId)) {
+        return c.json({ success: false, error: { code: "not_found", message: `No marketplace install for ${manifestId}.` } }, 404);
+      }
+      const entry = this.ledger.read(manifestId);
+      if (!entry) {
+        return c.json({ success: false, error: { code: "storage_failed", message: "Failed to read manifest cache." } }, 500);
+      }
+      const datasets = Array.isArray(entry.manifest?.data) ? entry.manifest.data.filter((d) => d && d.object && Array.isArray(d.records)) : [];
+      if (datasets.length === 0) {
+        return c.json({
+          success: false,
+          error: { code: "nothing_to_purge", message: "This package declares no seed datasets." }
+        }, 400);
+      }
+      let driver;
+      try {
+        driver = ctx.getService("driver");
+      } catch {
+      }
+      if (!driver || typeof driver.delete !== "function") {
+        return c.json({
+          success: false,
+          error: { code: "driver_missing", message: "driver service unavailable \u2014 cannot purge." }
+        }, 500);
+      }
+      let deleted = 0;
+      let skipped = 0;
+      let errors = 0;
+      for (const ds of datasets) {
+        const object = String(ds.object);
+        for (const rec of ds.records) {
+          const id = rec?.id;
+          if (id === void 0 || id === null || id === "") {
+            skipped++;
+            continue;
+          }
+          try {
+            const r = await driver.delete(object, id);
+            if (r === false || r === 0 || r?.deleted === 0) skipped++;
+            else deleted++;
+          } catch (err) {
+            const msg = String(err?.message ?? err);
+            if (/not.?found|no row/i.test(msg)) skipped++;
+            else {
+              errors++;
+              ctx.logger?.warn?.(`[MarketplaceInstallLocal] purge ${object}#${id}: ${msg}`);
+            }
+          }
+        }
+      }
+      try {
+        entry.withSampleData = false;
+        this.ledger.write(entry);
+      } catch {
+      }
+      ctx.logger?.info?.(`[MarketplaceInstallLocal] purged ${manifestId}: deleted=${deleted} skipped=${skipped} errors=${errors}`);
+      return c.json({
+        success: true,
+        data: { manifestId, deleted, skipped, errors, withSampleData: false }
+      }, 200);
+    };
+    /**
+     * Replicate the start-time side-effects that AppPlugin runs for
+     * statically-declared apps but the `manifest` service does NOT:
+     *
+     *   1. Load `manifest.translations` (array of `Record<locale, data>`)
+     *      into the i18n service — auto-creating an in-memory fallback if
+     *      none is registered, matching AppPlugin's behaviour.
+     *
+     *   2. Merge `manifest.data` (an array of seed datasets) into the
+     *      kernel's `seed-datasets` service so SecurityPlugin's per-org
+     *      replay middleware picks them up on every future
+     *      sys_organization insert.
+     *
+     *   3. When `seedNow=true`, also run the seed immediately so the user
+     *      sees demo data without having to create a new org:
+     *        • single-tenant: run SeedLoaderService inline (mirrors
+     *          AppPlugin single-tenant branch)
+     *        • multi-tenant: invoke `seed-replayer` for the caller's
+     *          active org (resolved from the request session)
+     *
+     * Errors are logged but never thrown — install succeeds even if
+     * post-register side-effects partially fail (the manifest itself is
+     * already registered + cached). Returns a small summary for the
+     * response envelope.
+     */
+    this.applySideEffects = async (ctx, manifest, opts) => {
+      const appId = String(manifest?.id ?? "unknown");
+      let translationsLoaded = 0;
+      let seedSummary = { mode: "skipped", reason: "no-datasets" };
+      try {
+        const bundles = [];
+        if (Array.isArray(manifest?.translations)) bundles.push(...manifest.translations);
+        if (Array.isArray(manifest?.i18n)) bundles.push(...manifest.i18n);
+        if (bundles.length > 0) {
+          let i18nService;
+          try {
+            i18nService = ctx.getService("i18n");
+          } catch {
+          }
+          if (!i18nService) {
+            try {
+              const mod = await import("@objectstack/core");
+              const createMemoryI18n = mod.createMemoryI18n;
+              if (typeof createMemoryI18n === "function") {
+                i18nService = createMemoryI18n();
+                ctx.registerService?.("i18n", i18nService);
+                ctx.logger?.info?.(`[MarketplaceInstallLocal] auto-registered in-memory i18n fallback for "${appId}"`);
+              }
+            } catch {
+            }
+          }
+          if (i18nService?.loadTranslations) {
+            for (const bundle of bundles) {
+              for (const [locale, data] of Object.entries(bundle)) {
+                if (data && typeof data === "object") {
+                  try {
+                    i18nService.loadTranslations(locale, data);
+                    translationsLoaded++;
+                  } catch (err) {
+                    ctx.logger?.warn?.(`[MarketplaceInstallLocal] failed to load ${appId} translations for ${locale}: ${err?.message ?? err}`);
+                  }
+                }
+              }
+            }
+            ctx.logger?.info?.(`[MarketplaceInstallLocal] loaded ${translationsLoaded} locale bundle(s) for ${appId}`);
+          }
+        }
+      } catch (err) {
+        ctx.logger?.warn?.(`[MarketplaceInstallLocal] i18n side-effect failed for ${appId}: ${err?.message ?? err}`);
+      }
+      const datasets = Array.isArray(manifest?.data) ? manifest.data.filter((d) => d && d.object && Array.isArray(d.records)) : [];
+      if (datasets.length > 0) {
+        try {
+          const kernel = ctx.kernel;
+          let existing = [];
+          try {
+            const v = kernel?.getService?.("seed-datasets");
+            if (Array.isArray(v)) existing = v;
+          } catch {
+          }
+          const merged = [...existing, ...datasets];
+          if (kernel?.registerService) kernel.registerService("seed-datasets", merged);
+          else ctx.registerService?.("seed-datasets", merged);
+          ctx.logger?.info?.(`[MarketplaceInstallLocal] merged ${datasets.length} seed dataset(s) into kernel (total: ${merged.length})`);
+        } catch (err) {
+          ctx.logger?.warn?.(`[MarketplaceInstallLocal] failed to merge seed-datasets: ${err?.message ?? err}`);
+        }
+      }
+      if (opts.seedNow && datasets.length > 0) {
+        const multiTenant = String((0, import_types.readEnvWithDeprecation)("OS_MULTI_ORG_ENABLED", "OS_MULTI_TENANT") ?? "false").toLowerCase() !== "false";
+        try {
+          const ql = ctx.getService("objectql");
+          let metadata;
+          try {
+            metadata = ctx.getService("metadata");
+          } catch {
+          }
+          if (!ql || !metadata) {
+            seedSummary = { mode: "skipped", reason: "objectql-or-metadata-missing" };
+          } else {
+            let organizationId;
+            if (multiTenant) {
+              const resolved = await this.resolveActiveOrgId(opts.c, ctx);
+              if (resolved) organizationId = resolved;
+              else {
+                seedSummary = { mode: "skipped", reason: "multi-tenant-no-active-org" };
+                ctx.logger?.warn?.("[MarketplaceInstallLocal] multi-tenant: no active org on request \u2014 data not seeded");
+              }
+            }
+            if (!multiTenant || organizationId) {
+              const [{ SeedLoaderService }, { SeedLoaderRequestSchema }] = await Promise.all([
+                import("@objectstack/runtime"),
+                import("@objectstack/spec/data")
+              ]);
+              const seedLoader = new SeedLoaderService(ql, metadata, ctx.logger);
+              const request = SeedLoaderRequestSchema.parse({
+                // ADR-0036 / seed rename: the field is `seeds` (was `datasets`).
+                seeds: datasets,
+                config: {
+                  defaultMode: "upsert",
+                  multiPass: true,
+                  ...organizationId ? { organizationId } : {}
+                }
+              });
+              const result = await seedLoader.load(request);
+              seedSummary = {
+                mode: "inline",
+                inserted: result.summary.totalInserted,
+                updated: result.summary.totalUpdated,
+                errors: result.errors.length
+              };
+              ctx.logger?.info?.(`[MarketplaceInstallLocal] inline seed for ${appId}${organizationId ? ` (org=${organizationId})` : ""}: inserted=${seedSummary.inserted} updated=${seedSummary.updated} errors=${seedSummary.errors}`);
+            }
+          }
+        } catch (err) {
+          seedSummary = { mode: "skipped", reason: `seed-error: ${err?.message ?? err}` };
+          ctx.logger?.warn?.(`[MarketplaceInstallLocal] seed run failed for ${appId}: ${err?.message ?? err}`);
+        }
+      }
+      return { translationsLoaded, seeded: seedSummary };
+    };
+    /**
+     * Best-effort active-org resolution. Reads the better-auth session
+     * (same path as requireAuthenticatedUser) and returns
+     * `session.activeOrganizationId`, falling back to the user's first
+     * org membership.
+     */
+    this.resolveActiveOrgId = async (c, ctx) => {
+      if (!c?.req?.raw?.headers) return null;
+      try {
+        const authService = ctx.getService("auth");
+        let api = authService?.api;
+        if (!api && typeof authService?.getApi === "function") api = await authService.getApi();
+        if (!api?.getSession) return null;
+        const session = await api.getSession({ headers: c.req.raw.headers });
+        const direct = session?.session?.activeOrganizationId ?? session?.activeOrganizationId ?? null;
+        if (direct) return String(direct);
+        const userId = session?.user?.id;
+        if (!userId) return null;
+        try {
+          const ql = ctx.getService("objectql");
+          if (ql?.find) {
+            const rows = await ql.find("sys_organization_member", { where: { user_id: userId }, limit: 1, context: { isSystem: true } });
+            const row = Array.isArray(rows) ? rows[0] : rows?.items?.[0] ?? null;
+            return row?.organization_id ? String(row.organization_id) : null;
+          }
+        } catch {
+        }
+      } catch {
+      }
+      return null;
+    };
+    this.requireAuthenticatedUser = async (c, ctx) => {
+      try {
+        const authService = ctx.getService("auth");
+        let api = authService?.api;
+        if (!api && typeof authService?.getApi === "function") {
+          api = await authService.getApi();
+        }
+        if (api?.getSession && c?.req?.raw?.headers) {
+          const session = await api.getSession({ headers: c.req.raw.headers });
+          const userId = session?.user?.id ?? null;
+          if (userId) return String(userId);
+        }
+      } catch {
+      }
+      const xUserId = c?.req?.header?.("x-user-id");
+      if (xUserId) return String(xUserId);
+      return null;
+    };
+    this.readAll = () => this.ledger.list();
+    this.cloudUrl = resolveCloudUrl(config.controlPlaneUrl);
+    this.ledger = new LocalManifestSource(config.storageDir);
+    this.storageDir = this.ledger.dir;
+    this.credentials = new ConnectionCredentialStore();
+  }
+};
+
+// src/cloud-connection-plugin.ts
+var import_node_os = require("os");
+
+// src/cloud-connection-ui.ts
+var CloudConnectionSettingsPage = {
+  name: "cloud_connection_settings",
+  label: "Cloud Connection",
+  type: "app",
+  template: "default",
+  kind: "full",
+  isDefault: false,
+  regions: [
+    {
+      name: "header",
+      width: "full",
+      components: [
+        {
+          type: "page:header",
+          properties: {
+            title: "Cloud Connection",
+            subtitle: "Connect this runtime to an ObjectStack control plane to browse your organization's private packages and install them here.",
+            icon: "cloud"
+          }
+        }
+      ]
+    },
+    {
+      name: "main",
+      width: "large",
+      components: [
+        {
+          // Registered console widget — the RFC 8628 device-code
+          // state machine (status → start → user-code display →
+          // poll → bound / disconnect). Talks to the same-origin
+          // /api/v1/cloud-connection/* routes this plugin mounts.
+          type: "cloud-connection:panel",
+          properties: {}
+        }
+      ]
+    }
+  ]
+};
+var CLOUD_CONNECTION_NAV_CONTRIBUTIONS = [
+  {
+    app: "setup",
+    group: "group_apps",
+    priority: 200,
+    items: [
+      {
+        id: "nav_cloud_connection",
+        type: "page",
+        pageName: "cloud_connection_settings",
+        label: "Cloud Connection",
+        icon: "cloud"
+      }
+    ]
+  }
+];
+var CLOUD_CONNECTION_UI_BUNDLE = {
+  id: "com.objectstack.cloud-connection.ui",
+  namespace: "sys",
+  version: "0.1.0",
+  type: "plugin",
+  scope: "system",
+  name: "Cloud Connection UI",
+  description: "Setup page + navigation for binding this runtime to a control plane.",
+  pages: [CloudConnectionSettingsPage],
+  navigationContributions: CLOUD_CONNECTION_NAV_CONTRIBUTIONS
+};
+
+// src/cloud-connection-plugin.ts
+var CLOUD_CONNECTION_PREFIX = "/api/v1/cloud-connection";
+var CloudConnectionPlugin = class {
+  constructor(config = {}) {
+    this.name = "com.objectstack.cloud.connection";
+    this.version = "0.3.0";
+    this.init = async (_ctx) => {
+    };
+    this.start = async (ctx) => {
+      ctx.hook("kernel:ready", async () => {
+        const httpServer = (() => {
+          try {
+            return ctx.getService("http-server");
+          } catch {
+            return void 0;
+          }
+        })();
+        if (!httpServer || typeof httpServer.getRawApp !== "function") {
+          ctx.logger?.warn?.("[CloudConnectionPlugin] http-server unavailable \u2014 routes not mounted");
+          return;
+        }
+        const rawApp = httpServer.getRawApp();
+        const cloudUrl = (this.cfg.controlPlaneUrl ?? process.env.OS_CLOUD_URL ?? "").trim().replace(/\/+$/, "");
+        const cloudApiKey = (this.cfg.controlPlaneApiKey ?? process.env.OS_CLOUD_API_KEY ?? "").trim();
+        const deviceClientId = (this.cfg.deviceClientId ?? process.env.OS_CLI_CLIENT_ID ?? "objectstack-cli").trim();
+        const deviceScope = "openid profile email";
+        const credential = () => cloudApiKey || this.store.read()?.runtimeToken || "";
+        const authHeaders = () => {
+          const cred = credential();
+          return cred ? { Authorization: `Bearer ${cred}` } : {};
+        };
+        const hostOf = (c) => {
+          try {
+            return new URL(c.req.url).hostname;
+          } catch {
+            return "";
+          }
+        };
+        const resolveEnvironmentId = async (c) => {
+          const fixed = (this.cfg.environmentId ?? process.env.OS_ENVIRONMENT_ID ?? "").trim();
+          if (fixed && fixed !== "env_local" && fixed !== "proj_local") return fixed;
+          if (this.cfg.singleEnvironment) {
+            return this.store.read()?.environmentId || void 0;
+          }
+          try {
+            const envRegistry = ctx.getService("env-registry");
+            const env = await envRegistry?.resolveByHostname?.(hostOf(c));
+            return env?.environmentId;
+          } catch {
+            return void 0;
+          }
+        };
+        try {
+          const manifest = ctx.getService("manifest");
+          manifest?.register?.(CLOUD_CONNECTION_UI_BUNDLE);
+        } catch {
+        }
+        const sessionFromAuthService = async (authSvc, rawReq) => {
+          const api = typeof authSvc?.getApi === "function" ? await authSvc.getApi() : authSvc?.api ?? authSvc;
+          const session = await api?.getSession?.({ headers: rawReq.headers });
+          const userId = session?.user?.id ? String(session.user.id) : void 0;
+          return userId ? { userId } : null;
+        };
+        const resolveSession = async (environmentId, rawReq) => {
+          try {
+            if (this.cfg.singleEnvironment) {
+              let authSvc2;
+              try {
+                authSvc2 = ctx.getService("auth");
+              } catch {
+              }
+              if (!authSvc2) return null;
+              return await sessionFromAuthService(authSvc2, rawReq);
+            }
+            const kernelManager = ctx.getService("kernel-manager");
+            const kernel = await kernelManager?.getOrCreate?.(environmentId);
+            let authSvc;
+            try {
+              authSvc = await kernel?.getServiceAsync?.("auth");
+            } catch {
+            }
+            if (!authSvc) {
+              try {
+                authSvc = kernel?.getService?.("auth");
+              } catch {
+              }
+            }
+            if (!authSvc) return null;
+            return await sessionFromAuthService(authSvc, rawReq);
+          } catch {
+            return null;
+          }
+        };
+        rawApp.get(`${CLOUD_CONNECTION_PREFIX}/status`, async (c) => {
+          const environmentId = await resolveEnvironmentId(c);
+          const stored = this.store.read();
+          const runtimeId = stored?.runtimeId;
+          if (!environmentId && !this.cfg.singleEnvironment) {
+            return c.json({ success: false, error: { code: "environment_not_found" } }, 404);
+          }
+          if (!environmentId && !credential()) {
+            return c.json({ success: true, data: { environmentId: null, runtimeId: runtimeId ?? null, bound: false, provider: "objectstack-cloud", connection: null } });
+          }
+          if (cloudUrl) {
+            try {
+              const qs = environmentId ? `?environment_id=${encodeURIComponent(environmentId)}` : runtimeId ? `?runtime_id=${encodeURIComponent(runtimeId)}` : "";
+              const resp = await fetch(`${cloudUrl}/api/v1/cloud-connection/status${qs}`, {
+                headers: authHeaders()
+              });
+              if (resp.ok) {
+                const json = await resp.json().catch(() => null);
+                const data = json?.data ?? {};
+                const bound2 = Boolean(data.bound) || Boolean(credential());
+                return c.json({ success: true, data: {
+                  environmentId: environmentId ?? null,
+                  runtimeId: data.runtime_id ?? runtimeId ?? null,
+                  bound: bound2,
+                  provider: "objectstack-cloud",
+                  connection: data.connection ?? null
+                } });
+              }
+            } catch {
+            }
+          }
+          const bound = Boolean(credential());
+          return c.json({ success: true, data: { environmentId: environmentId ?? null, runtimeId: runtimeId ?? null, bound, provider: "objectstack-cloud", connection: null } });
+        });
+        rawApp.post(`${CLOUD_CONNECTION_PREFIX}/bind/start`, async (c) => {
+          let body = {};
+          try {
+            body = await c.req.json();
+          } catch {
+            body = {};
+          }
+          let environmentId = await resolveEnvironmentId(c);
+          if (!environmentId && this.cfg.singleEnvironment) {
+            environmentId = String(body?.environment_id ?? body?.environmentId ?? "").trim() || void 0;
+          }
+          if (!environmentId && !this.cfg.singleEnvironment) {
+            return c.json({ success: false, error: { code: "environment_not_found" } }, 404);
+          }
+          const session = await resolveSession(environmentId ?? "", c.req.raw);
+          if (!session?.userId) return c.json({ success: false, error: { code: "unauthenticated", message: "Sign in to this environment to connect a cloud account." } }, 401);
+          if (!cloudUrl) return c.json({ success: false, error: { code: "cloud_unconfigured", message: "No cloud control plane configured." } }, 503);
+          try {
+            const resp = await fetch(`${cloudUrl}/api/v1/auth/device/code`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ client_id: deviceClientId, scope: deviceScope })
+            });
+            const json = await resp.json().catch(() => ({}));
+            if (!resp.ok) return c.json({ success: false, error: { code: "device_code_failed", message: json?.error ?? `device/code ${resp.status}` } }, 502);
+            const withContext = (uri) => {
+              if (typeof uri !== "string" || !uri) return void 0;
+              try {
+                const u = new URL(uri);
+                try {
+                  u.searchParams.set("runtime_name", (0, import_node_os.hostname)());
+                } catch {
+                }
+                const ver = (process.env.OS_RUNTIME_VERSION ?? this.version) || "";
+                if (ver) u.searchParams.set("runtime_version", ver);
+                return u.toString();
+              } catch {
+                return uri;
+              }
+            };
+            return c.json({ success: true, data: {
+              device_code: json.device_code,
+              user_code: json.user_code,
+              verification_uri: withContext(json.verification_uri),
+              verification_uri_complete: withContext(json.verification_uri_complete),
+              interval: json.interval ?? 5,
+              expires_in: json.expires_in ?? 600
+            } });
+          } catch (err) {
+            ctx.logger?.error?.("[CloudConnectionPlugin] bind/start failed", err instanceof Error ? err : new Error(String(err)));
+            return c.json({ success: false, error: { code: "device_code_failed", message: String(err?.message ?? err) } }, 502);
+          }
+        });
+        rawApp.post(`${CLOUD_CONNECTION_PREFIX}/bind/poll`, async (c) => {
+          let body = {};
+          try {
+            body = await c.req.json();
+          } catch {
+            body = {};
+          }
+          let environmentId = await resolveEnvironmentId(c);
+          if (!environmentId && this.cfg.singleEnvironment) {
+            environmentId = String(body?.environment_id ?? body?.environmentId ?? "").trim() || void 0;
+          }
+          if (!environmentId && !this.cfg.singleEnvironment) {
+            return c.json({ success: false, error: { code: "environment_not_found" } }, 404);
+          }
+          const session = await resolveSession(environmentId ?? "", c.req.raw);
+          if (!session?.userId) return c.json({ success: false, error: { code: "unauthenticated" } }, 401);
+          if (!cloudUrl) return c.json({ success: false, error: { code: "cloud_unconfigured" } }, 503);
+          const deviceCode = String(body?.device_code ?? body?.deviceCode ?? "").trim();
+          if (!deviceCode) return c.json({ success: false, error: { code: "invalid_request", message: "device_code is required" } }, 400);
+          try {
+            const tokResp = await fetch(`${cloudUrl}/api/v1/auth/device/token`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ grant_type: "urn:ietf:params:oauth:grant-type:device_code", device_code: deviceCode, client_id: deviceClientId })
+            });
+            const tok = await tokResp.json().catch(() => ({}));
+            const accessToken = tok?.access_token;
+            if (!accessToken) {
+              const errCode = String(tok?.error ?? `device/token ${tokResp.status}`);
+              const pending = errCode === "authorization_pending" || errCode === "slow_down";
+              return c.json({ success: pending, data: { pending }, error: pending ? void 0 : { code: errCode } }, pending ? 200 : 400);
+            }
+            const stored = this.store.read();
+            const bindResp = await fetch(`${cloudUrl}/api/v1/cloud-connection/bind`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json", ...cloudApiKey ? { Authorization: `Bearer ${cloudApiKey}` } : {} },
+              body: JSON.stringify({
+                ...environmentId ? { environment_id: environmentId } : {},
+                ...stored?.runtimeId ? { runtime_id: stored.runtimeId } : {},
+                name: (() => {
+                  try {
+                    return (0, import_node_os.hostname)();
+                  } catch {
+                    return void 0;
+                  }
+                })(),
+                runtime_version: (process.env.OS_RUNTIME_VERSION ?? this.version) || void 0,
+                token: accessToken,
+                scope: deviceScope
+              })
+            });
+            const bindJson = await bindResp.json().catch(() => ({ success: false, error: "bind failed (no body)" }));
+            const runtimeToken = bindJson?.data?.runtime_token;
+            if (bindResp.ok && typeof runtimeToken === "string" && runtimeToken) {
+              try {
+                this.store.write({
+                  runtimeToken,
+                  runtimeId: bindJson?.data?.runtime_id ?? bindJson?.data?.connection?.runtime_id ?? void 0,
+                  environmentId: environmentId || void 0,
+                  controlPlaneUrl: cloudUrl,
+                  organizationId: bindJson?.data?.connection?.organization_id ?? void 0,
+                  accountEmail: bindJson?.data?.connection?.account_email ?? void 0,
+                  boundAt: bindJson?.data?.connection?.bound_at ?? (/* @__PURE__ */ new Date()).toISOString()
+                });
+              } catch (err) {
+                ctx.logger?.error?.("[CloudConnectionPlugin] failed to persist runtime credential", err instanceof Error ? err : new Error(String(err)));
+              }
+              delete bindJson.data.runtime_token;
+            }
+            return c.json(bindJson, bindResp.status);
+          } catch (err) {
+            ctx.logger?.error?.("[CloudConnectionPlugin] bind/poll failed", err instanceof Error ? err : new Error(String(err)));
+            return c.json({ success: false, error: { code: "bind_failed", message: String(err?.message ?? err) } }, 502);
+          }
+        });
+        rawApp.post(`${CLOUD_CONNECTION_PREFIX}/unbind`, async (c) => {
+          const environmentId = await resolveEnvironmentId(c);
+          if (!environmentId && !this.cfg.singleEnvironment) {
+            return c.json({ success: false, error: { code: "environment_not_found" } }, 404);
+          }
+          const session = await resolveSession(environmentId ?? "", c.req.raw);
+          if (!session?.userId) return c.json({ success: false, error: { code: "unauthenticated" } }, 401);
+          let revoked = false;
+          if (cloudUrl && credential()) {
+            try {
+              const resp = await fetch(`${cloudUrl}/api/v1/cloud-connection/revoke`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", ...authHeaders() },
+                body: JSON.stringify(environmentId ? { environment_id: environmentId } : {})
+              });
+              revoked = resp.ok;
+            } catch {
+            }
+          }
+          const residualId = this.store.read()?.runtimeId;
+          const cleared = (() => {
+            try {
+              if (residualId) {
+                this.store.write({ runtimeToken: "", runtimeId: residualId });
+                return true;
+              }
+              return this.store.clear();
+            } catch {
+              return false;
+            }
+          })();
+          return c.json({ success: true, data: { environmentId: environmentId ?? null, revoked, cleared } });
+        });
+        rawApp.post(`${CLOUD_CONNECTION_PREFIX}/install`, async (c) => {
+          const environmentId = await resolveEnvironmentId(c);
+          if (!environmentId) return c.json({ success: false, error: { code: "environment_not_found" } }, 404);
+          const session = await resolveSession(environmentId, c.req.raw);
+          if (!session?.userId) {
+            return c.json({ success: false, error: { code: "unauthenticated", message: "Sign in to this environment to install apps." } }, 401);
+          }
+          if (!cloudUrl || !credential()) {
+            return c.json({ success: false, error: { code: "cloud_unconfigured", message: "This runtime is not connected to a cloud account; install is unavailable." } }, 503);
+          }
+          let body = {};
+          try {
+            body = await c.req.json();
+          } catch {
+            body = {};
+          }
+          const packageId = String(body?.package_id ?? body?.packageId ?? "").trim();
+          if (!packageId) return c.json({ success: false, error: { code: "invalid_request", message: "package_id is required" } }, 400);
+          const seedSampleData = body?.seed_sample_data === true || body?.seedSampleData === true;
+          try {
+            const resp = await fetch(`${cloudUrl}/api/v1/actions/sys_package/install_package`, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                ...authHeaders()
+              },
+              body: JSON.stringify({ recordId: packageId, params: { environment_id: environmentId, seed_sample_data: seedSampleData } })
+            });
+            const json = await resp.json().catch(() => ({ success: false, error: "install failed (no body)" }));
+            return c.json(json, resp.status);
+          } catch (err) {
+            ctx.logger?.error?.("[CloudConnectionPlugin] install failed", err instanceof Error ? err : new Error(String(err)));
+            return c.json({ success: false, error: { code: "install_failed", message: String(err?.message ?? err) } }, 502);
+          }
+        });
+        rawApp.get(`${CLOUD_CONNECTION_PREFIX}/installation`, async (c) => {
+          const environmentId = await resolveEnvironmentId(c);
+          if (!environmentId) {
+            if (this.cfg.singleEnvironment) return c.json({ success: true, data: { installed: false } });
+            return c.json({ success: false, error: { code: "environment_not_found" } }, 404);
+          }
+          const session = await resolveSession(environmentId, c.req.raw);
+          if (!session?.userId) {
+            return c.json({ success: false, error: { code: "unauthenticated", message: "Sign in to this environment." } }, 401);
+          }
+          let packageId = "";
+          try {
+            const u = new URL(c.req.url);
+            packageId = String(u.searchParams.get("package_id") ?? u.searchParams.get("packageId") ?? "").trim();
+          } catch {
+          }
+          if (!packageId) return c.json({ success: false, error: { code: "invalid_request", message: "package_id is required" } }, 400);
+          if (!cloudUrl || !credential()) return c.json({ success: true, data: { installed: false } });
+          try {
+            const resp = await fetch(
+              `${cloudUrl}/api/v1/cloud/environments/${encodeURIComponent(environmentId)}/installations/${encodeURIComponent(packageId)}`,
+              { headers: { Accept: "application/json", ...authHeaders() } }
+            );
+            if (!resp.ok) return c.json({ success: true, data: { installed: false } });
+            const json = await resp.json().catch(() => ({}));
+            const data = json?.data ?? json ?? {};
+            if (!data.installed) return c.json({ success: true, data: { installed: false } });
+            return c.json({ success: true, data: {
+              installed: true,
+              installationId: String(data.installationId ?? ""),
+              version: String(data.version ?? "installed"),
+              withSampleData: data.withSampleData === true
+            } });
+          } catch (err) {
+            ctx.logger?.warn?.(`[CloudConnectionPlugin] installation probe failed: ${String(err?.message ?? err)}`);
+            return c.json({ success: true, data: { installed: false } });
+          }
+        });
+        rawApp.get(`${CLOUD_CONNECTION_PREFIX}/installed`, async (c) => {
+          const environmentId = await resolveEnvironmentId(c);
+          if (!environmentId) {
+            if (this.cfg.singleEnvironment) {
+              return c.json({ success: true, data: { packages: [], total: 0, connected: Boolean(credential()) } });
+            }
+            return c.json({ success: false, error: { code: "environment_not_found" } }, 404);
+          }
+          const session = await resolveSession(environmentId, c.req.raw);
+          if (!session?.userId) {
+            return c.json({ success: false, error: { code: "unauthenticated", message: "Sign in to this environment." } }, 401);
+          }
+          if (!cloudUrl || !credential()) {
+            return c.json({ success: true, data: { packages: [], total: 0, connected: false } });
+          }
+          try {
+            const resp = await fetch(
+              `${cloudUrl}/api/v1/cloud/environments/${encodeURIComponent(environmentId)}/packages`,
+              { headers: { Accept: "application/json", ...authHeaders() } }
+            );
+            if (!resp.ok) return c.json({ success: true, data: { packages: [], total: 0, connected: true } });
+            const json = await resp.json().catch(() => ({}));
+            const data = json?.data ?? json ?? {};
+            const packages = Array.isArray(data.packages) ? data.packages : [];
+            return c.json({ success: true, data: { packages, total: packages.length, connected: true } });
+          } catch (err) {
+            ctx.logger?.warn?.(`[CloudConnectionPlugin] installed-list failed: ${String(err?.message ?? err)}`);
+            return c.json({ success: true, data: { packages: [], total: 0, connected: true } });
+          }
+        });
+        rawApp.get(`${CLOUD_CONNECTION_PREFIX}/org-packages`, async (c) => {
+          const environmentId = await resolveEnvironmentId(c);
+          if (!environmentId && !this.cfg.singleEnvironment) {
+            return c.json({ success: false, error: { code: "environment_not_found" } }, 404);
+          }
+          const session = await resolveSession(environmentId ?? "", c.req.raw);
+          if (!session?.userId) {
+            return c.json({ success: false, error: { code: "unauthenticated", message: "Sign in to this environment." } }, 401);
+          }
+          if (!cloudUrl || !credential()) {
+            return c.json({ success: true, data: { items: [], total: 0, connected: false } });
+          }
+          try {
+            const qs = environmentId ? `?environment_id=${encodeURIComponent(environmentId)}` : "";
+            const resp = await fetch(
+              `${cloudUrl}/api/v1/cloud/org-packages${qs}`,
+              { headers: { Accept: "application/json", ...authHeaders() } }
+            );
+            if (!resp.ok) return c.json({ success: true, data: { items: [], total: 0, connected: true } });
+            const json = await resp.json().catch(() => ({}));
+            const data = json?.data ?? json ?? {};
+            const items = Array.isArray(data.items) ? data.items : [];
+            return c.json({ success: true, data: { items, total: items.length, connected: true } });
+          } catch (err) {
+            ctx.logger?.warn?.(`[CloudConnectionPlugin] org-packages failed: ${String(err?.message ?? err)}`);
+            return c.json({ success: true, data: { items: [], total: 0, connected: true } });
+          }
+        });
+        ctx.logger?.info?.(`[CloudConnectionPlugin] mounted ${CLOUD_CONNECTION_PREFIX}/{status,bind/start,bind/poll,install,installation,installed,org-packages} \u2192 ${cloudUrl || "(cloud unconfigured)"}`);
+      });
+    };
+    this.cfg = config;
+    this.store = new ConnectionCredentialStore(config.credentialPath);
+  }
+};
+function createCloudConnectionPlugin(config = {}) {
+  return new CloudConnectionPlugin(config);
+}
+
+// src/runtime-config-plugin.ts
+var RuntimeConfigPlugin = class {
+  constructor(config = {}) {
+    this.name = "com.objectstack.runtime.runtime-config";
+    this.version = "1.0.0";
+    this.init = async (_ctx) => {
+    };
+    this.start = async (ctx) => {
+      ctx.hook("kernel:ready", async () => {
+        let httpServer;
+        try {
+          httpServer = ctx.getService("http-server");
+        } catch {
+          ctx.logger?.warn?.("[RuntimeConfigPlugin] http-server not available \u2014 runtime/config not mounted");
+          return;
+        }
+        if (!httpServer || typeof httpServer.getRawApp !== "function") {
+          ctx.logger?.warn?.("[RuntimeConfigPlugin] http-server missing getRawApp() \u2014 runtime/config not mounted");
+          return;
+        }
+        const rawApp = httpServer.getRawApp();
+        let envRegistry = null;
+        try {
+          envRegistry = ctx.getService("env-registry");
+        } catch {
+        }
+        const featuresFor = (plan, base) => {
+          const derived = this.resolvePlanFeatures?.(plan);
+          return {
+            aiStudio: derived?.aiStudio ?? base.aiStudio,
+            autoPublishAiBuilds: derived?.autoPublishAiBuilds ?? base.autoPublishAiBuilds
+          };
+        };
+        const handler = async (c) => {
+          const rawHost = c.req.header("host") ?? "";
+          const host = rawHost.split(":")[0].toLowerCase().trim();
+          let defaultEnvironmentId;
+          let defaultOrgId;
+          let resolvedSingleEnv = this.singleEnvironment;
+          let features = featuresFor(void 0, { aiStudio: this.aiStudio, autoPublishAiBuilds: false });
+          const resolveFn = typeof envRegistry?.resolveByHostname === "function" ? envRegistry.resolveByHostname.bind(envRegistry) : typeof envRegistry?.resolveHostname === "function" ? envRegistry.resolveHostname.bind(envRegistry) : null;
+          if (resolveFn && host) {
+            try {
+              const resolved = await resolveFn(host);
+              if (resolved?.environmentId) {
+                defaultEnvironmentId = String(resolved.environmentId);
+                const orgId = resolved.organizationId ?? resolved.organization_id;
+                if (orgId) defaultOrgId = String(orgId);
+                resolvedSingleEnv = true;
+                if (typeof resolved.plan === "string" && resolved.plan.trim() !== "") {
+                  features = featuresFor(resolved.plan, features);
+                }
+              }
+            } catch {
+            }
+          }
+          return c.json({
+            cloudUrl: this.cloudUrl,
+            singleEnvironment: resolvedSingleEnv,
+            defaultOrgId,
+            defaultEnvironmentId,
+            features: {
+              installLocal: this.installLocal,
+              marketplace: true,
+              aiStudio: features.aiStudio,
+              autoPublishAiBuilds: features.autoPublishAiBuilds
+            },
+            branding: {
+              productName: this.productName,
+              productShortName: this.productShortName
+            }
+          });
+        };
+        rawApp.get("/api/v1/runtime/config", handler);
+        rawApp.get("/api/v1/studio/runtime-config", handler);
+        ctx.logger?.info?.("[RuntimeConfigPlugin] mounted /api/v1/runtime/config", {
+          cloudUrl: this.cloudUrl || "(empty)",
+          installLocal: this.installLocal,
+          perHostEnvResolution: !!envRegistry
+        });
+      });
+    };
+    this.destroy = async () => {
+    };
+    this.cloudUrl = config.controlPlaneUrl === "" ? "" : resolveCloudUrl(config.controlPlaneUrl) ?? "";
+    this.installLocal = !!config.installLocal;
+    this.aiStudio = config.aiStudio !== false;
+    this.singleEnvironment = !!config.singleEnvironment;
+    this.resolvePlanFeatures = config.resolvePlanFeatures;
+    const envName = (typeof process !== "undefined" ? process.env?.OS_PRODUCT_NAME : void 0)?.trim();
+    const envShort = (typeof process !== "undefined" ? process.env?.OS_PRODUCT_SHORT_NAME : void 0)?.trim();
+    this.productName = (config.productName ?? envName ?? "ObjectOS").trim() || "ObjectOS";
+    this.productShortName = (config.productShortName ?? envShort ?? this.productName).trim() || this.productName;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLOUD_CONNECTION_UI_BUNDLE,
+  CloudConnectionPlugin,
+  CloudConnectionSettingsPage,
+  ConnectionCredentialStore,
+  DEFAULT_CLOUD_URL,
+  DEFAULT_CONNECTION_CREDENTIAL_PATH,
+  DEFAULT_INSTALLED_PACKAGES_DIR,
+  LocalManifestSource,
+  MARKETPLACE_BROWSE_UI_BUNDLE,
+  MARKETPLACE_INSTALLED_UI_BUNDLE,
+  MarketplaceInstallLocalPlugin,
+  MarketplaceProxyPlugin,
+  RuntimeConfigPlugin,
+  createCloudConnectionPlugin,
+  publicMarketplaceKeyForApiPath,
+  resolveCloudUrl,
+  resolveMarketplacePublicBaseUrl
+});
+//# sourceMappingURL=index.cjs.map