@treeseed/sdk 0.4.7 → 0.4.9

package/dist/platform/environment.js

@@ -21,6 +21,7 @@ const TREESEED_ENVIRONMENT_TARGETS = [
 ];
 const TREESEED_ENVIRONMENT_PURPOSES = ["dev", "save", "deploy", "destroy", "config"];
 const TREESEED_ENVIRONMENT_SENSITIVITY = ["secret", "plain", "derived"];
+const TREESEED_ENVIRONMENT_STORAGE = ["scoped", "shared"];
 const moduleDir = dirname(fileURLToPath(import.meta.url));
 const CORE_ENVIRONMENT_PATH = resolve(moduleDir, "env.yaml");
 const TENANT_ENVIRONMENT_OVERLAY_PATH = "src/env.yaml";
@@ -45,9 +46,69 @@ function railwayManagedEnabled(context) {
 function generatedSecret(bytes = 24) {
   return randomBytes(bytes).toString("hex");
 }
+function normalizeUrl(value) {
+  return value.trim().replace(/\/$/u, "");
+}
+function primaryHostFromUrl(value) {
+  if (!value || value.trim().length === 0) {
+    return void 0;
+  }
+  try {
+    return new URL(value).host;
+  } catch {
+    return void 0;
+  }
+}
+function parseDomainList(value) {
+  return String(value ?? "").split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function deriveApiDomainFromProjectDomain(domain) {
+  if (!domain) {
+    return void 0;
+  }
+  if (domain.startsWith("api.")) {
+    return domain;
+  }
+  const segments = domain.split(".").filter(Boolean);
+  if (segments.length <= 2) {
+    return `api.${domain}`;
+  }
+  return `api.${segments.slice(1).join(".")}`;
+}
+function resolveConfiguredApiBaseUrl(context, scope, values = {}) {
+  const localBaseUrl = context.deployConfig.services?.api?.environments?.local?.baseUrl ?? context.deployConfig.surfaces?.api?.localBaseUrl ?? "http://127.0.0.1:3000";
+  if (scope === "local") {
+    return normalizeUrl(localBaseUrl);
+  }
+  const scopedBaseUrl = context.deployConfig.services?.api?.environments?.[scope]?.baseUrl ?? context.deployConfig.services?.api?.publicBaseUrl ?? context.deployConfig.surfaces?.api?.publicBaseUrl;
+  if (scopedBaseUrl) {
+    return normalizeUrl(scopedBaseUrl);
+  }
+  const projectDomains = [
+    ...parseDomainList(values.TREESEED_PROJECT_DOMAINS),
+    primaryHostFromUrl(context.deployConfig.siteUrl)
+  ].filter(Boolean);
+  for (const domain of projectDomains) {
+    const apiDomain = deriveApiDomainFromProjectDomain(domain);
+    if (apiDomain) {
+      return `https://${apiDomain}`;
+    }
+  }
+  return void 0;
+}
+function resolveWebServiceId(_values = {}) {
+  return "web";
+}
+function resolveApiWebServiceId(values = {}) {
+  return values.TREESEED_WEB_SERVICE_ID?.trim() || "web";
+}
 const VALUE_RESOLVERS = {
   generatedSecret: () => generatedSecret(),
-  localFormsBypassDefault: () => "true"
+  localFormsBypassDefault: () => "true",
+  projectDomainsDefault: (context) => primaryHostFromUrl(context.deployConfig.siteUrl),
+  apiBaseUrlDefault: (context, scope, values) => resolveConfiguredApiBaseUrl(context, scope, values),
+  webServiceIdDefault: (_context, _scope, values) => resolveWebServiceId(values),
+  apiWebServiceIdDefault: (_context, _scope, values) => resolveApiWebServiceId(values)
 };
 const PREDICATES = {
   turnstileEnabled: (context) => turnstileEnabled(context),
@@ -135,6 +196,7 @@ function materializeEntry(id, entry) {
   return {
     ...entry,
     id,
+    storage: entry.storage ?? "scoped",
     defaultValue: resolveNamedValueResolver(entry.defaultValueRef),
     localDefaultValue: resolveNamedValueResolver(entry.localDefaultValueRef),
     isRelevant: resolveNamedPredicate(entry.relevanceRef),
@@ -233,18 +295,30 @@ function isEntryRequired(entry, context, scope, purpose) {
   }
   return false;
 }
-function materializeDefaultValue(entry, context, scope) {
+function materializeDefaultValue(entry, context, scope, values = {}) {
   const source = scope === "local" && entry.localDefaultValue !== void 0 ? entry.localDefaultValue : entry.defaultValue;
   if (source === void 0) {
     return void 0;
   }
-  return typeof source === "function" ? source(context, scope) : source;
+  return typeof source === "function" ? source(context, scope, values) : source;
 }
 function getTreeseedEnvironmentSuggestedValues(options) {
   const registry = resolveTreeseedEnvironmentRegistry(options);
-  return Object.fromEntries(
-    registry.entries.filter((entry) => isTreeseedEnvironmentEntryRelevant(entry, registry.context, options.scope, options.purpose)).map((entry) => [entry.id, materializeDefaultValue(entry, registry.context, options.scope)]).filter(([, value]) => value !== void 0)
-  );
+  const suggestedValues = {};
+  const seedValues = { ...options.values ?? {} };
+  for (const entry of registry.entries.filter(
+    (candidate) => isTreeseedEnvironmentEntryRelevant(candidate, registry.context, options.scope, options.purpose)
+  )) {
+    const value = materializeDefaultValue(entry, registry.context, options.scope, { ...suggestedValues, ...seedValues });
+    if (value === void 0) {
+      continue;
+    }
+    suggestedValues[entry.id] = value;
+  }
+  return suggestedValues;
+}
+function isTreeseedEnvironmentEntryRequired(entry, context, scope, purpose) {
+  return isEntryRequired(entry, context, scope, purpose);
 }
 function valuePresent(value) {
   return typeof value === "string" && value.trim().length > 0;
@@ -322,9 +396,11 @@ export {
   TREESEED_ENVIRONMENT_REQUIREMENTS,
   TREESEED_ENVIRONMENT_SCOPES,
   TREESEED_ENVIRONMENT_SENSITIVITY,
+  TREESEED_ENVIRONMENT_STORAGE,
   TREESEED_ENVIRONMENT_TARGETS,
   getTreeseedEnvironmentSuggestedValues,
   isTreeseedEnvironmentEntryRelevant,
+  isTreeseedEnvironmentEntryRequired,
   loadTreeseedEnvironmentOverlay,
   resolveTreeseedEnvironmentContext,
   resolveTreeseedEnvironmentRegistry,

package/dist/remote.d.ts

@@ -1,3 +1,4 @@
+import type { RemoteJob, RemoteJobEvent, SdkDispatchRequest, SdkDispatchResult } from './sdk-types.ts';
 export declare const TREESEED_REMOTE_CONTRACT_VERSION = 1;
 export declare const TREESEED_REMOTE_CONTRACT_HEADER = "x-treeseed-remote-contract-version";
 export type ApiScope = string;
@@ -111,6 +112,25 @@ export interface RemoteWorkflowOperationResponse {
     payload?: Record<string, unknown> | null;
     nextSteps?: RemoteWorkflowNextStep[];
 }
+export interface RemoteJobPullRequest {
+    limit?: number;
+    runnerId?: string;
+}
+export interface RemoteJobPullResponse {
+    ok: true;
+    payload: RemoteJob[];
+}
+export interface RemoteJobProgressRequest {
+    summary?: string;
+    data?: Record<string, unknown>;
+}
+export interface RemoteJobCompletionRequest {
+    output?: unknown;
+}
+export interface RemoteJobFailureRequest {
+    code?: string;
+    message: string;
+}
 export declare class RemoteTreeseedClient {
     readonly config: RemoteTreeseedConfig;
     private readonly fetchImpl;
@@ -141,15 +161,6 @@ export declare class RemoteTreeseedSdkClient {
     constructor(client: RemoteTreeseedClient);
     execute<T = unknown>(operation: string, request: RemoteSdkOperationRequest): Promise<T>;
 }
-export declare class TreeseedGatewayClient {
-    private readonly baseUrl;
-    private readonly token;
-    private readonly fetchImpl;
-    constructor(config: import('./sdk-types.ts').SdkGatewayClientConfig);
-    requestJson<T>(path: string, options?: RemoteGatewayRequest): Promise<T & {
-        error?: string;
-    }>;
-}
 export declare class CloudflareQueuePullClient {
     private readonly baseUrl;
     private readonly token;
@@ -170,8 +181,53 @@ export declare class CloudflareQueuePullClient {
         delaySeconds?: number;
     }>): Promise<unknown>;
 }
+export declare class CloudflareQueuePushClient {
+    private readonly baseUrl;
+    private readonly token;
+    private readonly fetchImpl;
+    constructor(config: import('./sdk-types.ts').SdkQueuePushClientConfig);
+    enqueue(request: import('./sdk-types.ts').SdkQueuePushRequest): Promise<void>;
+}
 export declare class RemoteTreeseedOperationsClient {
     private readonly client;
     constructor(client: RemoteTreeseedClient);
     execute(operation: string, request: RemoteWorkflowOperationRequest): Promise<RemoteWorkflowOperationResponse>;
 }
+export declare class RemoteTreeseedDispatchClient {
+    private readonly client;
+    constructor(client: RemoteTreeseedClient);
+    dispatch(projectId: string, request: SdkDispatchRequest): Promise<SdkDispatchResult>;
+}
+export declare class RemoteTreeseedJobsClient {
+    private readonly client;
+    constructor(client: RemoteTreeseedClient);
+    get(jobId: string): Promise<{
+        ok: true;
+        payload: RemoteJob;
+    }>;
+    cancel(jobId: string): Promise<{
+        ok: true;
+        payload: RemoteJob;
+    }>;
+    events(jobId: string): Promise<{
+        ok: true;
+        payload: RemoteJobEvent[];
+    }>;
+}
+export declare class RemoteTreeseedRunnerClient {
+    private readonly client;
+    constructor(client: RemoteTreeseedClient);
+    pull(projectId: string, request?: RemoteJobPullRequest): Promise<RemoteJobPullResponse>;
+    progress(jobId: string, request?: RemoteJobProgressRequest): Promise<{
+        ok: true;
+        payload: RemoteJob;
+    }>;
+    complete(jobId: string, request?: RemoteJobCompletionRequest): Promise<{
+        ok: true;
+        payload: RemoteJob;
+    }>;
+    fail(jobId: string, request: RemoteJobFailureRequest): Promise<{
+        ok: true;
+        payload: RemoteJob;
+    }>;
+}

package/dist/remote.js

@@ -100,32 +100,6 @@ class RemoteTreeseedSdkClient {
 function normalizeExternalBaseUrl(baseUrl) {
   return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
 }
-class TreeseedGatewayClient {
-  baseUrl;
-  token;
-  fetchImpl;
-  constructor(config) {
-    this.baseUrl = normalizeExternalBaseUrl(config.baseUrl);
-    this.token = config.bearerToken;
-    this.fetchImpl = config.fetchImpl ?? fetch;
-  }
-  async requestJson(path, options = {}) {
-    const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
-      method: options.method ?? "POST",
-      headers: {
-        accept: "application/json",
-        authorization: `Bearer ${this.token}`,
-        ...options.body === void 0 ? {} : { "content-type": "application/json" }
-      },
-      body: options.body === void 0 ? void 0 : JSON.stringify(options.body)
-    });
-    const payload = await response.json().catch(() => ({}));
-    if (!response.ok) {
-      throw new Error(typeof payload.error === "string" ? payload.error : `Gateway request failed with ${response.status}.`);
-    }
-    return payload;
-  }
-}
 class CloudflareQueuePullClient {
   baseUrl;
   token;
@@ -177,6 +151,36 @@ class CloudflareQueuePullClient {
     });
   }
 }
+class CloudflareQueuePushClient {
+  baseUrl;
+  token;
+  fetchImpl;
+  constructor(config) {
+    const apiBaseUrl = config.apiBaseUrl ?? "https://api.cloudflare.com/client/v4/accounts";
+    this.baseUrl = `${normalizeExternalBaseUrl(apiBaseUrl)}/${config.accountId}/queues/${config.queueId}`;
+    this.token = config.token;
+    this.fetchImpl = config.fetchImpl ?? fetch;
+  }
+  async enqueue(request) {
+    const response = await this.fetchImpl(`${this.baseUrl}/messages`, {
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${this.token}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        body: request.message,
+        content_type: "json",
+        delay_seconds: request.delaySeconds ?? 0
+      })
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok || payload.success === false) {
+      throw new Error(payload.errors?.[0]?.message ?? `Queue request failed with ${response.status}.`);
+    }
+  }
+}
 class RemoteTreeseedOperationsClient {
   constructor(client) {
     this.client = client;
@@ -190,13 +194,85 @@ class RemoteTreeseedOperationsClient {
     });
   }
 }
+class RemoteTreeseedDispatchClient {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  dispatch(projectId, request) {
+    return this.client.requestJson(`/v1/projects/${encodeURIComponent(projectId)}/dispatch`, {
+      method: "POST",
+      body: request,
+      requireAuth: true
+    });
+  }
+}
+class RemoteTreeseedJobsClient {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  get(jobId) {
+    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}`, {
+      requireAuth: true
+    });
+  }
+  cancel(jobId) {
+    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}/cancel`, {
+      method: "POST",
+      requireAuth: true
+    });
+  }
+  events(jobId) {
+    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}/events`, {
+      requireAuth: true
+    });
+  }
+}
+class RemoteTreeseedRunnerClient {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  pull(projectId, request = {}) {
+    return this.client.requestJson(`/v1/projects/${encodeURIComponent(projectId)}/runner/jobs/pull`, {
+      method: "POST",
+      body: request,
+      requireAuth: true
+    });
+  }
+  progress(jobId, request = {}) {
+    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}/progress`, {
+      method: "POST",
+      body: request,
+      requireAuth: true
+    });
+  }
+  complete(jobId, request = {}) {
+    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}/complete`, {
+      method: "POST",
+      body: request,
+      requireAuth: true
+    });
+  }
+  fail(jobId, request) {
+    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}/fail`, {
+      method: "POST",
+      body: request,
+      requireAuth: true
+    });
+  }
+}
 export {
   CloudflareQueuePullClient,
+  CloudflareQueuePushClient,
   RemoteTreeseedAuthClient,
   RemoteTreeseedClient,
+  RemoteTreeseedDispatchClient,
+  RemoteTreeseedJobsClient,
   RemoteTreeseedOperationsClient,
+  RemoteTreeseedRunnerClient,
   RemoteTreeseedSdkClient,
   TREESEED_REMOTE_CONTRACT_HEADER,
-  TREESEED_REMOTE_CONTRACT_VERSION,
-  TreeseedGatewayClient
+  TREESEED_REMOTE_CONTRACT_VERSION
 };

package/dist/scripts/aggregate-book.js

@@ -1,121 +1,16 @@
-import fs from 'node:fs';
 import path from 'node:path';
-import { buildTenantBookRuntime } from '../platform/books-data.js';
-import { loadTreeseedManifest } from '../platform/tenant-config.js';
-const PROJECT_TENANT = loadTreeseedManifest();
-const { BOOKS, TREESEED_LIBRARY_DOWNLOAD } = buildTenantBookRuntime(PROJECT_TENANT, {
-    projectRoot: PROJECT_TENANT.__tenantRoot ?? process.cwd(),
-    docsLibraryDownload: {
-        downloadFileName: 'karyon-knowledge.md',
-        downloadHref: '/books/karyon-knowledge.md',
-        downloadTitle: 'Karyon Knowledge Library',
-    },
-});
-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}`);
+import { exportTenantBookPackages } from '../platform/book-export.js';
+async function main() {
+    console.log('Generating Treeseed AI book packages...');
+    const result = await exportTenantBookPackages({ projectRoot: 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)}`);
     }
-    return path.join(PROJECT_TENANT.content.docs, relativeKnowledgePath);
+    console.log(`Generated ${path.relative(result.projectRoot, result.libraryPackage.markdownPath)}`);
+    console.log(`Generated ${path.relative(result.projectRoot, result.libraryPackage.indexPath)}`);
 }
-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 Karyon 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 contextual Karyon 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 Karyon 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)}`);
-    }
-}
-main();
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/scripts/config-treeseed.js

@@ -1,8 +1,5 @@
 #!/usr/bin/env node
-import readline from 'node:readline/promises';
-import { stdin as input, stdout as output } from 'node:process';
-import { collectCliPreflight } from '../operations/services/workspace-preflight.js';
-import { applyTreeseedEnvironmentToProcess, ensureTreeseedGitignoreEntries, getTreeseedMachineConfigPaths, rotateTreeseedMachineKey, runTreeseedConfigWizard, writeTreeseedLocalEnvironmentFiles, } from '../operations/services/config-runtime.js';
+import { applyTreeseedConfigValues, applyTreeseedSafeRepairs, collectTreeseedConfigContext, ensureTreeseedGitignoreEntries, finalizeTreeseedConfig, getTreeseedMachineConfigPaths, rotateTreeseedMachineKey, } from '../operations/services/config-runtime.js';
 const tenantRoot = process.cwd();
 function parseArgs(argv) {
     const parsed = {
@@ -45,42 +42,37 @@ const scopes = options.scopes.length === 0 || options.scopes.includes('all')
     ? ['local', 'staging', 'prod']
     : ['local', 'staging', 'prod'].filter((scope) => options.scopes.includes(scope));
 ensureTreeseedGitignoreEntries(tenantRoot);
-const preflight = collectCliPreflight({ cwd: tenantRoot, requireAuth: false });
-const rl = readline.createInterface({ input, output });
 try {
-    console.log('Treeseed configuration wizard');
-    console.log('This command writes a local machine config, generates .env.local and .dev.vars, and can sync GitHub or Cloudflare settings.');
-    console.log('Enter a value to set it, press Enter to keep the current/default value, or enter "-" to clear a value.\n');
     if (options.rotateMachineKey) {
         const result = rotateTreeseedMachineKey(tenantRoot);
         console.log('Treeseed machine key rotated.');
         console.log(`Machine key: ${result.keyPath}`);
     }
     else {
-        const result = await runTreeseedConfigWizard({
+        applyTreeseedSafeRepairs(tenantRoot);
+        const context = collectTreeseedConfigContext({
+            tenantRoot,
+            scopes,
+            env: process.env,
+        });
+        const updates = scopes.flatMap((scope) => context.entriesByScope[scope].map((entry) => ({
+            scope,
+            entryId: entry.id,
+            value: entry.effectiveValue,
+            reused: entry.currentValue.length > 0 || entry.suggestedValue.length > 0,
+        })));
+        const applyResult = applyTreeseedConfigValues({ tenantRoot, updates });
+        const result = finalizeTreeseedConfig({
             tenantRoot,
             scopes,
             sync: options.sync,
-            authStatus: preflight.checks.auth,
-            prompt: async (message) => {
-                if (!process.stdin.isTTY || !process.stdout.isTTY) {
-                    return '';
-                }
-                try {
-                    return await rl.question(message);
-                }
-                catch {
-                    return '';
-                }
-            },
+            env: process.env,
         });
-        writeTreeseedLocalEnvironmentFiles(tenantRoot);
-        applyTreeseedEnvironmentToProcess({ tenantRoot, scope: 'local', override: true });
         const { configPath, keyPath } = getTreeseedMachineConfigPaths(tenantRoot);
-        console.log('\nTreeseed config completed.');
+        console.log('Treeseed config completed.');
         console.log(`Machine config: ${configPath}`);
         console.log(`Machine key: ${keyPath}`);
-        console.log(`Updated values: ${result.updated.length}`);
+        console.log(`Updated values: ${applyResult.updated.length}`);
         console.log(`Initialized environments: ${result.initialized.length}`);
         if (result.synced.github) {
             console.log(`GitHub sync: ${result.synced.github.secrets.length} secrets, ${result.synced.github.variables.length} variables (${result.synced.github.repository})`);
@@ -91,5 +83,4 @@ try {
     }
 }
 finally {
-    rl.close();
 }

package/dist/sdk-dispatch.d.ts

@@ -0,0 +1,12 @@
+import type { AgentSdk } from './sdk.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 | null;
+export declare function executeSdkOperation(sdk: AgentSdk, operationName: string, input: JsonRecord): Promise<unknown>;
+export {};