@treeseed/sdk 0.1.1 → 0.3.0

package/dist/operations/services/local-dev.js

@@ -0,0 +1,106 @@
+import { spawn, spawnSync } from "node:child_process";
+import { resolve } from "node:path";
+import { runLocalD1Migrations as applyLocalD1Migrations } from "./d1-migration.js";
+import {
+  fixtureMigrationsRoot,
+  fixtureRoot,
+  fixtureWranglerConfig,
+  corePackageRoot
+} from "./runtime-paths.js";
+function mergeEnv(extraEnv = {}) {
+  return { ...process.env, ...extraEnv };
+}
+function runStep(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    stdio: "inherit",
+    shell: process.platform === "win32",
+    env: mergeEnv(options.env),
+    cwd: options.cwd ?? process.cwd()
+  });
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
+  }
+}
+function runNodeScript(scriptRelativePath, args = [], options = {}) {
+  return runStep(process.execPath, [resolve(corePackageRoot, scriptRelativePath), ...args], {
+    ...options,
+    cwd: options.cwd ?? corePackageRoot
+  });
+}
+function spawnProcess(command, args, options = {}) {
+  return spawn(command, args, {
+    stdio: options.stdio ?? "inherit",
+    shell: process.platform === "win32",
+    env: mergeEnv(options.env),
+    cwd: options.cwd ?? process.cwd(),
+    detached: options.detached ?? false
+  });
+}
+function syncDevVars(overrides = {}) {
+  const overrideEntries = Object.entries(overrides);
+  runNodeScript(
+    "./scripts/sync-dev-vars.js",
+    overrideEntries.map(([key, value]) => `${key}=${value}`),
+    { cwd: fixtureRoot }
+  );
+}
+function runLocalD1Migration(persistTo) {
+  applyLocalD1Migrations({
+    cwd: fixtureRoot,
+    wranglerConfig: fixtureWranglerConfig,
+    migrationsRoot: fixtureMigrationsRoot,
+    persistTo
+  });
+}
+function prepareCloudflareLocalRuntime({ envOverrides = {}, persistTo, outDir } = {}) {
+  const mergedEnvOverrides = {
+    TREESEED_MAILPIT_SMTP_HOST: "127.0.0.1",
+    TREESEED_MAILPIT_SMTP_PORT: "1025",
+    ...envOverrides
+  };
+  runNodeScript("./scripts/patch-starlight-content-path.js");
+  runNodeScript("./scripts/aggregate-book.js");
+  runNodeScript("./scripts/ensure-mailpit.js");
+  syncDevVars({
+    TREESEED_LOCAL_DEV_MODE: "cloudflare",
+    ...mergedEnvOverrides
+  });
+  runLocalD1Migration(persistTo);
+  const astroArgs = ["astro", "build", "--root", fixtureRoot];
+  if (outDir) {
+    astroArgs.push("--outDir", outDir);
+  }
+  runStep("npx", astroArgs, {
+    env: {
+      TREESEED_LOCAL_DEV_MODE: "cloudflare",
+      ...mergedEnvOverrides
+    },
+    cwd: corePackageRoot
+  });
+  runNodeScript("./scripts/build-tenant-worker.js", [], {
+    cwd: fixtureRoot,
+    env: {
+      TREESEED_LOCAL_DEV_MODE: "cloudflare",
+      ...mergedEnvOverrides
+    }
+  });
+}
+function startWranglerDev(args = [], options = {}) {
+  return spawnProcess(
+    "wrangler",
+    ["dev", "--local", "--config", fixtureWranglerConfig, ...args],
+    {
+      ...options,
+      cwd: options.cwd ?? fixtureRoot
+    }
+  );
+}
+export {
+  prepareCloudflareLocalRuntime,
+  runLocalD1Migration,
+  runNodeScript,
+  runStep,
+  spawnProcess,
+  startWranglerDev,
+  syncDevVars
+};

package/dist/operations/services/mailpit-runtime.d.ts

@@ -0,0 +1,4 @@
+export declare function dockerIsAvailable(): boolean;
+export declare function findRunningMailpitContainer(): any;
+export declare function stopKnownMailpitContainers(): boolean;
+export declare function streamKnownMailpitLogs(): void;

package/dist/operations/services/mailpit-runtime.js

@@ -0,0 +1,59 @@
+import { spawnSync } from "node:child_process";
+const EXPECTED_PORTS = ["1025->1025/tcp", "8025->8025/tcp"];
+const KNOWN_MAILPIT_NAMES = ["treeseed_mailpit", "karyon_docs_mailpit"];
+function runDocker(args, options = {}) {
+  return spawnSync("docker", args, {
+    encoding: "utf8",
+    ...options
+  });
+}
+function parseDockerPsOutput(stdout) {
+  return stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => {
+    const [name = "", image = "", ports = ""] = line.split("	");
+    return { name, image, ports };
+  });
+}
+function isCompatibleMailpitContainer(container) {
+  const nameMatch = KNOWN_MAILPIT_NAMES.includes(container.name);
+  const imageMatch = container.image.includes("mailpit");
+  const portsMatch = EXPECTED_PORTS.every((port) => container.ports.includes(port));
+  return (nameMatch || imageMatch) && portsMatch;
+}
+function dockerIsAvailable() {
+  const result = runDocker(["ps", "--format", "{{.Names}}	{{.Image}}	{{.Ports}}"]);
+  return result.status === 0;
+}
+function findRunningMailpitContainer() {
+  const result = runDocker(["ps", "--format", "{{.Names}}	{{.Image}}	{{.Ports}}"]);
+  if (result.status !== 0) {
+    return null;
+  }
+  return parseDockerPsOutput(result.stdout).find(isCompatibleMailpitContainer) ?? null;
+}
+function stopKnownMailpitContainers() {
+  const container = findRunningMailpitContainer();
+  if (!container) {
+    return true;
+  }
+  const stopResult = runDocker(["stop", container.name], { stdio: "inherit" });
+  if (stopResult.status !== 0) {
+    return false;
+  }
+  const removeResult = runDocker(["rm", "-f", container.name], { stdio: "inherit" });
+  return removeResult.status === 0;
+}
+function streamKnownMailpitLogs() {
+  const container = findRunningMailpitContainer();
+  if (!container) {
+    console.error("No running Mailpit container was found on ports 1025 and 8025.");
+    process.exit(1);
+  }
+  const result = runDocker(["logs", "-f", container.name], { stdio: "inherit" });
+  process.exit(result.status ?? 1);
+}
+export {
+  dockerIsAvailable,
+  findRunningMailpitContainer,
+  stopKnownMailpitContainers,
+  streamKnownMailpitLogs
+};

package/dist/operations/services/railway-deploy.d.ts

@@ -0,0 +1,53 @@
+export declare function configuredRailwayServices(tenantRoot: any, scope: any): ({
+    key: string;
+    scope: string;
+    projectId: string | null;
+    projectName: string | null;
+    serviceId: string | null;
+    serviceName: string | null;
+    rootDir: string;
+    publicBaseUrl: string | null;
+    railwayEnvironment: string;
+    buildCommand: string | null;
+    startCommand: string | null;
+} | null)[];
+export declare function validateRailwayServiceConfiguration(tenantRoot: any, scope: any): ({
+    key: string;
+    scope: string;
+    projectId: string | null;
+    projectName: string | null;
+    serviceId: string | null;
+    serviceName: string | null;
+    rootDir: string;
+    publicBaseUrl: string | null;
+    railwayEnvironment: string;
+    buildCommand: string | null;
+    startCommand: string | null;
+} | null)[];
+export declare function validateRailwayDeployPrerequisites(tenantRoot: any, scope: any): ({
+    key: string;
+    scope: string;
+    projectId: string | null;
+    projectName: string | null;
+    serviceId: string | null;
+    serviceName: string | null;
+    rootDir: string;
+    publicBaseUrl: string | null;
+    railwayEnvironment: string;
+    buildCommand: string | null;
+    startCommand: string | null;
+} | null)[];
+export declare function planRailwayServiceDeploy(service: any): {
+    command: string;
+    args: any[];
+    cwd: any;
+};
+export declare function deployRailwayService(tenantRoot: any, service: any, { dryRun }?: {
+    dryRun?: boolean | undefined;
+}): {
+    service: any;
+    status: string;
+    command: string;
+    cwd: any;
+    publicBaseUrl: any;
+};

package/dist/operations/services/railway-deploy.js

@@ -0,0 +1,123 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import { loadCliDeployConfig } from "./runtime-tools.js";
+function normalizeScope(scope) {
+  return scope === "prod" ? "prod" : scope === "staging" ? "staging" : "local";
+}
+const RAILWAY_SERVICE_KEYS = ["api", "agents", "manager", "worker", "workdayStart", "workdayReport"];
+function runRailway(args, { cwd, capture = false, allowFailure = false } = {}) {
+  const result = spawnSync("railway", args, {
+    cwd,
+    stdio: capture ? "pipe" : "inherit",
+    encoding: "utf8",
+    env: { ...process.env }
+  });
+  if (result.status !== 0 && !allowFailure) {
+    throw new Error(result.stderr?.trim() || result.stdout?.trim() || `railway ${args.join(" ")} failed`);
+  }
+  return result;
+}
+function configuredRailwayServices(tenantRoot, scope) {
+  const deployConfig = loadCliDeployConfig(tenantRoot);
+  const normalizedScope = normalizeScope(scope);
+  return RAILWAY_SERVICE_KEYS.map((serviceKey) => {
+    const service = deployConfig.services?.[serviceKey];
+    if (!service || service.enabled === false || (service.provider ?? "railway") !== "railway") {
+      return null;
+    }
+    const defaultRootDir = serviceKey === "api" ? "packages/api" : "packages/agent";
+    const serviceRoot = resolve(tenantRoot, service.railway?.rootDir ?? service.rootDir ?? defaultRootDir);
+    const railwayEnvironment = service.environments?.[normalizedScope]?.railwayEnvironment ?? normalizedScope;
+    const publicBaseUrl = service.environments?.[normalizedScope]?.baseUrl ?? service.publicBaseUrl ?? null;
+    return {
+      key: serviceKey,
+      scope: normalizedScope,
+      projectId: service.railway?.projectId ?? null,
+      projectName: service.railway?.projectName ?? null,
+      serviceId: service.railway?.serviceId ?? null,
+      serviceName: service.railway?.serviceName ?? null,
+      rootDir: serviceRoot,
+      publicBaseUrl,
+      railwayEnvironment,
+      buildCommand: service.railway?.buildCommand ?? null,
+      startCommand: service.railway?.startCommand ?? null
+    };
+  }).filter(Boolean);
+}
+function validateRailwayServiceConfiguration(tenantRoot, scope) {
+  const services = configuredRailwayServices(tenantRoot, scope);
+  const issues = [];
+  for (const service of services) {
+    if (!service.serviceName && !service.serviceId) {
+      issues.push(`${service.key}: set railway.serviceName or railway.serviceId in treeseed.site.yaml.`);
+    }
+    if (!service.projectName && !service.projectId) {
+      issues.push(`${service.key}: set railway.projectName or railway.projectId in treeseed.site.yaml.`);
+    }
+    if (!existsSync(service.rootDir)) {
+      issues.push(`${service.key}: service root ${service.rootDir} does not exist.`);
+    }
+  }
+  if (issues.length > 0) {
+    throw new Error(`Railway service configuration is incomplete:
+- ${issues.join("\n- ")}`);
+  }
+  return services;
+}
+function validateRailwayDeployPrerequisites(tenantRoot, scope) {
+  const services = validateRailwayServiceConfiguration(tenantRoot, scope);
+  const token = process.env.RAILWAY_API_TOKEN;
+  if (typeof token !== "string" || token.trim().length === 0) {
+    throw new Error("Configure RAILWAY_API_TOKEN before deploying Railway-managed services.");
+  }
+  return services;
+}
+function planRailwayServiceDeploy(service) {
+  const args = ["up", "--service", service.serviceName ?? service.serviceId, "--ci"];
+  if (service.railwayEnvironment) {
+    args.push("--environment", service.railwayEnvironment);
+  }
+  return {
+    command: "railway",
+    args,
+    cwd: service.rootDir
+  };
+}
+function deployRailwayService(tenantRoot, service, { dryRun = false } = {}) {
+  const plan = planRailwayServiceDeploy(service);
+  if (dryRun) {
+    return {
+      service: service.key,
+      status: "planned",
+      command: [plan.command, ...plan.args].join(" "),
+      cwd: plan.cwd,
+      publicBaseUrl: service.publicBaseUrl
+    };
+  }
+  if (service.buildCommand) {
+    const buildResult = spawnSync("bash", ["-lc", service.buildCommand], {
+      cwd: service.rootDir,
+      stdio: "inherit",
+      env: { ...process.env }
+    });
+    if (buildResult.status !== 0) {
+      throw new Error(`Railway ${service.key} build command failed.`);
+    }
+  }
+  runRailway(plan.args, { cwd: service.rootDir });
+  return {
+    service: service.key,
+    status: "deployed",
+    command: [plan.command, ...plan.args].join(" "),
+    cwd: plan.cwd,
+    publicBaseUrl: service.publicBaseUrl
+  };
+}
+export {
+  configuredRailwayServices,
+  deployRailwayService,
+  planRailwayServiceDeploy,
+  validateRailwayDeployPrerequisites,
+  validateRailwayServiceConfiguration
+};

package/dist/operations/services/runtime-paths.d.ts

@@ -0,0 +1,19 @@
+import { corePackageRoot, packageRoot } from './runtime-tools.ts';
+export declare const cliPackageRoot: string;
+export { corePackageRoot, packageRoot };
+export declare const workspaceRoot: string;
+export declare const templatesRoot: string;
+export declare const examplesRoot: string;
+export declare const fixturesRoot: string;
+export declare const referenceAppsRoot: string;
+export declare const toolingRoot: string;
+export declare const servicesRoot: string;
+export declare const mailpitComposeFile: string;
+export declare const fixtureRoot: string;
+export declare const fixtureWranglerConfig: string;
+export declare const fixtureMigrationsRoot: string;
+export declare const fixtureSrcRoot: string;
+export declare const templateCatalogRoot: string;
+export declare const localTemplateArtifactsRoot: string;
+export declare const cliPackageVersion: any;
+export declare const corePackageVersion: any;

package/dist/operations/services/runtime-paths.js

@@ -0,0 +1,54 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { corePackageRoot, packageRoot, runtimeRoot } from "./runtime-tools.js";
+const pathsRuntimeRoot = resolve(fileURLToPath(new URL("..", import.meta.url)));
+const cliPackageRoot = packageRoot;
+const cliRuntimeRoot = runtimeRoot ?? pathsRuntimeRoot;
+const workspaceRoot = resolve(cliPackageRoot, "..");
+function resolveProjectRoot(localPath, workspacePath) {
+  return existsSync(localPath) ? localPath : workspacePath;
+}
+function readPackageVersion(packageDir, fallback = "0.0.0") {
+  const packageJsonPath = resolve(packageDir, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return fallback;
+  }
+  return JSON.parse(readFileSync(packageJsonPath, "utf8")).version ?? fallback;
+}
+const templatesRoot = resolveProjectRoot(resolve(cliPackageRoot, "templates"), resolve(workspaceRoot, "templates"));
+const examplesRoot = resolveProjectRoot(resolve(cliPackageRoot, "examples"), resolve(workspaceRoot, "examples"));
+const fixturesRoot = resolveProjectRoot(resolve(cliPackageRoot, ".fixtures", "treeseed-fixtures"), resolve(workspaceRoot, "fixtures"));
+const referenceAppsRoot = resolveProjectRoot(resolve(cliPackageRoot, "reference-apps"), resolve(workspaceRoot, "reference-apps"));
+const toolingRoot = resolveProjectRoot(resolve(cliPackageRoot, "tooling"), resolve(workspaceRoot, "tooling"));
+const servicesRoot = resolve(cliRuntimeRoot, "services");
+const mailpitComposeFile = resolve(servicesRoot, "compose.yml");
+const fixtureRoot = resolve(corePackageRoot, "fixture");
+const fixtureWranglerConfig = resolve(fixtureRoot, "wrangler.toml");
+const fixtureMigrationsRoot = resolve(fixtureRoot, "migrations");
+const fixtureSrcRoot = resolve(fixtureRoot, "src");
+const templateCatalogRoot = resolve(cliRuntimeRoot, "template-catalog");
+const localTemplateArtifactsRoot = resolve(templateCatalogRoot, "templates");
+const cliPackageVersion = readPackageVersion(cliPackageRoot);
+const corePackageVersion = readPackageVersion(corePackageRoot);
+export {
+  cliPackageRoot,
+  cliPackageVersion,
+  corePackageRoot,
+  corePackageVersion,
+  examplesRoot,
+  fixtureMigrationsRoot,
+  fixtureRoot,
+  fixtureSrcRoot,
+  fixtureWranglerConfig,
+  fixturesRoot,
+  localTemplateArtifactsRoot,
+  mailpitComposeFile,
+  packageRoot,
+  referenceAppsRoot,
+  servicesRoot,
+  templateCatalogRoot,
+  templatesRoot,
+  toolingRoot,
+  workspaceRoot
+};

package/dist/operations/services/runtime-tools.d.ts

@@ -0,0 +1,117 @@
+export declare const packageRoot: string;
+export declare const packageScriptRoot: string;
+export declare const runtimeRoot: string;
+export declare function treeseedWorkspacePackageCheckoutState(root?: string): {
+    mode: string;
+    packages: {
+        dirName: string;
+        dir: string;
+        present: boolean;
+    }[];
+    missing: {
+        dirName: string;
+        dir: string;
+        present: boolean;
+    }[];
+};
+export declare function resolveAstroBin(): string;
+export declare function resolveWranglerBin(): string;
+export declare const corePackageRoot: string;
+export declare const sdkPackageRoot: string;
+export declare const agentPackageRoot: string;
+export declare function loadPackageJson(root?: string): any;
+export declare function isWorkspaceRoot(root?: string): boolean;
+export declare function createProductionBuildEnv(extraEnv?: {}): {
+    TREESEED_LOCAL_DEV_MODE: string;
+    TREESEED_PUBLIC_FORMS_LOCAL_BYPASS_TURNSTILE: string;
+    TREESEED_FORMS_LOCAL_BYPASS_TURNSTILE: string;
+    TREESEED_FORMS_LOCAL_BYPASS_CLOUDFLARE_GUARDS: string;
+    TREESEED_PUBLIC_DEV_WATCH_RELOAD: string;
+};
+export declare function packageScriptPath(scriptName: any): string;
+export declare function withProcessCwd(cwd: any, action: any): any;
+export declare function loadCliDeployConfig(tenantRoot: any): {
+    name: string;
+    slug: string;
+    siteUrl: string;
+    contactEmail: string;
+    cloudflare: {
+        accountId: string;
+        workerName: string | undefined;
+        gatewayWorkerName: string | undefined;
+        queueName: string | undefined;
+        dlqName: string | undefined;
+        d1Binding: string | undefined;
+        queueBinding: string | undefined;
+    };
+    plugins: {
+        package: string;
+        enabled: boolean;
+    }[] | {
+        package: string;
+        enabled: boolean | undefined;
+        config: any;
+    }[];
+    providers: {
+        forms: string;
+        agents: {
+            execution: string;
+            mutation: string;
+            repository: string;
+            verification: string;
+            notification: string;
+            research: string;
+        };
+        deploy: string;
+        content: {
+            docs: string;
+        };
+        site: string;
+    };
+    services: {
+        [k: string]: {
+            enabled: boolean | undefined;
+            provider: string | undefined;
+            rootDir: string | undefined;
+            publicBaseUrl: string | undefined;
+            cloudflare: {
+                workerName: string | undefined;
+            };
+            railway: {
+                projectId: string | undefined;
+                projectName: string | undefined;
+                serviceId: string | undefined;
+                serviceName: string | undefined;
+                rootDir: string | undefined;
+                buildCommand: string | undefined;
+                startCommand: string | undefined;
+            };
+            environments: {
+                local: {
+                    baseUrl: string | undefined;
+                    domain: string | undefined;
+                    railwayEnvironment: string | undefined;
+                };
+                staging: {
+                    baseUrl: string | undefined;
+                    domain: string | undefined;
+                    railwayEnvironment: string | undefined;
+                };
+                prod: {
+                    baseUrl: string | undefined;
+                    domain: string | undefined;
+                    railwayEnvironment: string | undefined;
+                };
+            };
+        } | undefined;
+    } | undefined;
+    smtp: {
+        enabled: boolean | undefined;
+    };
+    turnstile: {
+        enabled: boolean;
+    };
+};
+export declare function runNodeBinary(binPath: any, args: any, options?: {}): void;
+export declare function runNodeScript(scriptPath: any, args?: never[], options?: {}): void;
+export declare function spawnNodeBinary(binPath: any, args: any, options?: {}): import("child_process").ChildProcessWithoutNullStreams;