@treeseed/core 0.4.8 → 0.4.10

package/dist/api/operations-routes.d.ts

@@ -2,5 +2,6 @@ import type { Hono } from 'hono';
 import { executeHttpWorkflowOperation } from './operations.ts';
 export declare function registerOperationRoutes(app: Hono<any>, options: {
     scope: string;
+    prefix?: string;
     executeOperation?: typeof executeHttpWorkflowOperation;
 }): void;

package/dist/api/operations-routes.js

@@ -3,7 +3,12 @@ import { executeHttpWorkflowOperation, isHttpWorkflowOperationAllowed } from "./
 import { jsonError, requireScope } from "./http.js";
 function registerOperationRoutes(app, options) {
   const executeOperation = options.executeOperation ?? executeHttpWorkflowOperation;
-  app.post("/operations/:operation", async (c) => {
+  const prefix = options.prefix ?? "";
+  function withPrefix(path) {
+    if (!prefix) return path;
+    return `${prefix}${path}`.replace(/\/{2,}/g, "/");
+  }
+  app.post(withPrefix("/operations/:operation"), async (c) => {
     const unauthorized = requireScope(c, options.scope);
     if (unauthorized) return unauthorized;
     const requestedOperation = c.req.param("operation");

package/dist/api/railway.d.ts

@@ -22,7 +22,11 @@ export declare function createRailwayTreeseedApiServer(options?: ApiServerOption
         baseUrl: string;
         issuer: string;
         repoRoot: string;
+        projectId: string;
         authSecret: string;
+        projectApiKey?: string;
+        projectApiLabel: string;
+        projectApiPermissions: string[];
         cloudflareAccountId?: string;
         cloudflareApiToken?: string;
         d1DatabaseId?: string;

package/dist/api/sdk-dispatch.d.ts

@@ -1,14 +1,5 @@
 import type { AgentSdk, RemoteSdkOperationRequest } from '@treeseed/sdk';
+import { executeSdkOperation, findSdkOperation, listSdkOperationNames } from '@treeseed/sdk';
 import type { ApiConfig } from './types.ts';
-type JsonRecord = Record<string, unknown>;
-type SdkOperationHandler = (sdk: AgentSdk, input: JsonRecord) => Promise<unknown> | unknown;
-interface SdkOperationSpec {
-    name: string;
-    aliases?: string[];
-    handler: SdkOperationHandler;
-}
-export declare function listSdkOperationNames(): string[];
-export declare function findSdkOperation(name: string): SdkOperationSpec;
+export { executeSdkOperation, findSdkOperation, listSdkOperationNames, };
 export declare function resolveSdkInstance(sharedSdk: AgentSdk | undefined, config: ApiConfig, request: RemoteSdkOperationRequest): AgentSdk;
-export declare function executeSdkOperation(sdk: AgentSdk, operationName: string, input: JsonRecord): Promise<unknown>;
-export {};

package/dist/api/sdk-dispatch.js

@@ -1,142 +1,10 @@
-import { AgentSdk as AgentSdkClass } from "@treeseed/sdk";
-function passthrough(methodName) {
-  return (sdk, input) => sdk[methodName](input);
-}
-const SDK_OPERATION_SPECS = [
-  { name: "get", handler: passthrough("get") },
-  { name: "read", handler: passthrough("read") },
-  { name: "search", handler: passthrough("search") },
-  { name: "follow", handler: passthrough("follow") },
-  { name: "pick", handler: passthrough("pick") },
-  { name: "create", handler: passthrough("create") },
-  { name: "update", handler: passthrough("update") },
-  { name: "claimMessage", aliases: ["claim-message"], handler: passthrough("claimMessage") },
-  { name: "ackMessage", aliases: ["ack-message"], handler: passthrough("ackMessage") },
-  { name: "createMessage", aliases: ["create-message"], handler: passthrough("createMessage") },
-  { name: "recordRun", aliases: ["record-run"], handler: passthrough("recordRun") },
-  { name: "getCursor", aliases: ["get-cursor"], handler: passthrough("getCursor") },
-  { name: "upsertCursor", aliases: ["upsert-cursor"], handler: passthrough("upsertCursor") },
-  { name: "releaseLease", aliases: ["release-lease"], handler: passthrough("releaseLease") },
-  {
-    name: "releaseAllLeases",
-    aliases: ["release-all-leases"],
-    handler: (sdk) => sdk.releaseAllLeases()
-  },
-  { name: "startWorkDay", aliases: ["start-work-day"], handler: passthrough("startWorkDay") },
-  { name: "closeWorkDay", aliases: ["close-work-day"], handler: passthrough("closeWorkDay") },
-  { name: "createTask", aliases: ["create-task"], handler: passthrough("createTask") },
-  { name: "claimTask", aliases: ["claim-task"], handler: passthrough("claimTask") },
-  {
-    name: "recordTaskProgress",
-    aliases: ["record-task-progress"],
-    handler: passthrough("recordTaskProgress")
-  },
-  { name: "completeTask", aliases: ["complete-task"], handler: passthrough("completeTask") },
-  { name: "failTask", aliases: ["fail-task"], handler: passthrough("failTask") },
-  { name: "appendTaskEvent", aliases: ["append-task-event"], handler: passthrough("appendTaskEvent") },
-  { name: "searchTasks", aliases: ["search-tasks"], handler: passthrough("searchTasks") },
-  {
-    name: "getManagerContext",
-    aliases: ["get-manager-context"],
-    handler: (sdk, input) => sdk.getManagerContext(String(input.taskId ?? input.id ?? ""))
-  },
-  { name: "createReport", aliases: ["create-report"], handler: passthrough("createReport") },
-  {
-    name: "listAgentSpecs",
-    aliases: ["list-agent-specs"],
-    handler: (sdk, input) => sdk.listAgentSpecs(input)
-  },
-  { name: "refreshGraph", aliases: ["refresh-graph"], handler: passthrough("refreshGraph") },
-  {
-    name: "searchFiles",
-    aliases: ["search-files"],
-    handler: (sdk, input) => sdk.searchFiles(String(input.query ?? ""), input.options)
-  },
-  {
-    name: "searchSections",
-    aliases: ["search-sections"],
-    handler: (sdk, input) => sdk.searchSections(String(input.query ?? ""), input.options)
-  },
-  {
-    name: "searchEntities",
-    aliases: ["search-entities"],
-    handler: (sdk, input) => sdk.searchEntities(String(input.query ?? ""), input.options)
-  },
-  {
-    name: "getGraphNode",
-    aliases: ["get-graph-node"],
-    handler: (sdk, input) => sdk.getGraphNode(String(input.id ?? ""))
-  },
-  {
-    name: "getNeighbors",
-    aliases: ["get-neighbors"],
-    handler: (sdk, input) => sdk.getNeighbors(String(input.id ?? ""), input.options)
-  },
-  {
-    name: "followReferences",
-    aliases: ["follow-references"],
-    handler: (sdk, input) => sdk.followReferences(String(input.id ?? ""), input.options)
-  },
-  {
-    name: "getBacklinks",
-    aliases: ["get-backlinks"],
-    handler: (sdk, input) => sdk.getBacklinks(String(input.id ?? ""), input.options)
-  },
-  {
-    name: "getRelated",
-    aliases: ["get-related"],
-    handler: (sdk, input) => sdk.getRelated(String(input.id ?? ""), input.options)
-  },
-  {
-    name: "getSubgraph",
-    aliases: ["get-subgraph"],
-    handler: (sdk, input) => sdk.getSubgraph(Array.isArray(input.seedIds) ? input.seedIds.map(String) : [], input.options)
-  },
-  { name: "resolveSeeds", aliases: ["resolve-seeds"], handler: passthrough("resolveSeeds") },
-  { name: "queryGraph", aliases: ["query-graph"], handler: passthrough("queryGraph") },
-  { name: "buildContextPack", aliases: ["build-context-pack"], handler: passthrough("buildContextPack") },
-  {
-    name: "parseGraphDsl",
-    aliases: ["parse-graph-dsl"],
-    handler: (sdk, input) => sdk.parseGraphDsl(String(input.source ?? input.query ?? ""))
-  },
-  {
-    name: "resolveReference",
-    aliases: ["resolve-reference"],
-    handler: (sdk, input) => sdk.resolveReference(String(input.reference ?? ""), input.options)
-  },
-  {
-    name: "explainReferenceChain",
-    aliases: ["explain-reference-chain"],
-    handler: (sdk, input) => sdk.explainReferenceChain(String(input.fromId ?? ""), String(input.toId ?? ""))
-  }
-];
-const SDK_OPERATION_INDEX = /* @__PURE__ */ new Map();
-for (const spec of SDK_OPERATION_SPECS) {
-  SDK_OPERATION_INDEX.set(spec.name, spec);
-  for (const alias of spec.aliases ?? []) {
-    SDK_OPERATION_INDEX.set(alias, spec);
-  }
-}
-function listSdkOperationNames() {
-  return [...new Set(SDK_OPERATION_SPECS.map((entry) => entry.name))];
-}
-function findSdkOperation(name) {
-  return SDK_OPERATION_INDEX.get(name) ?? null;
-}
+import { AgentSdk as AgentSdkClass, executeSdkOperation, findSdkOperation, listSdkOperationNames } from "@treeseed/sdk";
 function resolveSdkInstance(sharedSdk, config, request) {
   if (!request.repoRoot || request.repoRoot === config.repoRoot) {
     return sharedSdk ?? new AgentSdkClass({ repoRoot: config.repoRoot });
   }
   return new AgentSdkClass({ repoRoot: request.repoRoot });
 }
-async function executeSdkOperation(sdk, operationName, input) {
-  const spec = findSdkOperation(operationName);
-  if (!spec) {
-    throw new Error(`Unknown SDK operation "${operationName}".`);
-  }
-  return await spec.handler(sdk, input);
-}
 export {
   executeSdkOperation,
   findSdkOperation,

package/dist/api/sdk-routes.d.ts

@@ -5,6 +5,7 @@ interface RegisterSdkRoutesOptions {
     config: ApiConfig;
     sharedSdk?: AgentSdk;
     scope: string;
+    prefix?: string;
 }
 export declare function registerSdkRoutes(app: Hono<any>, options: RegisterSdkRoutesOptions): void;
 export {};

package/dist/api/sdk-routes.js

@@ -1,7 +1,11 @@
 import { executeSdkOperation, resolveSdkInstance } from "./sdk-dispatch.js";
 import { jsonError, requireScope } from "./http.js";
+function withPrefix(prefix, path) {
+  if (!prefix) return path;
+  return `${prefix}${path}`.replace(/\/{2,}/g, "/");
+}
 function registerSdkRoutes(app, options) {
-  app.post("/sdk/:operation", async (c) => {
+  app.post(withPrefix(options.prefix ?? "", "/sdk/:operation"), async (c) => {
     const unauthorized = requireScope(c, options.scope);
     if (unauthorized) return unauthorized;
     const operation = c.req.param("operation");

package/dist/api/types.d.ts

@@ -1,4 +1,5 @@
-import type { AgentSdk, SdkQueueMessageEnvelope } from '@treeseed/sdk';
+import type { Hono } from 'hono';
+import type { AgentSdk } from '@treeseed/sdk';
 import type { ApiPrincipal, ApiScope, DeviceCodeApproveRequest as SdkDeviceCodeApproveRequest, DeviceCodePollRequest, DeviceCodePollResponse, DeviceCodeStartRequest, DeviceCodeStartResponse, RemoteWorkflowOperationRequest as WorkflowHttpOperationRequest, RemoteWorkflowOperationResponse as ApiWorkflowOperationResponse, RemoteSdkOperationRequest as SdkHttpOperationRequest, TokenRefreshRequest, TokenRefreshResponse } from '@treeseed/sdk/remote';
 export type { ApiPrincipal, ApiScope, DeviceCodePollRequest, DeviceCodePollResponse, DeviceCodeStartRequest, DeviceCodeStartResponse, WorkflowHttpOperationRequest, ApiWorkflowOperationResponse, SdkHttpOperationRequest, TokenRefreshRequest, TokenRefreshResponse, };
 export type DeviceCodeApproveRequest = SdkDeviceCodeApproveRequest;
@@ -87,7 +88,11 @@ export interface ApiConfig {
     baseUrl: string;
     issuer: string;
     repoRoot: string;
+    projectId: string;
     authSecret: string;
+    projectApiKey?: string;
+    projectApiLabel: string;
+    projectApiPermissions: string[];
     cloudflareAccountId?: string;
     cloudflareApiToken?: string;
     d1DatabaseId?: string;
@@ -111,11 +116,11 @@ export interface AppVariables {
     principal: ApiPrincipal | null;
     actingUser: ApiPrincipal | null;
     credential: ApiCredential | null;
-    actorType: 'anonymous' | 'user' | 'service';
+    actorType: 'anonymous' | 'user' | 'service' | 'project';
     permissionGrants: string[];
 }
 export interface ApiCredential {
-    type: 'access_token' | 'personal_access_token' | 'service_secret' | 'service_token';
+    type: 'access_token' | 'personal_access_token' | 'service_secret' | 'service_token' | 'project_api_key' | 'team_api_key';
     id: string;
     label?: string;
 }
@@ -158,6 +163,28 @@ export interface ResolvedApiRuntimeProviders {
     };
     selections: ApiRuntimeProviderSelections;
 }
+export interface ApiResolvedSettings {
+    config: ApiConfig;
+    surfaces: {
+        auth: boolean;
+        templates: boolean;
+        sdk: boolean;
+        agent: boolean;
+        operations: boolean;
+    };
+    scopes: {
+        authMe: ApiScope;
+        sdk: ApiScope;
+        agent: ApiScope;
+        operations: ApiScope;
+    };
+}
+export interface ApiAppRuntime {
+    resolved: ApiResolvedSettings;
+    runtimeProviders: ResolvedApiRuntimeProviders;
+    sharedSdk: AgentSdk;
+    internalPrefix: string;
+}
 export interface ApiServerOptions {
     config?: Partial<ApiConfig>;
     runtimeProviders?: ApiRuntimeProviders;
@@ -176,18 +203,7 @@ export interface ApiServerOptions {
         agent: ApiScope;
         operations: ApiScope;
     }>;
+    internalPrefix?: string;
+    extendApp?: (app: Hono<any>, runtime: ApiAppRuntime) => void;
     log?: (message: string, details?: Record<string, unknown>) => void;
 }
-export interface GatewayQueueProducer {
-    enqueue(request: {
-        queueName?: string;
-        message: SdkQueueMessageEnvelope;
-        delaySeconds?: number;
-    }): Promise<void>;
-}
-export interface GatewayServerOptions {
-    sdk: AgentSdk;
-    bearerToken: string;
-    queueProducer?: GatewayQueueProducer;
-    projectId?: string;
-}

package/dist/dev.js

@@ -38,6 +38,28 @@ function resolveNodeEntrypoint(packageDir, sourceRelativePath, distRelativePath)
     args: [resolve(packageDir, distRelativePath)]
   };
 }
+function resolveTenantApiEntrypoint(tenantRoot, runTsPath) {
+  const javascriptCandidates = [
+    resolve(tenantRoot, "src", "api", "server.js"),
+    resolve(tenantRoot, "src", "api", "server.mjs")
+  ];
+  for (const candidate of javascriptCandidates) {
+    if (existsSync(candidate)) {
+      return {
+        command: process.execPath,
+        args: [candidate]
+      };
+    }
+  }
+  const typescriptCandidate = resolve(tenantRoot, "src", "api", "server.ts");
+  if (existsSync(typescriptCandidate) && existsSync(runTsPath)) {
+    return {
+      command: process.execPath,
+      args: [runTsPath, typescriptCandidate]
+    };
+  }
+  return null;
+}
 function withWatchArgs(args, watchPaths) {
   return watchPaths.flatMap((watchPath) => ["--watch-path", watchPath]).concat(args);
 }
@@ -55,12 +77,13 @@ function createTreeseedIntegratedDevPlan(options = {}) {
   const mergedEnv = { ...process.env, ...options.env ?? {} };
   const apiBaseUrl = mergedEnv.TREESEED_API_BASE_URL?.trim() || `http://${apiHost}:${apiPort}`;
   const sdkPackageRoot = resolvePackageRoot("@treeseed/sdk", tenantRoot);
+  const coreRunTsPath = resolve(packageRoot, "scripts", "run-ts.mjs");
   const webEntrypoint = resolveNodeEntrypoint(
     sdkPackageRoot,
     "scripts/tenant-astro-command.ts",
     "dist/scripts/tenant-astro-command.js"
   );
-  const apiEntrypoint = resolveNodeEntrypoint(
+  const apiEntrypoint = resolveTenantApiEntrypoint(tenantRoot, coreRunTsPath) ?? resolveNodeEntrypoint(
     packageRoot,
     "src/api/server.ts",
     "dist/api/server.js"

package/dist/index.d.ts

@@ -2,7 +2,6 @@ export { buildTreeseedSiteLayers, resolveTreeseedPageEntrypoint, resolveTreeseed
 export { buildTreeseedPlatformLayers, resolveTreeseedPlatformResource, TREESEED_PLATFORM_RESOURCE_KINDS, } from './platform-resources';
 export { parseSiteConfig } from './utils/site-config-schema.js';
 export { createTreeseedApiApp } from './api/app';
-export { createTreeseedGatewayApp } from './api/gateway';
 export { createRailwayTreeseedApiServer } from './api/railway';
 export { resolveApiConfig } from './api/config';
 export { createTreeseedIntegratedDevPlan, runTreeseedIntegratedDev, type TreeseedIntegratedDevCommand, type TreeseedIntegratedDevOptions, type TreeseedIntegratedDevPlan, type TreeseedIntegratedDevSurface, } from './dev';

package/dist/index.js

@@ -12,7 +12,6 @@ import {
 } from "./platform-resources.js";
 import { parseSiteConfig } from "./utils/site-config-schema.js";
 import { createTreeseedApiApp } from "./api/app.js";
-import { createTreeseedGatewayApp } from "./api/gateway.js";
 import { createRailwayTreeseedApiServer } from "./api/railway.js";
 import { resolveApiConfig } from "./api/config.js";
 import {
@@ -26,7 +25,6 @@ export {
   buildTreeseedSiteLayers,
   createRailwayTreeseedApiServer,
   createTreeseedApiApp,
-  createTreeseedGatewayApp,
   createTreeseedIntegratedDevPlan,
   parseSiteConfig,
   resolveApiConfig,

package/dist/scripts/aggregate-book.js

@@ -1,112 +1,17 @@
-import fs from 'node:fs';
 import path from 'node:path';
-import { BOOKS, TREESEED_LIBRARY_DOWNLOAD } from '@treeseed/sdk/platform/books-data';
+import { exportTenantBookPackages } from '@treeseed/sdk/platform/book-export';
 import { PROJECT_TENANT } from '../tenant/bridge.js';
-const projectRoot = PROJECT_TENANT.__tenantRoot ?? process.cwd();
-const outputDir = path.join(projectRoot, 'public', 'books');
-const legacyOutputFile = path.join(projectRoot, 'public', 'book.md');
-function sortPaths(paths) {
-    return [...paths].sort((left, right) => left.localeCompare(right, undefined, { numeric: true, sensitivity: 'base' }));
-}
-function getSidebarOrder(filePath) {
-    const rawContent = fs.readFileSync(filePath, 'utf8');
-    const frontmatterMatch = rawContent.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-    if (!frontmatterMatch)
-        return Number.POSITIVE_INFINITY;
-    const orderMatch = frontmatterMatch[1].match(/^\s{2}order:\s*(\d+)\s*$/m);
-    return orderMatch ? Number.parseInt(orderMatch[1], 10) : Number.POSITIVE_INFINITY;
-}
-function collectMarkdownFiles(rootPath) {
-    if (!fs.existsSync(rootPath)) {
-        throw new Error(`Book export root not found: ${rootPath}`);
-    }
-    const stats = fs.statSync(rootPath);
-    if (stats.isFile()) {
-        return [rootPath];
-    }
-    const entries = fs.readdirSync(rootPath, { withFileTypes: true });
-    return sortPaths(entries.flatMap((entry) => {
-        const fullPath = path.join(rootPath, entry.name);
-        if (entry.isDirectory()) {
-            return collectMarkdownFiles(fullPath);
-        }
-        if (entry.isFile() && (entry.name.endsWith('.md') || entry.name.endsWith('.mdx'))) {
-            return [fullPath];
-        }
-        return [];
-    }));
-}
-function stripFrontmatter(content) {
-    return content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '').trim();
-}
-function stripMdxOnlySyntax(content) {
-    return content
-        .replace(/^import\s.+$/gm, '')
-        .replace(/^\s*<\/?[A-Z][^>]*>\s*$/gm, '')
-        .replace(/\n{3,}/g, '\n\n')
-        .trim();
-}
-function inferExportRootFromBasePath(book) {
-    const normalizedBasePath = String(book.basePath || '').trim();
-    const knowledgePrefix = '/knowledge/';
-    if (!normalizedBasePath.startsWith(knowledgePrefix)) {
-        throw new Error(`Book basePath must start with "${knowledgePrefix}" to infer exports: ${book.basePath}`);
-    }
-    const relativeKnowledgePath = normalizedBasePath
-        .slice(knowledgePrefix.length)
-        .replace(/^\/+|\/+$/g, '');
-    if (!relativeKnowledgePath) {
-        throw new Error(`Book basePath must identify a knowledge directory: ${book.basePath}`);
-    }
-    return path.join(PROJECT_TENANT.content.docs, relativeKnowledgePath);
-}
-function resolveExportRoots(book) {
-    if (Array.isArray(book.exportRoots) && book.exportRoots.length > 0) {
-        return book.exportRoots;
-    }
-    return [inferExportRootFromBasePath(book)];
-}
-function resolveBookFiles(book) {
-    const files = resolveExportRoots(book).flatMap((root) => collectMarkdownFiles(path.resolve(projectRoot, root)).sort((left, right) => {
-        const orderDelta = getSidebarOrder(left) - getSidebarOrder(right);
-        if (orderDelta !== 0)
-            return orderDelta;
-        return left.localeCompare(right, undefined, { numeric: true, sensitivity: 'base' });
-    }));
-    return Array.from(new Set(files));
-}
-function buildBookMarkdown(book) {
-    const sections = resolveBookFiles(book).map((filePath) => {
-        const rawContent = fs.readFileSync(filePath, 'utf8');
-        return stripMdxOnlySyntax(stripFrontmatter(rawContent));
-    });
-    return `# ${book.downloadTitle}\n\n> This document is auto-generated from the TreeSeed knowledge source.\n\n${sections.join('\n\n---\n\n')}\n`;
-}
-function ensureOutputDir() {
-    fs.mkdirSync(outputDir, { recursive: true });
-}
-function writeBookOutput(fileName, content) {
-    const outputPath = path.join(outputDir, fileName);
-    fs.writeFileSync(outputPath, content);
-    return outputPath;
-}
-function main() {
-    console.log('Generating TreeSeed knowledge exports...');
-    ensureOutputDir();
-    const bookOutputs = BOOKS.map((book) => {
-        const content = buildBookMarkdown(book);
-        const outputPath = writeBookOutput(book.downloadFileName, content);
-        console.log(`Generated ${path.relative(projectRoot, outputPath)}`);
-        return { book, content };
-    });
-    const compositeContent = `# ${TREESEED_LIBRARY_DOWNLOAD.downloadTitle}\n\n> This document is auto-generated from the TreeSeed knowledge source.\n\n${bookOutputs
-        .map(({ content }) => content.trim())
-        .join('\n\n---\n\n')}\n`;
-    const compositeOutputPath = writeBookOutput(TREESEED_LIBRARY_DOWNLOAD.downloadFileName, compositeContent);
-    console.log(`Generated ${path.relative(projectRoot, compositeOutputPath)}`);
-    if (fs.existsSync(legacyOutputFile)) {
-        fs.rmSync(legacyOutputFile);
-        console.log(`Removed legacy export ${path.relative(projectRoot, legacyOutputFile)}`);
+async function main() {
+    console.log('Generating Treeseed AI book packages...');
+    const result = await exportTenantBookPackages({ projectRoot: PROJECT_TENANT.__tenantRoot ?? process.cwd() });
+    for (const entry of result.bookPackages) {
+        console.log(`Generated ${path.relative(result.projectRoot, entry.markdownPath)}`);
+        console.log(`Generated ${path.relative(result.projectRoot, entry.indexPath)}`);
     }
+    console.log(`Generated ${path.relative(result.projectRoot, result.libraryPackage.markdownPath)}`);
+    console.log(`Generated ${path.relative(result.projectRoot, result.libraryPackage.indexPath)}`);
 }
-main();
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/scripts/test-smoke.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
 import { mkdtempSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
@@ -24,36 +24,92 @@ function run(command, args, cwd = packageRoot, capture = false) {
     }
     return (result.stdout ?? '').trim();
 }
-function resolveNodeModulesRoot() {
-    let lastCandidate = null;
-    let current = packageRoot;
-    while (true) {
-        const candidate = resolve(current, 'node_modules');
-        try {
-            readdirSync(candidate);
-            lastCandidate = candidate;
+function runtimeDependencyNamesFor(root) {
+    const packageJson = JSON.parse(readFileSync(resolve(root, 'package.json'), 'utf8'));
+    return Object.keys(packageJson.dependencies ?? {});
+}
+function resolveWorkspaceRuntimePackageRoots() {
+    const roots = new Map();
+    for (const dependencyName of runtimeDependencyNamesFor(packageRoot)) {
+        const dependencyRoot = resolveTreeseedRuntimeDependencyRoot(dependencyName);
+        if (dependencyRoot) {
+            roots.set(dependencyName, dependencyRoot);
+        }
+    }
+    return roots;
+}
+function collectRuntimeDependenciesForPackaging() {
+    const dependencyNames = new Set(runtimeDependencyNamesFor(packageRoot));
+    const searchRoots = [
+        packageRoot,
+        sdkPackageRoot,
+    ];
+    const queue = [...resolveWorkspaceRuntimePackageRoots().values()];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const nextRoot = queue.shift();
+        if (!nextRoot || visited.has(nextRoot)) {
+            continue;
         }
-        catch {
+        visited.add(nextRoot);
+        for (const dependencyName of runtimeDependencyNamesFor(nextRoot)) {
+            dependencyNames.add(dependencyName);
+            const dependencyRoot = resolveTreeseedRuntimeDependencyRoot(dependencyName, searchRoots);
+            if (dependencyRoot) {
+                queue.push(dependencyRoot);
+            }
+        }
+    }
+    return dependencyNames;
+}
+function resolveTreeseedRuntimeDependencyRoot(packageName, searchRoots = [packageRoot, sdkPackageRoot]) {
+    if (!packageName.startsWith('@treeseed/')) {
+        return null;
+    }
+    const folderName = packageName.slice('@treeseed/'.length);
+    const workspaceCandidateRoot = resolve(packageRoot, '..', folderName);
+    if (existsSync(resolve(workspaceCandidateRoot, 'package.json'))) {
+        return workspaceCandidateRoot;
+    }
+    try {
+        return resolveInstalledPackageRoot(packageName, searchRoots);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveInstalledPackageRoot(packageName, searchRoots) {
+    let resolvedEntry = require.resolve(packageName, { paths: searchRoots });
+    let current = dirname(resolvedEntry);
+    while (true) {
+        const packageJsonPath = resolve(current, 'package.json');
+        if (existsSync(packageJsonPath)) {
+            return current;
         }
         const parent = resolve(current, '..');
-        if (parent === current)
-            break;
+        if (parent === current) {
+            throw new Error(`Unable to resolve installed package root for ${packageName}.`);
+        }
         current = parent;
     }
-    if (lastCandidate) {
-        return lastCandidate;
-    }
-    throw new Error(`Unable to locate node_modules for ${packageRoot}.`);
 }
-function mirrorDependencies(tempRoot) {
-    const sharedNodeModules = resolveNodeModulesRoot();
-    for (const entry of readdirSync(sharedNodeModules, { withFileTypes: true })) {
-        if (entry.name === '.bin' || entry.name === '@treeseed') {
+function mirrorDependencies(tempRoot, excludedPackages = new Set()) {
+    const runtimeDependencies = collectRuntimeDependenciesForPackaging();
+    const searchRoots = [
+        packageRoot,
+        ...resolveWorkspaceRuntimePackageRoots().values(),
+    ];
+    for (const packageName of runtimeDependencies) {
+        if (excludedPackages.has(packageName) || packageName === '@treeseed/core') {
+            continue;
+        }
+        const sourcePath = resolveInstalledPackageRoot(packageName, searchRoots);
+        const targetPath = resolve(tempRoot, 'node_modules', ...packageName.split('/'));
+        if (existsSync(targetPath)) {
             continue;
         }
-        const targetPath = resolve(tempRoot, 'node_modules', entry.name);
         mkdirSync(dirname(targetPath), { recursive: true });
-        symlinkSync(resolve(sharedNodeModules, entry.name), targetPath, 'dir');
+        symlinkSync(sourcePath, targetPath, 'dir');
     }
 }
 function pack(root, outputRoot, fallbackName) {
@@ -98,6 +154,7 @@ try {
     mkdirSync(packRoot, { recursive: true });
     mkdirSync(extractRoot, { recursive: true });
     const coreTarball = pack(packageRoot, packRoot, 'treeseed-core.tgz');
+    const workspaceRuntimePackageRoots = resolveWorkspaceRuntimePackageRoots();
     if (existsSync(resolve(sdkPackageRoot, 'scripts', 'run-ts.mjs'))) {
         const sdkTarball = pack(sdkPackageRoot, packRoot, 'treeseed-sdk.tgz');
         installPackagedPackage(extractRoot, installRoot, sdkTarball, 'sdk');
@@ -106,7 +163,7 @@ try {
         installPackageDirectory(installRoot, sdkPackageRoot, 'sdk');
     }
     installPackagedPackage(extractRoot, installRoot, coreTarball, 'core');
-    mirrorDependencies(installRoot);
+    mirrorDependencies(installRoot, new Set(workspaceRuntimePackageRoots.keys()));
     writeFileSync(resolve(installRoot, 'package.json'), `${JSON.stringify({ name: 'treeseed-core-smoke', private: true, type: 'module' }, null, 2)}\n`, 'utf8');
     run(process.execPath, [
         '--input-type=module',
@@ -117,7 +174,6 @@ try {
             'await import("@treeseed/core/runtime-types");',
             'await import("@treeseed/core/contracts/messages");',
             'await import("@treeseed/core/contracts/run");',
-            'await import("@treeseed/core/services/manager");',
             'await import("@treeseed/core/services/worker");',
             'await import("@treeseed/core/services/workday-start");',
             'await import("@treeseed/core/services/workday-report");',