@treeseed/sdk 0.10.28 → 0.11.0

package/dist/db/market-schema.js

@@ -1236,6 +1236,104 @@ const hubContentSources = pgTable("hub_content_sources", {
   createdAt: text("created_at").notNull(),
   updatedAt: text("updated_at").notNull()
 });
+const treeDxInstances = pgTable("treedx_instances", {
+  id: text("id").primaryKey(),
+  teamId: text("team_id").notNull(),
+  kind: text("kind").notNull(),
+  provider: text("provider").notNull(),
+  name: text("name").notNull(),
+  baseUrl: text("base_url"),
+  registryUrl: text("registry_url"),
+  publicRead: integer("public_read").notNull().default(0),
+  primary: integer("primary").notNull().default(1),
+  status: text("status").notNull().default("pending"),
+  imageRef: text("image_ref"),
+  railwayProjectId: text("railway_project_id"),
+  railwayServiceId: text("railway_service_id"),
+  railwayEnvironmentId: text("railway_environment_id"),
+  volumeMountPath: text("volume_mount_path"),
+  metadataJson: text("metadata_json").notNull().default("{}"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull()
+}, (table) => [
+  index("idx_treedx_instances_team_status").on(table.teamId, table.status)
+]);
+const treeDxProjectLibraries = pgTable("treedx_project_libraries", {
+  id: text("id").primaryKey(),
+  teamId: text("team_id").notNull(),
+  projectId: text("project_id").notNull(),
+  instanceId: text("instance_id").notNull(),
+  libraryId: text("library_id").notNull(),
+  repositoryId: text("repository_id"),
+  contentPath: text("content_path").notNull().default("src/content"),
+  contentRepositoryUrl: text("content_repository_url"),
+  contentRepositoryDefaultBranch: text("content_repository_default_branch"),
+  contentRepositoryRef: text("content_repository_ref"),
+  r2BucketName: text("r2_bucket_name"),
+  r2ManifestKey: text("r2_manifest_key"),
+  topologyJson: text("topology_json").notNull().default("{}"),
+  metadataJson: text("metadata_json").notNull().default("{}"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull()
+}, (table) => [
+  uniqueIndex("idx_treedx_project_libraries_project").on(table.projectId),
+  index("idx_treedx_project_libraries_instance").on(table.instanceId)
+]);
+const treeDxMirrors = pgTable("treedx_mirrors", {
+  id: text("id").primaryKey(),
+  teamId: text("team_id").notNull(),
+  instanceId: text("instance_id").notNull(),
+  name: text("name").notNull(),
+  direction: text("direction").notNull().default("bidirectional"),
+  targetKind: text("target_kind").notNull(),
+  targetUrl: text("target_url"),
+  status: text("status").notNull().default("pending"),
+  instructions: text("instructions"),
+  lastSyncAt: text("last_sync_at"),
+  lastSyncStatus: text("last_sync_status"),
+  lastSyncMetadataJson: text("last_sync_metadata_json").notNull().default("{}"),
+  metadataJson: text("metadata_json").notNull().default("{}"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull()
+}, (table) => [
+  index("idx_treedx_mirrors_team_instance").on(table.teamId, table.instanceId)
+]);
+const treeDxShares = pgTable("treedx_shares", {
+  id: text("id").primaryKey(),
+  teamId: text("team_id").notNull(),
+  instanceId: text("instance_id"),
+  projectId: text("project_id"),
+  libraryId: text("library_id"),
+  scope: text("scope").notNull(),
+  targetTeamId: text("target_team_id"),
+  trustGrantJson: text("trust_grant_json").notNull().default("{}"),
+  publicRead: integer("public_read").notNull().default(0),
+  status: text("status").notNull().default("active"),
+  expiresAt: text("expires_at"),
+  metadataJson: text("metadata_json").notNull().default("{}"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull(),
+  revokedAt: text("revoked_at")
+}, (table) => [
+  index("idx_treedx_shares_team_scope").on(table.teamId, table.scope, table.status)
+]);
+const treeDxDeployments = pgTable("treedx_deployments", {
+  id: text("id").primaryKey(),
+  teamId: text("team_id").notNull(),
+  instanceId: text("instance_id"),
+  provider: text("provider").notNull(),
+  status: text("status").notNull().default("queued"),
+  imageRef: text("image_ref"),
+  volumeMountPath: text("volume_mount_path"),
+  serviceRefsJson: text("service_refs_json").notNull().default("{}"),
+  resultJson: text("result_json").notNull().default("{}"),
+  errorJson: text("error_json"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull(),
+  completedAt: text("completed_at")
+}, (table) => [
+  index("idx_treedx_deployments_team_instance").on(table.teamId, table.instanceId, table.createdAt)
+]);
 const hubLaunches = pgTable("hub_launches", {
   id: text("id").primaryKey(),
   hubId: text("hub_id").notNull(),
@@ -1743,6 +1841,11 @@ const treeseedMarketSchema = {
   repositoryHosts,
   hubRepositories,
   hubContentSources,
+  treeDxInstances,
+  treeDxProjectLibraries,
+  treeDxMirrors,
+  treeDxShares,
+  treeDxDeployments,
   hubLaunches,
   hubLaunchEvents,
   hubWorkspaceLinks,
@@ -1864,6 +1967,11 @@ export {
   teamStorageLocators,
   teamWebHosts,
   teams,
+  treeDxDeployments,
+  treeDxInstances,
+  treeDxMirrors,
+  treeDxProjectLibraries,
+  treeDxShares,
   treeseedMarketSchema,
   userEmailAddresses,
   userIdentities,

package/dist/db/node-sqlite.js

@@ -6,8 +6,12 @@ import { treeseedSchema } from "./schema.js";
 function isDirectoryLike(path) {
   return !/\.(sqlite|sqlite3|db)$/iu.test(path);
 }
+function isInMemorySqlitePath(path) {
+  return path === ":memory:";
+}
 function resolveTreeseedSqlitePath(input) {
   const base = input?.trim() || ".treeseed/generated/environments/local/site-data.sqlite";
+  if (isInMemorySqlitePath(base)) return base;
   if (!isDirectoryLike(base)) return resolve(base);
   const miniflareRoot = resolve(base, "miniflare-D1DatabaseObject");
   if (existsSync(miniflareRoot)) {
@@ -70,10 +74,11 @@ class NodeSqliteD1Database {
   path;
   constructor(path) {
     this.path = resolveTreeseedSqlitePath(path);
-    mkdirSync(dirname(this.path), { recursive: true });
+    const inMemory = isInMemorySqlitePath(this.path);
+    if (!inMemory) mkdirSync(dirname(this.path), { recursive: true });
     this.client = new DatabaseSync(this.path);
     this.client.exec("PRAGMA foreign_keys = ON;");
-    this.client.exec("PRAGMA journal_mode = WAL;");
+    if (!inMemory) this.client.exec("PRAGMA journal_mode = WAL;");
   }
   prepare(query) {
     return new NodeSqliteD1PreparedStatement(this.client, query);

package/dist/hosting/apps.d.ts

@@ -0,0 +1,12 @@
+import type { TreeseedDeployConfig } from '../platform/contracts.ts';
+export interface TreeseedDiscoveredApplication {
+    id: string;
+    label: string;
+    root: string;
+    configPath: string;
+    relativeRoot: string;
+    config: TreeseedDeployConfig;
+    roles: string[];
+}
+export declare function discoverTreeseedApplications(workspaceRootInput: string): TreeseedDiscoveredApplication[];
+export declare function findTreeseedApplication(workspaceRoot: string, appId: string): TreeseedDiscoveredApplication | null;

package/dist/hosting/apps.js

@@ -0,0 +1,107 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { loadTreeseedDeployConfigFromPath } from "../platform/deploy-config.js";
+const IGNORED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".treeseed",
+  ".astro",
+  ".cache",
+  "dist",
+  "node_modules",
+  "coverage",
+  "target"
+]);
+function readPackageJson(root) {
+  try {
+    return JSON.parse(readFileSync(resolve(root, "package.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function workspacePackageRoots(root) {
+  const packageJson = readPackageJson(root);
+  const workspaces = Array.isArray(packageJson?.workspaces) ? packageJson.workspaces : packageJson?.workspaces && typeof packageJson.workspaces === "object" && Array.isArray(packageJson.workspaces.packages) ? packageJson.workspaces.packages : [];
+  const roots = /* @__PURE__ */ new Set();
+  for (const pattern of workspaces) {
+    if (typeof pattern !== "string") continue;
+    const normalized = pattern.trim();
+    if (!normalized.endsWith("/*")) continue;
+    const base = resolve(root, normalized.slice(0, -2));
+    if (!existsSync(base)) continue;
+    for (const entry of readdirSync(base, { withFileTypes: true })) {
+      if (!entry.isDirectory() || IGNORED_DIRS.has(entry.name)) continue;
+      roots.add(resolve(base, entry.name));
+    }
+  }
+  return [...roots].sort();
+}
+function applicationRoles(config) {
+  const roles = [];
+  if (config.surfaces?.web?.enabled !== false && config.surfaces?.web) roles.push("web");
+  if (config.surfaces?.api?.enabled === true || config.services?.api?.enabled !== false && config.services?.api) roles.push("api");
+  if (config.services?.operationsRunner?.enabled !== false && config.services?.operationsRunner) roles.push("operations-runner");
+  if (config.hosting?.kind === "treeseed_control_plane") roles.push("treeseed-control-plane");
+  return [...new Set(roles)];
+}
+function inferApplicationId(config, root, workspaceRoot) {
+  const roles = applicationRoles(config);
+  const hasBackendServices = Boolean(config.services?.api || config.services?.operationsRunner || config.services?.treeseedDatabase);
+  if (config.hosting?.kind === "treeseed_control_plane" || roles.includes("api") || roles.includes("operations-runner")) {
+    return "api";
+  }
+  if (roles.includes("web") && !hasBackendServices && root === workspaceRoot) {
+    const configuredRootId = config.hosting?.projectId ?? config.runtime?.projectId ?? null;
+    if (configuredRootId && configuredRootId !== "market") {
+      return configuredRootId.replace(/^treeseed-/u, "").replace(/[^a-z0-9-]+/giu, "-").replace(/^-|-$/gu, "") || "web";
+    }
+    return "web";
+  }
+  const relative = root === workspaceRoot ? "." : root.slice(workspaceRoot.length + 1).replaceAll("\\", "/");
+  const configuredId = config.hosting?.projectId ?? config.runtime?.projectId ?? config.slug ?? relative;
+  return (configuredId || "app").replace(/^treeseed-/u, "").replace(/[^a-z0-9-]+/giu, "-").replace(/^-|-$/gu, "") || "app";
+}
+function appFromConfigPath(configPath, workspaceRoot) {
+  const root = dirname(configPath);
+  const config = loadTreeseedDeployConfigFromPath(configPath);
+  const roles = applicationRoles(config);
+  const id = inferApplicationId(config, root, workspaceRoot);
+  const relativeRoot = root === workspaceRoot ? "." : root.slice(workspaceRoot.length + 1).replaceAll("\\", "/");
+  return {
+    id,
+    label: config.name,
+    root,
+    configPath,
+    relativeRoot,
+    config,
+    roles
+  };
+}
+function discoverTreeseedApplications(workspaceRootInput) {
+  const workspaceRoot = resolve(workspaceRootInput);
+  const candidates = [
+    workspaceRoot,
+    ...workspacePackageRoots(workspaceRoot)
+  ];
+  const seenIds = /* @__PURE__ */ new Set();
+  const apps = [];
+  for (const root of candidates) {
+    const configPath = resolve(root, "treeseed.site.yaml");
+    if (!existsSync(configPath)) continue;
+    const app = appFromConfigPath(configPath, workspaceRoot);
+    let id = app.id;
+    let suffix = 2;
+    while (seenIds.has(id)) {
+      id = `${app.id}-${suffix++}`;
+    }
+    seenIds.add(id);
+    apps.push({ ...app, id });
+  }
+  return apps;
+}
+function findTreeseedApplication(workspaceRoot, appId) {
+  return discoverTreeseedApplications(workspaceRoot).find((app) => app.id === appId || app.relativeRoot === appId) ?? null;
+}
+export {
+  discoverTreeseedApplications,
+  findTreeseedApplication
+};

package/dist/hosting/builtins.d.ts

@@ -0,0 +1,25 @@
+import type { TreeseedApplicationHostingProfile, TreeseedHostAdapter, TreeseedHostCapability, TreeseedHostingEnvironment, TreeseedHostingStatus, TreeseedHostingUnit, TreeseedServicePlacement, TreeseedServiceTypeAdapter } from './contracts.ts';
+export declare function createDefaultHostAdapters(): Record<string, TreeseedHostAdapter>;
+export declare function createDefaultServiceTypeAdapters(): Record<string, TreeseedServiceTypeAdapter>;
+export declare function createDefaultHostingProfiles(): TreeseedApplicationHostingProfile[];
+export declare function sanitizedUnitConfig(unit: TreeseedHostingUnit): {
+    id: string;
+    label: string;
+    serviceType: string;
+    placement: TreeseedServicePlacement;
+    hostId: string;
+    environment: TreeseedHostingEnvironment;
+    projectGroupId: string | null;
+    requiredCapabilities: TreeseedHostCapability[];
+    secretRefs: string[];
+    variableRefs: string[];
+    application: {
+        id: string;
+        relativeRoot: string;
+        roles: string[];
+    } | null;
+    config: unknown;
+    metadata: unknown;
+};
+export declare function redactSensitiveConfig(value: unknown): unknown;
+export declare function summarizePlacementStatus(statuses: TreeseedHostingStatus[]): TreeseedHostingStatus;