@treeseed/sdk 0.4.5 → 0.4.7

package/dist/fixture-support.d.ts

@@ -4,7 +4,7 @@ export type FixtureSupportDeclaration = {
     modes: readonly FixtureInjectionMode[];
     workspaceDirName?: string;
     entrySpecifier?: string;
-    contractsShim?: 'agent';
+    contractsShim?: 'core-agent';
 };
 export type ResolveSharedFixtureOptions = {
     packageRoot?: string;

package/dist/fixture-support.js

@@ -106,15 +106,15 @@ function ensureFixtureLinkedPackage(fixtureRoot, packageName, resolvedPackageRoo
   rmSync(packageDir, { recursive: true, force: true });
   symlinkSync(resolvedPackageRoot, packageDir, "dir");
 }
-function buildAgentContractsShimPackage(fixtureRoot) {
-  const packageDir = resolve(fixtureRoot, "node_modules", "@treeseed", "agent");
+function buildCoreAgentContractsShimPackage(fixtureRoot) {
+  const packageDir = resolve(fixtureRoot, "node_modules", "@treeseed", "core");
   rmSync(packageDir, { recursive: true, force: true });
   mkdirSync(resolve(packageDir, "contracts"), { recursive: true });
   writeFileSync(
     resolve(packageDir, "package.json"),
     JSON.stringify(
       {
-        name: "@treeseed/agent",
+        name: "@treeseed/core",
         type: "module",
         exports: {
           "./runtime-types": {
@@ -315,8 +315,8 @@ function prepareFixturePackages(options) {
         satisfied = true;
         break;
       }
-      if (mode === "contracts-only" && declaration.contractsShim === "agent") {
-        buildAgentContractsShimPackage(options.fixtureRoot);
+      if (mode === "contracts-only" && declaration.contractsShim === "core-agent") {
+        buildCoreAgentContractsShimPackage(options.fixtureRoot);
         satisfied = true;
         break;
       }

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

@@ -1064,7 +1064,7 @@ function syncTreeseedRailwayEnvironment({ tenantRoot, scope = "prod", dryRun = f
     }
     const environment = service.environments?.[scope];
     const fallbackServiceName = serviceKey === "api" ? config.settings.services.railway.apiServiceName : serviceKey === "agents" ? config.settings.services.railway.agentsServiceName : "";
-    const defaultRootDir = serviceKey === "api" ? "." : "packages/agent";
+    const defaultRootDir = ["api", "manager", "worker", "workdayStart", "workdayReport"].includes(serviceKey) ? "." : "packages/core";
     return {
       service: serviceKey,
       projectName: service.railway?.projectName ?? config.settings.services.railway.projectName,

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

@@ -26,7 +26,7 @@ function configuredRailwayServices(tenantRoot, scope) {
     if (!service || service.enabled === false || (service.provider ?? "railway") !== "railway") {
       return null;
     }
-    const defaultRootDir = serviceKey === "api" ? "." : "packages/agent";
+    const defaultRootDir = ["api", "manager", "worker", "workdayStart", "workdayReport"].includes(serviceKey) ? "." : "packages/core";
     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;

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

@@ -19,7 +19,6 @@ 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?: {}): {

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

@@ -51,7 +51,7 @@ const TREESEED_DEFAULT_PROVIDER_SELECTIONS = {
   site: "default"
 };
 const TRESEED_MANAGED_SERVICE_KEYS = ["api", "agents", "gateway", "manager", "worker", "workdayStart", "workdayReport"];
-const TRESEED_WORKSPACE_PACKAGE_DIRS = ["sdk", "core", "cli", "agent"];
+const TRESEED_WORKSPACE_PACKAGE_DIRS = ["sdk", "core", "cli"];
 const CLOUDFLARE_ACCOUNT_ID_PLACEHOLDER = "replace-with-cloudflare-account-id";
 function parseServiceEnvironmentConfig(value) {
   const record = optionalRecord(value, "service environment") ?? {};
@@ -178,7 +178,6 @@ function resolveWranglerBin() {
 }
 const corePackageRoot = resolveTreeseedPackageRoot("@treeseed/core", "@treeseed/core/config", "core");
 const sdkPackageRoot = resolveTreeseedPackageRoot("@treeseed/sdk", "@treeseed/sdk", "sdk");
-const agentPackageRoot = resolveTreeseedPackageRoot("@treeseed/agent", "@treeseed/agent", "agent");
 function loadPackageJson(root = process.cwd()) {
   const packageJsonPath = resolve(root, "package.json");
   if (!existsSync(packageJsonPath)) {
@@ -372,7 +371,6 @@ function spawnNodeBinary(binPath, args, options = {}) {
   });
 }
 export {
-  agentPackageRoot,
   corePackageRoot,
   createProductionBuildEnv,
   isWorkspaceRoot,

package/dist/operations/services/template-registry.d.ts

@@ -37,6 +37,7 @@ export interface TemplateProductDefinition extends SdkTemplateCatalogEntry {
     artifactRoot: string;
     artifactManifestPath: string;
     templateRoot: string;
+    fulfillmentMode: 'packaged' | 'git';
 }
 export interface ResolvedTemplateDefinition {
     product: TemplateProductDefinition;
@@ -82,6 +83,7 @@ export declare function serializeTemplateRegistryEntry(product: Pick<TemplatePro
     templateApiVersion: number;
     minCliVersion: string;
     minCoreVersion: string | undefined;
+    fulfillmentMode: "git" | "packaged";
     source: import("../../sdk-types.ts").SdkTemplateCatalogSource;
 };
 export declare function exportTemplateCatalogYaml(options?: TemplateCatalogOptions): Promise<string>;

package/dist/operations/services/template-registry.js

@@ -1,4 +1,5 @@
-import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
 import { basename, dirname, relative, resolve } from "node:path";
 import { RemoteTemplateCatalogClient } from "../../template-catalog.js";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
@@ -53,10 +54,10 @@ function validateTemplateProductShape(product) {
   if (product.status !== "draft" && product.status !== "live" && product.status !== "archived") {
     throw new Error(`Template product ${product.id} uses unsupported status "${product.status}".`);
   }
-  if (!existsSync(product.artifactManifestPath)) {
+  if (product.fulfillmentMode === "packaged" && !existsSync(product.artifactManifestPath)) {
     throw new Error(`Template product ${product.id} points to a missing artifact manifest: ${product.artifactManifestPath}`);
   }
-  if (!existsSync(product.templateRoot)) {
+  if (product.fulfillmentMode === "packaged" && !existsSync(product.templateRoot)) {
     throw new Error(`Template product ${product.id} points to a missing template payload: ${product.templateRoot}`);
   }
 }
@@ -101,9 +102,55 @@ function normalizeTemplateProduct(remoteProduct) {
     contentPath: `${remoteProduct.fulfillment.source.repoUrl}#${remoteProduct.id}`,
     artifactRoot,
     artifactManifestPath: resolve(artifactRoot, "template.config.json"),
+    templateRoot: resolve(artifactRoot, "template"),
+    fulfillmentMode: remoteProduct.fulfillment.mode ?? "packaged"
+  };
+}
+function sanitizeCacheSegment(value) {
+  return value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "source";
+}
+function resolveTemplateSourceCacheRoot(product, options) {
+  const cachePath = resolveTreeseedTemplateCatalogCachePath(options.cwd ?? process.cwd());
+  return resolve(dirname(cachePath), "templates", sanitizeCacheSegment(product.id), sanitizeCacheSegment(product.fulfillment.source.ref));
+}
+function runGit(commandArgs, cwd) {
+  const result = spawnSync("git", commandArgs, {
+    cwd,
+    stdio: "pipe",
+    encoding: "utf8"
+  });
+  if (result.status !== 0) {
+    throw new Error(result.stderr?.trim() || result.stdout?.trim() || `git ${commandArgs.join(" ")} failed`);
+  }
+}
+function materializeGitTemplateSource(product, options) {
+  const cacheRoot = resolveTemplateSourceCacheRoot(product, options);
+  const repoRoot = resolve(cacheRoot, "repo");
+  const source = product.fulfillment.source;
+  if (!existsSync(resolve(repoRoot, ".git"))) {
+    rmSync(cacheRoot, { recursive: true, force: true });
+    mkdirSync(cacheRoot, { recursive: true });
+    runGit(["clone", "--no-checkout", source.repoUrl, repoRoot]);
+  }
+  runGit(["fetch", "--all", "--tags"], repoRoot);
+  runGit(["checkout", "--force", source.ref], repoRoot);
+  const artifactRoot = resolve(repoRoot, source.directory);
+  return {
+    artifactRoot,
+    manifestPath: resolve(artifactRoot, "template.config.json"),
     templateRoot: resolve(artifactRoot, "template")
   };
 }
+function resolveTemplateDefinitionPaths(product, options) {
+  if (existsSync(product.artifactManifestPath) && existsSync(product.templateRoot)) {
+    return {
+      artifactRoot: product.artifactRoot,
+      manifestPath: product.artifactManifestPath,
+      templateRoot: product.templateRoot
+    };
+  }
+  return materializeGitTemplateSource(product, options);
+}
 function readTemplateCatalogCache(cachePath) {
   if (!existsSync(cachePath)) {
     return null;
@@ -268,11 +315,12 @@ async function resolveTemplateDefinition(id, options = {}, category) {
     throw new Error(`Unable to resolve template "${id}" in category "${category}".`);
   }
   validateTemplateProductShape(product);
-  const manifest = loadJsonFile(product.artifactManifestPath);
+  const resolvedPaths = resolveTemplateDefinitionPaths(product, options);
+  const manifest = loadJsonFile(resolvedPaths.manifestPath);
   const definition = {
     product,
-    manifestPath: product.artifactManifestPath,
-    templateRoot: product.templateRoot,
+    manifestPath: resolvedPaths.manifestPath,
+    templateRoot: resolvedPaths.templateRoot,
     manifest
   };
   validateTemplateManifest(definition);
@@ -387,6 +435,7 @@ function serializeTemplateRegistryEntry(product) {
     templateApiVersion: product.templateApiVersion,
     minCliVersion: product.minCliVersion,
     minCoreVersion: product.minCoreVersion,
+    fulfillmentMode: product.fulfillment.mode ?? "packaged",
     source: product.fulfillment.source
   };
 }

package/dist/scripts/test-scaffold.js

@@ -3,7 +3,7 @@ import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync,
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { agentPackageRoot, corePackageRoot, packageRoot, packageScriptPath, sdkPackageRoot } from '../operations/services/runtime-tools.js';
+import { corePackageRoot, packageRoot, packageScriptPath, sdkPackageRoot } from '../operations/services/runtime-tools.js';
 import { listTemplateProducts, validateTemplateProduct } from '../operations/services/template-registry.js';
 const npmCacheDir = process.env.TREESEED_SCAFFOLD_NPM_CACHE_DIR
     ? resolve(process.env.TREESEED_SCAFFOLD_NPM_CACHE_DIR)
@@ -11,7 +11,6 @@ const npmCacheDir = process.env.TREESEED_SCAFFOLD_NPM_CACHE_DIR
 const packageJson = JSON.parse(readFileSync(resolve(corePackageRoot, 'package.json'), 'utf8'));
 const sdkPackageJson = JSON.parse(readFileSync(resolve(sdkPackageRoot, 'package.json'), 'utf8'));
 const cliPackageJson = JSON.parse(readFileSync(resolve(packageRoot, 'package.json'), 'utf8'));
-const agentPackageJson = JSON.parse(readFileSync(resolve(agentPackageRoot, 'package.json'), 'utf8'));
 const workspaceTarballs = (() => {
     try {
         return JSON.parse(process.env.TREESEED_WORKSPACE_TARBALLS ?? '{}');
@@ -35,12 +34,7 @@ const externalCliTarball = process.env.TREESEED_SCAFFOLD_CLI_TARBALL
     : typeof workspaceTarballs['@treeseed/cli'] === 'string'
         ? resolve(workspaceTarballs['@treeseed/cli'])
         : null;
-const externalAgentTarball = process.env.TREESEED_SCAFFOLD_AGENT_TARBALL
-    ? resolve(process.env.TREESEED_SCAFFOLD_AGENT_TARBALL)
-    : typeof workspaceTarballs['@treeseed/agent'] === 'string'
-        ? resolve(workspaceTarballs['@treeseed/agent'])
-        : null;
-const reusesExternalTarballs = Boolean(externalCoreTarball || externalSdkTarball || externalCliTarball || externalAgentTarball);
+const reusesExternalTarballs = Boolean(externalCoreTarball || externalSdkTarball || externalCliTarball);
 const scaffoldChecks = new Set((process.env.TREESEED_SCAFFOLD_CHECKS ?? 'build,deploy')
     .split(',')
     .map((value) => value.trim())
@@ -177,7 +171,7 @@ function linkTreeseedBins(siteRoot) {
     mkdirSync(binRoot, { recursive: true });
     for (const [name, relativeTarget] of [
         ['treeseed', '../@treeseed/cli/dist/cli/main.js'],
-        ['treeseed-agents', '../@treeseed/agent/dist/scripts/treeseed-agents.js'],
+        ['treeseed-agents', '../@treeseed/core/dist/agents/cli.js'],
     ]) {
         symlinkSync(relativeTarget, resolve(binRoot, name));
     }
@@ -210,12 +204,11 @@ async function scaffoldSite(siteRoot) {
     }
     runStep(process.execPath, [packageScriptPath('scaffold-site'), siteRoot, '--template', 'starter-basic', '--name', 'Smoke Site', '--site-url', 'https://smoke.example.com', '--contact-email', 'hello@example.com']);
 }
-function installScaffold(siteRoot, { coreTarballPath, sdkTarballPath, cliTarballPath, agentTarballPath }) {
-    if (coreTarballPath && sdkTarballPath && cliTarballPath && agentTarballPath) {
+function installScaffold(siteRoot, { coreTarballPath, sdkTarballPath, cliTarballPath }) {
+    if (coreTarballPath && sdkTarballPath && cliTarballPath) {
         linkWorkspacePackage(siteRoot, sdkPackageJson.name, sdkPackageRoot);
         linkWorkspacePackage(siteRoot, packageJson.name, corePackageRoot);
         linkWorkspacePackage(siteRoot, cliPackageJson.name, packageRoot);
-        linkWorkspacePackage(siteRoot, agentPackageJson.name, agentPackageRoot);
         mirrorSharedNodeModules(siteRoot);
         linkTreeseedBins(siteRoot);
         return;
@@ -247,7 +240,6 @@ const siteRoot = createTempSiteRoot();
 let tarballPath = externalCoreTarball;
 let sdkTarballPath = externalSdkTarball;
 let cliTarballPath = externalCliTarball;
-let agentTarballPath = externalAgentTarball;
 try {
     if (!reusesExternalTarballs && resetScaffoldCache) {
         logStep(`resetting npm cache at ${npmCacheDir}`);
@@ -267,13 +259,6 @@ try {
     else {
         logStep(`reusing provided @treeseed/core tarball: ${tarballPath}`);
     }
-    if (!agentTarballPath) {
-        logStep('building and packing @treeseed/agent');
-        agentTarballPath = createTarball(agentPackageRoot, agentPackageJson);
-    }
-    else {
-        logStep(`reusing provided @treeseed/agent tarball: ${agentTarballPath}`);
-    }
     if (!cliTarballPath) {
         logStep('building and packing @treeseed/cli');
         cliTarballPath = createTarball(packageRoot, cliPackageJson);
@@ -292,7 +277,6 @@ try {
             coreTarballPath: tarballPath,
             sdkTarballPath,
             cliTarballPath,
-            agentTarballPath,
         });
     });
     logStep('running scaffold smoke checks');

package/dist/scripts/treeseed-release-verify.js

@@ -3,7 +3,7 @@ import { mkdtempSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, extname, join, resolve } from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { agentPackageRoot, corePackageRoot, packageRoot, sdkPackageRoot } from '../operations/services/runtime-tools.js';
+import { corePackageRoot, packageRoot, sdkPackageRoot } from '../operations/services/runtime-tools.js';
 const textExtensions = new Set(['.js', '.ts', '.mjs', '.cjs', '.d.js', '.json', '.md']);
 const forbiddenPatterns = [
     /['"`]workspace:[^'"`\n]+['"`]/,
@@ -108,11 +108,11 @@ function hasWorkspacePackageSource(root) {
 run('npm', ['run', 'build']);
 scanDirectory(resolve(packageRoot, 'dist'));
 run('npm', ['test']);
-if (hasWorkspacePackageSource(sdkPackageRoot) && hasWorkspacePackageSource(corePackageRoot) && hasWorkspacePackageSource(agentPackageRoot)) {
+if (hasWorkspacePackageSource(sdkPackageRoot) && hasWorkspacePackageSource(corePackageRoot)) {
     run('npm', ['run', 'test:scaffold']);
 }
 else {
-    console.log('Skipping scaffold verification because local sdk/core/agent package sources are not available.');
+    console.log('Skipping scaffold verification because local sdk/core package sources are not available.');
 }
 const stageRoot = mkdtempSync(join(tmpdir(), 'treeseed-cli-release-'));
 const extractRoot = resolve(stageRoot, 'extract');

package/dist/sdk-types.d.ts

@@ -777,6 +777,7 @@ export interface SdkTemplateCatalogEntry {
     minCliVersion: string;
     minCoreVersion?: string;
     fulfillment: {
+        mode?: 'packaged' | 'git';
         source: SdkTemplateCatalogSource;
         hooksPolicy: 'builtin_only' | 'trusted_only' | 'disabled';
         supportsReconcile: boolean;

package/dist/template-catalog.js

@@ -66,6 +66,7 @@ function normalizeTemplateCatalogEntry(value) {
     minCliVersion: expectString(record.minCliVersion, "minCliVersion"),
     minCoreVersion: optionalString(record.minCoreVersion),
     fulfillment: {
+      mode: optionalString(fulfillment.mode),
       source: {
         kind: "git",
         repoUrl: expectString(source.repoUrl, "fulfillment.source.repoUrl"),