@treeseed/sdk 0.13.0-rc.6 → 0.13.0-rc.8

package/dist/api/configuration/config.js

@@ -1,149 +0,0 @@
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-const LOCAL_DEV_AUTH_TTL_SECONDS = 365 * 24 * 60 * 60;
-const DEFAULT_AUTH_TTL_SECONDS = 15 * 60;
-const DEFAULT_REFRESH_TTL_SECONDS = 7 * 24 * 60 * 60;
-const DEFAULT_LOCAL_API_DATABASE_PORT = "54329";
-const DEFAULT_LOCAL_API_DATABASE_NAME = "treeseed_api";
-const DEFAULT_LOCAL_API_DATABASE_USER = "treeseed";
-const DEFAULT_LOCAL_API_DATABASE_PASSWORD = "treeseed-local-dev";
-function parseInteger(value, fallback) {
-  if (!value) return fallback;
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) ? parsed : fallback;
-}
-function resolveLocalWranglerConfigPath(repoRoot, env) {
-  const explicit = env.TREESEED_API_D1_WRANGLER_CONFIG?.trim() || env.TREESEED_LOCAL_WRANGLER_CONFIG?.trim();
-  if (explicit) return resolve(repoRoot, explicit);
-  const generated = resolve(repoRoot, ".treeseed", "generated", "environments", "local", "wrangler.toml");
-  return existsSync(generated) ? generated : void 0;
-}
-function normalizeUrl(value) {
-  return value.endsWith("/") ? value.slice(0, -1) : value;
-}
-function isLoopbackUrl(value) {
-  try {
-    const url = new URL(value);
-    return url.hostname === "127.0.0.1" || url.hostname === "localhost";
-  } catch {
-    return false;
-  }
-}
-function parseCsv(value) {
-  return (value ?? "").split(",").map((entry) => entry.trim().toLowerCase()).filter(Boolean);
-}
-function firstEnvValue(env, ...keys) {
-  for (const key of keys) {
-    const value = env[key]?.trim();
-    if (value) return value;
-  }
-  return void 0;
-}
-function encodeDatabaseUrlPart(value) {
-  return encodeURIComponent(value);
-}
-function resolveLocalApiDatabaseUrl(env = process.env) {
-  const port = firstEnvValue(env, "TREESEED_MARKET_LOCAL_POSTGRES_PORT", "TREESEED_API_LOCAL_POSTGRES_PORT") || DEFAULT_LOCAL_API_DATABASE_PORT;
-  const database = firstEnvValue(env, "TREESEED_MARKET_LOCAL_POSTGRES_DATABASE", "TREESEED_API_LOCAL_POSTGRES_DATABASE") || DEFAULT_LOCAL_API_DATABASE_NAME;
-  const user = firstEnvValue(env, "TREESEED_MARKET_LOCAL_POSTGRES_USER", "TREESEED_API_LOCAL_POSTGRES_USER") || DEFAULT_LOCAL_API_DATABASE_USER;
-  const password = firstEnvValue(env, "TREESEED_MARKET_LOCAL_POSTGRES_PASSWORD", "TREESEED_API_LOCAL_POSTGRES_PASSWORD") || DEFAULT_LOCAL_API_DATABASE_PASSWORD;
-  return `postgres://${encodeDatabaseUrlPart(user)}:${encodeDatabaseUrlPart(password)}@127.0.0.1:${port}/${encodeDatabaseUrlPart(database)}`;
-}
-function resolveApiDatabaseUrl(env = process.env, baseUrl) {
-  const explicit = firstEnvValue(env, "TREESEED_DATABASE_URL");
-  if (explicit) return explicit;
-  const environment = firstEnvValue(env, "TREESEED_API_ENVIRONMENT", "TREESEED_ENVIRONMENT");
-  const localMode = env.LOCAL_DEV_MODE !== void 0 || environment === "local" || (baseUrl ? isLoopbackUrl(baseUrl) : false);
-  return localMode ? resolveLocalApiDatabaseUrl(env) : void 0;
-}
-function resolveBaseUrl(env, host, port) {
-  if (env.TREESEED_API_BASE_URL?.trim()) {
-    return normalizeUrl(env.TREESEED_API_BASE_URL.trim());
-  }
-  if (env.RAILWAY_PUBLIC_DOMAIN?.trim()) {
-    return normalizeUrl(`https://${env.RAILWAY_PUBLIC_DOMAIN.trim()}`);
-  }
-  return normalizeUrl(`http://${host}:${port}`);
-}
-function resolveAuthApprovalBaseUrl(env, baseUrl) {
-  const explicit = env.TREESEED_API_AUTH_APPROVAL_BASE_URL?.trim() || env.TREESEED_SITE_URL?.trim() || env.TREESEED_BETTER_AUTH_URL?.trim();
-  const explicitIsLoopback = explicit ? isLoopbackUrl(explicit) : false;
-  try {
-    const url = new URL(baseUrl);
-    const isLocalApi = url.hostname === "127.0.0.1" || url.hostname === "localhost";
-    if (!isLocalApi && explicit && explicitIsLoopback) {
-      throw new Error(`Refusing loopback device approval URL "${explicit}" for remote API "${baseUrl}".`);
-    }
-    if (explicit) {
-      return normalizeUrl(explicit);
-    }
-    if (isLocalApi && url.port === "3000") {
-      url.port = "4321";
-      return normalizeUrl(url.toString());
-    }
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("Refusing loopback device approval URL")) {
-      throw error;
-    }
-    if (explicit && /^https?:\/\//u.test(explicit)) {
-      throw new Error(`Invalid device approval URL configuration for API "${baseUrl}".`);
-    }
-  }
-  return baseUrl;
-}
-function resolveApiConfig(env = process.env) {
-  const host = env.HOST?.trim() || "0.0.0.0";
-  const port = parseInteger(env.PORT, 3e3);
-  const baseUrl = resolveBaseUrl(env, host === "0.0.0.0" ? "127.0.0.1" : host, port);
-  const issuer = normalizeUrl(env.TREESEED_API_ISSUER?.trim() || baseUrl);
-  const repoRoot = resolve(env.TREESEED_API_REPO_ROOT?.trim() || process.cwd());
-  const localDevAuth = env.LOCAL_DEV_MODE === "cloudflare" || isLoopbackUrl(baseUrl);
-  const defaultAccessTokenTtl = localDevAuth ? LOCAL_DEV_AUTH_TTL_SECONDS : DEFAULT_AUTH_TTL_SECONDS;
-  const defaultRefreshTokenTtl = localDevAuth ? LOCAL_DEV_AUTH_TTL_SECONDS : DEFAULT_REFRESH_TTL_SECONDS;
-  return {
-    name: env.TREESEED_API_NAME?.trim() || "@treeseed/sdk/api",
-    host,
-    port,
-    baseUrl,
-    authApprovalBaseUrl: resolveAuthApprovalBaseUrl(env, baseUrl),
-    issuer,
-    repoRoot,
-    projectId: env.TREESEED_PROJECT_ID?.trim() || "treeseed-project",
-    authSecret: env.TREESEED_API_AUTH_SECRET?.trim() || "treeseed-api-dev-secret",
-    projectApiKey: env.TREESEED_API_PROJECT_KEY?.trim() || void 0,
-    projectApiLabel: env.TREESEED_API_PROJECT_LABEL?.trim() || "Project API Key",
-    projectApiPermissions: parseCsv(env.TREESEED_API_PROJECT_KEY_PERMISSIONS).length > 0 ? parseCsv(env.TREESEED_API_PROJECT_KEY_PERMISSIONS) : ["sdk:execute:global", "agent:execute:global", "operations:execute:global"],
-    cloudflareAccountId: env.TREESEED_CLOUDFLARE_ACCOUNT_ID?.trim() || void 0,
-    cloudflareApiToken: env.TREESEED_CLOUDFLARE_API_TOKEN?.trim() || void 0,
-    apiDatabaseUrl: resolveApiDatabaseUrl(env, baseUrl),
-    d1DatabaseId: env.TREESEED_API_D1_DATABASE_ID?.trim() || void 0,
-    d1DatabaseName: env.TREESEED_API_D1_DATABASE_NAME?.trim() || env.SITE_DATA_DB?.trim() || void 0,
-    d1LocalPersistTo: env.TREESEED_API_D1_LOCAL_PERSIST_TO?.trim() || resolve(repoRoot, ".wrangler/state/v3/d1"),
-    d1WranglerConfigPath: resolveLocalWranglerConfigPath(repoRoot, env),
-    webServiceId: firstEnvValue(env, "TREESEED_WEB_SERVICE_ID", "TREESEED_API_WEB_SERVICE_ID") || "web",
-    webServiceSecret: firstEnvValue(env, "TREESEED_WEB_SERVICE_SECRET", "TREESEED_API_WEB_SERVICE_SECRET") || "treeseed-web-service-dev-secret",
-    webAssertionSecret: firstEnvValue(env, "TREESEED_API_WEB_ASSERTION_SECRET", "TREESEED_WEB_ASSERTION_SECRET", "TREESEED_API_AUTH_SECRET") || "treeseed-web-assertion-dev-secret",
-    webExchangeTtlSeconds: parseInteger(env.TREESEED_API_WEB_EXCHANGE_TTL, 300),
-    bootstrapAdminAllowlist: parseCsv(env.TREESEED_API_BOOTSTRAP_ADMIN_ALLOWLIST),
-    accessTokenTtlSeconds: parseInteger(env.TREESEED_API_ACCESS_TOKEN_TTL, defaultAccessTokenTtl),
-    refreshTokenTtlSeconds: parseInteger(env.TREESEED_API_REFRESH_TOKEN_TTL, defaultRefreshTokenTtl),
-    deviceCodeTtlSeconds: parseInteger(env.TREESEED_API_DEVICE_CODE_TTL, 10 * 60),
-    deviceCodePollIntervalSeconds: parseInteger(env.TREESEED_API_DEVICE_CODE_POLL_INTERVAL, 5),
-    templateCatalogPath: env.TREESEED_API_TEMPLATE_CATALOG_PATH?.trim() || void 0,
-    providers: {
-      auth: env.TREESEED_API_PROVIDER_AUTH?.trim() || "d1",
-      agents: {
-        execution: env.TREESEED_API_PROVIDER_AGENT_EXECUTION?.trim() || "codex",
-        queue: env.TREESEED_API_PROVIDER_AGENT_QUEUE?.trim() || "memory",
-        notification: env.TREESEED_API_PROVIDER_AGENT_NOTIFICATION?.trim() || "sdk_message",
-        repository: env.TREESEED_API_PROVIDER_AGENT_REPOSITORY?.trim() || "git",
-        verification: env.TREESEED_API_PROVIDER_AGENT_VERIFICATION?.trim() || "local"
-      }
-    }
-  };
-}
-export {
-  resolveApiConfig,
-  resolveApiDatabaseUrl,
-  resolveLocalApiDatabaseUrl
-};

package/dist/api/hosting/railway.d.ts

@@ -1,53 +0,0 @@
-import type { Hono } from 'hono';
-import { type Server } from 'node:http';
-import type { ApiServerOptions } from '../types.js';
-export declare function createNodeServer(options?: ApiServerOptions): Promise<{
-    app: Hono<{
-        Variables: import("../types.js").AppVariables;
-    }, import("hono/types").BlankSchema, "/">;
-    config: {
-        providers: {
-            agents: {
-                execution: string;
-                queue: string;
-                notification: string;
-                repository: string;
-                verification: string;
-            };
-            auth: string;
-        };
-        name: string;
-        host: string;
-        port: number;
-        baseUrl: string;
-        authApprovalBaseUrl?: string;
-        issuer: string;
-        repoRoot: string;
-        projectId: string;
-        authSecret: string;
-        projectApiKey?: string;
-        projectApiLabel: string;
-        projectApiPermissions: string[];
-        cloudflareAccountId?: string;
-        cloudflareApiToken?: string;
-        apiDatabaseUrl?: string;
-        d1DatabaseId?: string;
-        d1DatabaseName?: string;
-        d1LocalPersistTo?: string;
-        d1WranglerConfigPath?: string;
-        webServiceId: string;
-        webServiceSecret: string;
-        webAssertionSecret: string;
-        webExchangeTtlSeconds: number;
-        bootstrapAdminAllowlist: string[];
-        accessTokenTtlSeconds: number;
-        refreshTokenTtlSeconds: number;
-        deviceCodeTtlSeconds: number;
-        deviceCodePollIntervalSeconds: number;
-        templateCatalogPath?: string;
-    };
-    server: Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
-    url: string;
-    close(): Promise<void>;
-}>;
-export declare const createRailwayApiServer: typeof createNodeServer;

package/dist/api/hosting/railway.js

@@ -1,71 +0,0 @@
-import { createServer } from "node:http";
-import { Readable } from "node:stream";
-import { resolveApiConfig } from "../configuration/config.js";
-import { createApiApp } from "../support/app.js";
-function hasRequestBody(method) {
-  return method !== "GET" && method !== "HEAD";
-}
-async function honoNodeHandler(app, request, response) {
-  const req = request;
-  const res = response;
-  const origin = req.headers.host ? `http://${req.headers.host}` : "http://127.0.0.1";
-  const url = new URL(req.url ?? "/", origin);
-  const webRequest = new Request(url, {
-    method: req.method,
-    headers: req.headers,
-    body: hasRequestBody(req.method) ? req : void 0,
-    duplex: "half"
-  });
-  const webResponse = await app.fetch(webRequest);
-  res.statusCode = webResponse.status;
-  webResponse.headers.forEach((value, key) => {
-    res.setHeader(key, value);
-  });
-  if (!webResponse.body) {
-    res.end();
-    return;
-  }
-  Readable.fromWeb(webResponse.body).pipe(res);
-}
-async function createNodeServer(options = {}) {
-  const config = {
-    ...resolveApiConfig(),
-    ...options.config ?? {},
-    providers: {
-      ...resolveApiConfig().providers,
-      ...options.config?.providers ?? {},
-      agents: {
-        ...resolveApiConfig().providers.agents,
-        ...options.config?.providers?.agents ?? {}
-      }
-    }
-  };
-  const app = createApiApp({
-    ...options,
-    config
-  });
-  const server = createServer((req, res) => {
-    void honoNodeHandler(app, req, res);
-  });
-  await new Promise((resolvePromise) => {
-    server.listen(config.port, config.host, () => resolvePromise());
-  });
-  const address = server.address();
-  const resolvedUrl = address ? `${config.baseUrl.startsWith("http") ? config.baseUrl : `http://${address.address}:${address.port}`}` : config.baseUrl;
-  return {
-    app,
-    config,
-    server,
-    url: resolvedUrl,
-    async close() {
-      await new Promise((resolvePromise, rejectPromise) => {
-        server.close((error) => error ? rejectPromise(error) : resolvePromise());
-      });
-    }
-  };
-}
-const createRailwayApiServer = createNodeServer;
-export {
-  createNodeServer,
-  createRailwayApiServer
-};

package/dist/api/index.d.ts

@@ -1,13 +0,0 @@
-export { resolveApiD1Database } from './auth/d1-database.js';
-export { D1AuthProvider } from './auth/d1-provider.js';
-export { MemoryDeviceCodeAuthProvider } from './auth/memory-provider.js';
-export { createSignedUserAssertion } from './auth/trusted-assertion.js';
-export { principalHasPlatformPermission } from './auth/rbac.js';
-export type { PermissionPrincipal } from './auth/rbac.js';
-export { resolveApiRuntimeProviders } from './capacity/providers/providers.js';
-export { resolveApiConfig, resolveApiDatabaseUrl, resolveLocalApiDatabaseUrl } from './configuration/config.js';
-export { createNodeServer, createRailwayApiServer } from './hosting/railway.js';
-export { createApiApp, createApiRouter } from './support/app.js';
-export { bearerTokenFromRequest, jsonError, requireActorType, requireAuthentication, requirePermission, requireScope } from './support/http.js';
-export { loadTemplateCatalog } from './support/templates.js';
-export type * from './types.js';

package/dist/api/index.js

@@ -1,33 +0,0 @@
-import { resolveApiD1Database } from "./auth/d1-database.js";
-import { D1AuthProvider } from "./auth/d1-provider.js";
-import { MemoryDeviceCodeAuthProvider } from "./auth/memory-provider.js";
-import { createSignedUserAssertion } from "./auth/trusted-assertion.js";
-import { principalHasPlatformPermission } from "./auth/rbac.js";
-import { resolveApiRuntimeProviders } from "./capacity/providers/providers.js";
-import { resolveApiConfig, resolveApiDatabaseUrl, resolveLocalApiDatabaseUrl } from "./configuration/config.js";
-import { createNodeServer, createRailwayApiServer } from "./hosting/railway.js";
-import { createApiApp, createApiRouter } from "./support/app.js";
-import { bearerTokenFromRequest, jsonError, requireActorType, requireAuthentication, requirePermission, requireScope } from "./support/http.js";
-import { loadTemplateCatalog } from "./support/templates.js";
-export {
-  D1AuthProvider,
-  MemoryDeviceCodeAuthProvider,
-  bearerTokenFromRequest,
-  createApiApp,
-  createApiRouter,
-  createNodeServer,
-  createRailwayApiServer,
-  createSignedUserAssertion,
-  jsonError,
-  loadTemplateCatalog,
-  principalHasPlatformPermission,
-  requireActorType,
-  requireAuthentication,
-  requirePermission,
-  requireScope,
-  resolveApiConfig,
-  resolveApiD1Database,
-  resolveApiDatabaseUrl,
-  resolveApiRuntimeProviders,
-  resolveLocalApiDatabaseUrl
-};

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

@@ -1,11 +0,0 @@
-import type { Hono } from 'hono';
-import type { AgentSdk } from '../../entrypoints/models/sdk.js';
-import type { ApiConfig } from '../types.js';
-import { executeHttpWorkflowOperation } from './operations.js';
-export declare function registerOperationRoutes(app: Hono<any>, options: {
-    config: ApiConfig;
-    scope: string;
-    prefix?: string;
-    sdk?: AgentSdk;
-    executeOperation?: typeof executeHttpWorkflowOperation;
-}): void;

package/dist/api/operations/operations-routes.js

@@ -1,39 +0,0 @@
-import { findOperation } from "../../operations/operations-registry.js";
-import { jsonError, requireScope } from "../support/http.js";
-import { executeHttpWorkflowOperation, isHttpWorkflowOperationAllowed } from "./operations.js";
-function registerOperationRoutes(app, options) {
-  const executeOperation = options.executeOperation ?? executeHttpWorkflowOperation;
-  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");
-    const resolvedOperation = findOperation(requestedOperation);
-    if (!resolvedOperation) {
-      return jsonError(c, 400, `Unknown Treeseed operation "${requestedOperation}".`, {
-        operation: requestedOperation
-      });
-    }
-    if (!isHttpWorkflowOperationAllowed(resolvedOperation.name)) {
-      return jsonError(c, 400, `Workflow operation "${resolvedOperation.name}" is not supported over HTTP.`, {
-        operation: resolvedOperation.name
-      });
-    }
-    const body = await c.req.json().catch(() => ({}));
-    try {
-      const result = await executeOperation(resolvedOperation.name, body);
-      return c.json(result, { status: result.ok ? 200 : 400 });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      const status = /Unknown Treeseed operation|not supported over HTTP|confirmation required/i.test(message) ? 400 : 500;
-      return jsonError(c, status, message, { operation: resolvedOperation.name });
-    }
-  });
-}
-export {
-  registerOperationRoutes
-};

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

@@ -1,3 +0,0 @@
-import type { ApiWorkflowOperationResponse, WorkflowHttpOperationRequest } from '../types.js';
-export declare function isHttpWorkflowOperationAllowed(operation: string): boolean;
-export declare function executeHttpWorkflowOperation(operation: string, request: WorkflowHttpOperationRequest): Promise<ApiWorkflowOperationResponse>;

package/dist/api/operations/operations.js

@@ -1,26 +0,0 @@
-import { OperationsSdk } from "../../operations/operations.js";
-const HTTP_BLOCKED_WORKFLOW_OPERATIONS = /* @__PURE__ */ new Set(["dev", "dev:watch"]);
-function isHttpWorkflowOperationAllowed(operation) {
-  return !HTTP_BLOCKED_WORKFLOW_OPERATIONS.has(operation);
-}
-async function executeHttpWorkflowOperation(operation, request) {
-  if (!isHttpWorkflowOperationAllowed(operation)) {
-    throw new Error(`Workflow operation "${operation}" is not supported over HTTP.`);
-  }
-  const operations = new OperationsSdk();
-  return operations.execute({
-    operationName: operation,
-    input: request.input ?? {}
-  }, {
-    cwd: request.cwd ?? process.cwd(),
-    env: {
-      ...process.env,
-      ...request.env ?? {}
-    },
-    transport: "api"
-  });
-}
-export {
-  executeHttpWorkflowOperation,
-  isHttpWorkflowOperationAllowed
-};

package/dist/api/support/app.d.ts

@@ -1,8 +0,0 @@
-import { Hono } from 'hono';
-import type { ApiServerOptions, AppVariables } from '../types.js';
-export declare function createApiRouter(options?: ApiServerOptions): Hono<{
-    Variables: AppVariables;
-}, import("hono/types").BlankSchema, "/">;
-export declare function createApiApp(options?: ApiServerOptions): Hono<{
-    Variables: AppVariables;
-}, import("hono/types").BlankSchema, "/">;