@tutti-os/workspace-app-center 0.0.1

package/dist/chunk-FENSLRNH.js

@@ -0,0 +1,690 @@
+import {
+  workspaceAppManifestSchemaVersion
+} from "./chunk-3Z2WIHMP.js";
+
+// src/core/appIdentity.ts
+var workspaceAppIdPattern = /^[a-z0-9]+(?:[._-][a-z0-9]+)*$/;
+function isWorkspaceAppId(value) {
+  return workspaceAppIdPattern.test(value);
+}
+function normalizeWorkspaceAppId(value) {
+  return value.trim().toLowerCase();
+}
+function createWorkspaceAppIdentity(input) {
+  return normalizeWorkspaceAppId(input.id);
+}
+
+// src/core/manifestValidation.ts
+var appWindowMinWidth = 280;
+var appWindowMinHeight = 160;
+var appWindowMaxWidth = 1600;
+var appWindowMaxHeight = 1200;
+function validateWorkspaceAppManifest(value) {
+  const issues = [];
+  if (!isRecord(value)) {
+    return {
+      issues: [
+        {
+          code: "manifest.notObject",
+          message: "Manifest must be an object.",
+          path: "$"
+        }
+      ],
+      valid: false
+    };
+  }
+  if (value.schemaVersion !== workspaceAppManifestSchemaVersion) {
+    issues.push({
+      code: "manifest.schemaVersion",
+      message: `schemaVersion must be ${workspaceAppManifestSchemaVersion}.`,
+      path: "$.schemaVersion"
+    });
+  }
+  const appId = readOptionalString(value.appId);
+  if (!appId || !isWorkspaceAppId(normalizeWorkspaceAppId(appId))) {
+    issues.push({
+      code: "manifest.appId",
+      message: "appId must contain lowercase letters, numbers, dots, hyphens, or underscores.",
+      path: "$.appId"
+    });
+  }
+  const name = readOptionalString(value.name);
+  if (!name) {
+    issues.push({
+      code: "manifest.name",
+      message: "name is required.",
+      path: "$.name"
+    });
+  }
+  const version = readOptionalString(value.version);
+  if (!version) {
+    issues.push({
+      code: "manifest.version",
+      message: "version is required.",
+      path: "$.version"
+    });
+  }
+  const description = readOptionalString(value.description);
+  if (!description) {
+    issues.push({
+      code: "manifest.description",
+      message: "description is required.",
+      path: "$.description"
+    });
+  }
+  const icon = validateIcon(value.icon, issues);
+  const runtime = validateRuntime(value.runtime, issues);
+  const window = validateWindow(value.window, issues);
+  const author = validateAuthor(value.author, issues);
+  const tags = validateTags(value.tags, issues);
+  const localizationInfo = validateLocalizationInfo(
+    value.localizationInfo,
+    issues
+  );
+  if (issues.length > 0 || !appId || !name || !version || !description || !runtime) {
+    return {
+      issues,
+      valid: false
+    };
+  }
+  return {
+    issues,
+    manifest: {
+      schemaVersion: workspaceAppManifestSchemaVersion,
+      appId: normalizeWorkspaceAppId(appId),
+      name,
+      version,
+      description,
+      ...icon ? { icon } : {},
+      runtime,
+      ...window ? { window } : {},
+      ...author ? { author } : {},
+      ...tags ? { tags } : {},
+      ...localizationInfo ? { localizationInfo } : {}
+    },
+    valid: true
+  };
+}
+function validateIcon(value, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    issues.push({
+      code: "manifest.icon",
+      message: "icon must be an object when provided.",
+      path: "$.icon"
+    });
+    return void 0;
+  }
+  const type = value.type;
+  const src = readOptionalString(value.src);
+  if (type !== "asset" || !src || !isRelativePackagePath(src)) {
+    issues.push({
+      code: "manifest.icon",
+      message: "icon must include type=asset and a relative src.",
+      path: "$.icon"
+    });
+    return void 0;
+  }
+  return {
+    type,
+    src
+  };
+}
+function validateRuntime(value, issues) {
+  if (!isRecord(value)) {
+    issues.push({
+      code: "manifest.runtime",
+      message: "runtime is required.",
+      path: "$.runtime"
+    });
+    return void 0;
+  }
+  const bootstrap = readOptionalString(value.bootstrap);
+  const healthcheckPath = readOptionalString(value.healthcheckPath);
+  if (!bootstrap || !isRelativePackagePath(bootstrap)) {
+    issues.push({
+      code: "manifest.runtime",
+      message: "runtime.bootstrap must be a relative package path.",
+      path: "$.runtime.bootstrap"
+    });
+  }
+  if (!healthcheckPath || !healthcheckPath.startsWith("/")) {
+    issues.push({
+      code: "manifest.runtime",
+      message: "runtime.healthcheckPath must start with /.",
+      path: "$.runtime.healthcheckPath"
+    });
+  }
+  if (!bootstrap || !healthcheckPath || !isRelativePackagePath(bootstrap) || !healthcheckPath.startsWith("/")) {
+    return void 0;
+  }
+  return {
+    bootstrap,
+    healthcheckPath
+  };
+}
+function validateWindow(value, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    issues.push({
+      code: "manifest.window",
+      message: "window must be an object when provided.",
+      path: "$.window"
+    });
+    return void 0;
+  }
+  const minimizeBehavior = value.minimizeBehavior;
+  if (minimizeBehavior !== void 0 && minimizeBehavior !== "keep-mounted" && minimizeBehavior !== "hibernate") {
+    issues.push({
+      code: "manifest.window",
+      message: "window.minimizeBehavior must be keep-mounted or hibernate when provided.",
+      path: "$.window.minimizeBehavior"
+    });
+    return void 0;
+  }
+  const minWidth = validateWindowSize(
+    value.minWidth,
+    "minWidth",
+    appWindowMinWidth,
+    appWindowMaxWidth,
+    issues
+  );
+  const minHeight = validateWindowSize(
+    value.minHeight,
+    "minHeight",
+    appWindowMinHeight,
+    appWindowMaxHeight,
+    issues
+  );
+  if (minWidth === null || minHeight === null) {
+    return void 0;
+  }
+  return {
+    ...minimizeBehavior ? { minimizeBehavior } : {},
+    ...minHeight === void 0 ? {} : { minHeight },
+    ...minWidth === void 0 ? {} : { minWidth }
+  };
+}
+function validateWindowSize(value, field, minimum, maximum, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isInteger(value) || value < minimum || value > maximum) {
+    issues.push({
+      code: "manifest.window",
+      message: `window.${field} must be an integer between ${minimum} and ${maximum} when provided.`,
+      path: `$.window.${field}`
+    });
+    return null;
+  }
+  return value;
+}
+function validateAuthor(value, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    issues.push({
+      code: "manifest.author",
+      message: "author must be an object when provided.",
+      path: "$.author"
+    });
+    return void 0;
+  }
+  const name = readOptionalString(value.name);
+  const url = readOptionalString(value.url);
+  if (!name || value.url !== void 0 && !url) {
+    issues.push({
+      code: "manifest.author",
+      message: "author must include name and an optional non-empty url.",
+      path: "$.author"
+    });
+    return void 0;
+  }
+  return {
+    name,
+    ...url ? { url } : {}
+  };
+}
+function validateTags(value, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    issues.push({
+      code: "manifest.tags",
+      message: "tags must be an array when provided.",
+      path: "$.tags"
+    });
+    return void 0;
+  }
+  const tags = value.map((tag) => readOptionalString(tag)).filter((tag) => Boolean(tag));
+  if (tags.length !== value.length) {
+    issues.push({
+      code: "manifest.tags",
+      message: "tags must only contain non-empty strings.",
+      path: "$.tags"
+    });
+  }
+  return Array.from(new Set(tags));
+}
+function validateLocalizationInfo(value, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    issues.push({
+      code: "manifest.localizationInfo",
+      message: "localizationInfo must be an object when provided.",
+      path: "$.localizationInfo"
+    });
+    return void 0;
+  }
+  const defaultLocale = readOptionalString(value.defaultLocale);
+  if (!defaultLocale) {
+    issues.push({
+      code: "manifest.localizationInfo",
+      message: "localizationInfo.defaultLocale is required.",
+      path: "$.localizationInfo.defaultLocale"
+    });
+  }
+  const additionalLocalesValue = value.additionalLocales;
+  if (additionalLocalesValue !== void 0 && !Array.isArray(additionalLocalesValue)) {
+    issues.push({
+      code: "manifest.localizationInfo",
+      message: "localizationInfo.additionalLocales must be an array.",
+      path: "$.localizationInfo.additionalLocales"
+    });
+    return void 0;
+  }
+  const seenLocales = new Set(
+    defaultLocale ? [defaultLocale.toLowerCase()] : []
+  );
+  const additionalLocales = [];
+  for (const [index, entry] of (additionalLocalesValue ?? []).entries()) {
+    if (!isRecord(entry)) {
+      issues.push({
+        code: "manifest.localizationInfo",
+        message: "localizationInfo.additionalLocales entries must be objects.",
+        path: `$.localizationInfo.additionalLocales[${index}]`
+      });
+      continue;
+    }
+    const locale = readOptionalString(entry.locale);
+    const file = readOptionalString(entry.file);
+    if (!locale || !file || !isRelativePackagePath(file)) {
+      issues.push({
+        code: "manifest.localizationInfo",
+        message: "localizationInfo.additionalLocales entries must include locale and a relative file path.",
+        path: `$.localizationInfo.additionalLocales[${index}]`
+      });
+      continue;
+    }
+    const localeKey = locale.toLowerCase();
+    if (seenLocales.has(localeKey)) {
+      issues.push({
+        code: "manifest.localizationInfo",
+        message: "localizationInfo locales must be unique.",
+        path: `$.localizationInfo.additionalLocales[${index}].locale`
+      });
+      continue;
+    }
+    seenLocales.add(localeKey);
+    additionalLocales.push({ locale, file });
+  }
+  if (!defaultLocale || issues.some((issue) => issue.code === "manifest.localizationInfo")) {
+    return void 0;
+  }
+  return {
+    defaultLocale,
+    ...additionalLocales.length > 0 ? { additionalLocales } : {}
+  };
+}
+function readOptionalString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function isRelativePackagePath(value) {
+  return !value.startsWith("/") && !value.split(/[\\/]/u).includes("..");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/core/statusMapping.ts
+var statusAliases = /* @__PURE__ */ new Map([
+  ["active", "running"],
+  ["created", "idle"],
+  ["crashed", "failed"],
+  ["error", "failed"],
+  ["failed", "failed"],
+  ["idle", "idle"],
+  ["installed", "idle"],
+  ["installing", "installing"],
+  ["downloading_runtime", "preparing"],
+  ["launching", "starting"],
+  ["pending", "starting"],
+  ["preparing", "preparing"],
+  ["ready", "idle"],
+  ["running", "running"],
+  ["started", "running"],
+  ["starting", "starting"],
+  ["stopped", "idle"],
+  ["stopping", "stopping"],
+  ["terminated", "idle"],
+  ["terminating", "stopping"]
+]);
+function mapWorkspaceAppRuntimeStatus(value) {
+  if (typeof value !== "string") {
+    return "idle";
+  }
+  return statusAliases.get(value.trim().toLowerCase()) ?? "idle";
+}
+function normalizeWorkspaceAppRuntimeState(state) {
+  return {
+    ...state,
+    status: mapWorkspaceAppRuntimeStatus(state.status)
+  };
+}
+function resolveWorkspaceAppStatusPresentation(status) {
+  switch (status) {
+    case "installing":
+      return {
+        labelKey: "status.installing",
+        pulse: true,
+        tone: "blue"
+      };
+    case "preparing":
+      return {
+        labelKey: "status.preparing",
+        pulse: true,
+        tone: "blue"
+      };
+    case "starting":
+      return {
+        labelKey: "status.starting",
+        pulse: true,
+        tone: "blue"
+      };
+    case "running":
+      return {
+        labelKey: "status.running",
+        pulse: false,
+        tone: "green"
+      };
+    case "failed":
+      return {
+        labelKey: "status.failed",
+        pulse: false,
+        tone: "red"
+      };
+    case "stopping":
+      return {
+        labelKey: "status.stopping",
+        pulse: true,
+        tone: "amber"
+      };
+    case "idle":
+      return {
+        labelKey: "actions.openApp",
+        pulse: false,
+        tone: "neutral"
+      };
+  }
+}
+
+// src/core/appCenterViewModel.ts
+function createAppCenterViewModel({
+  apps,
+  factoryJobs = [],
+  locale = null,
+  replaceableIconAppIds = [],
+  runtimeStates = []
+}) {
+  const runtimeByAppId = new Map(
+    runtimeStates.map((state) => [
+      state.appId,
+      {
+        ...state,
+        status: mapWorkspaceAppRuntimeStatus(state.status)
+      }
+    ])
+  );
+  const appFactoryJobByAppId = createAppFactoryJobByAppId(factoryJobs);
+  const replaceableIconAppIdSet = new Set(
+    replaceableIconAppIds.map((appId) => appId.trim()).filter(Boolean)
+  );
+  const appCards = apps.map((app) => {
+    const runtime = runtimeByAppId.get(app.manifest.appId);
+    const factoryJob = appFactoryJobByAppId.get(app.manifest.appId);
+    const metadata = resolveWorkspaceAppCatalogMetadata({
+      catalog: app.catalog,
+      locale,
+      manifest: app.manifest
+    });
+    const factoryAgentSessionId = factoryJob?.agentSessionId?.trim() || null;
+    const status = runtime?.status ?? "idle";
+    const presentation = resolveWorkspaceAppStatusPresentation(status);
+    const installed = Boolean(app.install);
+    const sourceKind = resolveCatalogSourceKind(app.catalog);
+    const localApp = sourceKind === "local";
+    const comingSoon = isComingSoonApp(metadata.tags) || isComingSoonApp(app.manifest.tags ?? []);
+    const canUpdate = installed && (app.updateAvailable ?? false);
+    const canOpen = !comingSoon && installed && canOpenInstalledApp(status);
+    const canRetry = installed && status === "failed";
+    const primaryAction = resolvePrimaryAction({
+      canOpen,
+      canRetry,
+      canUpdate,
+      comingSoon,
+      installed,
+      status
+    });
+    return {
+      id: app.manifest.appId,
+      name: metadata.name,
+      createdAtUnixMs: app.createdAtUnixMs ?? null,
+      ...metadata.description ? { description: metadata.description } : {},
+      ...app.manifest.version && !comingSoon ? { version: app.manifest.version } : {},
+      ...app.availableVersion && !comingSoon ? { availableVersion: app.availableVersion } : {},
+      ...app.category?.trim() ? { category: app.category.trim() } : {},
+      updateAvailable: app.updateAvailable ?? false,
+      ...app.manifest.icon ? { icon: app.manifest.icon } : {},
+      tags: metadata.tags,
+      installed,
+      status,
+      statusLabelKey: comingSoon ? "status.comingSoon" : resolvePrimaryActionLabelKey(primaryAction, presentation.labelKey),
+      statusTone: presentation.tone,
+      statusPulse: presentation.pulse,
+      primaryAction,
+      sourceKind,
+      canOpen,
+      canExport: localApp,
+      canDelete: localApp,
+      canReplaceIcon: replaceableIconAppIdSet.has(app.manifest.appId),
+      canOpenFolder: installed,
+      canOpenPackageFolder: installed && localApp && Boolean(app.manifest.version?.trim()),
+      canOpenFactorySession: Boolean(factoryAgentSessionId),
+      canPublishFactoryUpdate: installed && factoryJob?.status === "ready" && Boolean(factoryJob.publishedVersion?.trim()),
+      canUninstall: installed,
+      canRetry,
+      canUpdate,
+      ...factoryAgentSessionId ? { factoryAgentSessionId } : {},
+      ...factoryJob?.jobId ? { factoryJobId: factoryJob.jobId } : {},
+      ...factoryJob?.provider ? { factoryProvider: factoryJob.provider } : {},
+      ...runtime?.error?.message ? { errorMessage: runtime.error.message } : {}
+    };
+  }).sort((left, right) => left.name.localeCompare(right.name));
+  return {
+    apps: appCards,
+    factoryJobs: factoryJobs.filter((job) => !isPublishedAppFactoryJob(job)).map(createFactoryJobViewModel),
+    empty: appCards.length === 0,
+    failedCount: appCards.filter((app) => app.status === "failed").length,
+    installedCount: appCards.filter((app) => app.installed).length,
+    runningCount: appCards.filter((app) => app.status === "running").length
+  };
+}
+function resolveCatalogSourceKind(catalog) {
+  return catalog?.source?.kind ?? "bundled";
+}
+function resolveWorkspaceAppCatalogMetadata(input) {
+  const manifest = input.manifest;
+  const localization = findWorkspaceAppCatalogLocalization(
+    input.catalog,
+    input.locale
+  );
+  const name = localization?.name?.trim() || manifest.name;
+  const description = localization?.description?.trim() || manifest.description || "";
+  const tags = localization?.tags?.map((tag) => tag.trim()).filter((tag) => tag.length > 0) ?? manifest.tags ?? [];
+  return {
+    description,
+    name,
+    tags: Array.from(new Set(tags))
+  };
+}
+function findWorkspaceAppCatalogLocalization(catalog, locale) {
+  const localizations = catalog?.localizations ?? [];
+  const normalizedLocale = normalizeLocale(locale);
+  if (!normalizedLocale || localizations.length === 0) {
+    return null;
+  }
+  const exact = localizations.find(
+    (localization) => normalizeLocale(localization.locale) === normalizedLocale
+  );
+  if (exact) {
+    return exact;
+  }
+  const language = normalizedLocale.split("-")[0];
+  if (!language) {
+    return null;
+  }
+  return localizations.find(
+    (localization) => normalizeLocale(localization.locale)?.split("-")[0] === language
+  ) ?? null;
+}
+function normalizeLocale(value) {
+  const normalized = value?.trim().replace(/_/gu, "-").toLowerCase() ?? "";
+  return normalized.length > 0 ? normalized : null;
+}
+function resolvePrimaryAction(input) {
+  if (input.comingSoon) {
+    return "none";
+  }
+  if (isBusyRuntimeStatus(input.status)) {
+    return "none";
+  }
+  if (!input.installed) {
+    return "install";
+  }
+  if (input.canUpdate) {
+    return "update";
+  }
+  if (input.canRetry) {
+    return "retry";
+  }
+  if (input.canOpen) {
+    return "open";
+  }
+  return "none";
+}
+function isComingSoonApp(tags) {
+  return tags.some((tag) => tag.trim().toLowerCase() === "coming-soon");
+}
+function canOpenInstalledApp(status) {
+  return status === "idle" || status === "running";
+}
+function isBusyRuntimeStatus(status) {
+  return status === "installing" || status === "preparing" || status === "starting" || status === "stopping";
+}
+function resolvePrimaryActionLabelKey(primaryAction, fallbackLabelKey) {
+  switch (primaryAction) {
+    case "install":
+      return "actions.installApp";
+    case "open":
+      return "actions.openApp";
+    case "retry":
+      return "actions.retryApp";
+    case "update":
+      return "actions.updateApp";
+    case "none":
+      return fallbackLabelKey;
+  }
+}
+function createAppFactoryJobByAppId(factoryJobs) {
+  const result = /* @__PURE__ */ new Map();
+  for (const job of [...factoryJobs].sort(
+    (left, right) => right.updatedAtUnixMs - left.updatedAtUnixMs
+  )) {
+    if (!isPublishedAppFactoryJob(job)) {
+      continue;
+    }
+    const appId = job.appId?.trim();
+    if (!appId || result.has(appId)) {
+      continue;
+    }
+    result.set(appId, job);
+  }
+  return result;
+}
+function isPublishedAppFactoryJob(job) {
+  return job.status === "published" || Boolean(job.publishedVersion?.trim());
+}
+function createFactoryJobViewModel(job) {
+  const statusLabelKey = `factory.status.${job.status}`;
+  const title = job.displayName.trim();
+  const agentSessionId = job.agentSessionId?.trim() || null;
+  const canFixValidationFailure = job.status === "failed" && job.validationResult != null;
+  return {
+    id: job.jobId,
+    agentSessionId,
+    appId: job.appId,
+    title,
+    prompt: job.prompt,
+    provider: job.provider,
+    status: job.status,
+    statusLabelKey,
+    canCancel: job.status === "queued" || job.status === "generating" || job.status === "preparing" || job.status === "validating",
+    canDelete: job.status === "canceled" || job.status === "failed" || job.status === "published" || job.status === "ready",
+    canFix: canFixValidationFailure,
+    canOpenAgentSession: Boolean(agentSessionId),
+    canPublish: job.status === "ready",
+    canRetryValidation: canFixValidationFailure,
+    failureReason: job.failureReason,
+    updatedAtUnixMs: job.updatedAtUnixMs
+  };
+}
+function createWorkspaceAppRecord(input) {
+  const manifest = input.catalog?.manifest;
+  if (!manifest) {
+    throw new Error("catalog manifest is required.");
+  }
+  return {
+    catalog: input.catalog,
+    category: input.category,
+    createdAtUnixMs: input.createdAtUnixMs ?? null,
+    install: input.install ?? null,
+    manifest
+  };
+}
+
+export {
+  workspaceAppIdPattern,
+  isWorkspaceAppId,
+  normalizeWorkspaceAppId,
+  createWorkspaceAppIdentity,
+  validateWorkspaceAppManifest,
+  mapWorkspaceAppRuntimeStatus,
+  normalizeWorkspaceAppRuntimeState,
+  resolveWorkspaceAppStatusPresentation,
+  createAppCenterViewModel,
+  resolveWorkspaceAppCatalogMetadata,
+  createWorkspaceAppRecord
+};
+//# sourceMappingURL=chunk-FENSLRNH.js.map