@treeseed/agent 0.8.5

package/dist/api/railway.d.ts

@@ -0,0 +1,51 @@
+import { type Server } from 'node:http';
+import type { Hono } from 'hono';
+import type { ApiServerOptions } from './types.ts';
+export declare function createTreeseedNodeServer(options?: ApiServerOptions): Promise<{
+    app: Hono<{
+        Variables: import("./types.ts").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;
+        issuer: string;
+        repoRoot: string;
+        projectId: string;
+        authSecret: string;
+        projectApiKey?: string;
+        projectApiLabel: string;
+        projectApiPermissions: string[];
+        cloudflareAccountId?: string;
+        cloudflareApiToken?: 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 createRailwayTreeseedApiServer: typeof createTreeseedNodeServer;

package/dist/api/railway.js

@@ -0,0 +1,71 @@
+import { createServer } from "node:http";
+import { Readable } from "node:stream";
+import { createTreeseedApiApp } from "./app.js";
+import { resolveApiConfig } from "./config.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 createTreeseedNodeServer(options = {}) {
+  const config = {
+    ...resolveApiConfig(),
+    ...options.config ?? {},
+    providers: {
+      ...resolveApiConfig().providers,
+      ...options.config?.providers ?? {},
+      agents: {
+        ...resolveApiConfig().providers.agents,
+        ...options.config?.providers?.agents ?? {}
+      }
+    }
+  };
+  const app = createTreeseedApiApp({
+    ...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 createRailwayTreeseedApiServer = createTreeseedNodeServer;
+export {
+  createRailwayTreeseedApiServer,
+  createTreeseedNodeServer
+};

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

@@ -0,0 +1,5 @@
+import type { AgentSdk, RemoteSdkOperationRequest } from '@treeseed/sdk';
+import { executeSdkOperation, findSdkOperation, listSdkOperationNames } from '@treeseed/sdk';
+import type { ApiConfig } from './types.ts';
+export { executeSdkOperation, findSdkOperation, listSdkOperationNames, };
+export declare function resolveSdkInstance(sharedSdk: AgentSdk | undefined, config: ApiConfig, request: RemoteSdkOperationRequest): AgentSdk;

package/dist/api/sdk-dispatch.js

@@ -0,0 +1,13 @@
+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 });
+}
+export {
+  executeSdkOperation,
+  findSdkOperation,
+  listSdkOperationNames,
+  resolveSdkInstance
+};

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

@@ -0,0 +1,11 @@
+import type { Hono } from 'hono';
+import type { AgentSdk } from '@treeseed/sdk';
+import type { ApiConfig } from './types.ts';
+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

@@ -0,0 +1,29 @@
+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(withPrefix(options.prefix ?? "", "/sdk/:operation"), async (c) => {
+    const unauthorized = requireScope(c, options.scope);
+    if (unauthorized) return unauthorized;
+    const operation = c.req.param("operation");
+    const body = await c.req.json().catch(() => ({}));
+    try {
+      const result = await executeSdkOperation(
+        resolveSdkInstance(options.sharedSdk, options.config, body),
+        operation,
+        body.input ?? {}
+      );
+      return c.json(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const status = /Unknown SDK operation/.test(message) ? 400 : 500;
+      return jsonError(c, status, message, { operation });
+    }
+  });
+}
+export {
+  registerSdkRoutes
+};

package/dist/api/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/api/server.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { createRailwayTreeseedApiServer } from "./railway.js";
+const currentFile = fileURLToPath(import.meta.url);
+const entryFile = process.argv[1] ?? "";
+if (entryFile === currentFile) {
+  const instance = await createRailwayTreeseedApiServer();
+  process.stdout.write(`Treeseed API listening on ${instance.url}
+`);
+}

package/dist/api/templates.d.ts

@@ -0,0 +1,3 @@
+import type { SdkTemplateCatalogResponse } from '@treeseed/sdk/types';
+import type { ApiConfig } from './types.ts';
+export declare function loadTemplateCatalog(config: ApiConfig): SdkTemplateCatalogResponse;

package/dist/api/templates.js

@@ -0,0 +1,31 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import { parseTemplateCatalogResponse } from "@treeseed/sdk/template-catalog";
+const require2 = createRequire(import.meta.url);
+function resolveSdkPackageRoot() {
+  const exportedEntrypoint = require2.resolve("@treeseed/sdk");
+  const distRoot = dirname(exportedEntrypoint);
+  const packageRoot = resolve(distRoot, "..");
+  return packageRoot;
+}
+function resolveDefaultCatalogPath() {
+  const sdkRoot = resolveSdkPackageRoot();
+  const candidates = [
+    resolve(sdkRoot, "dist", "treeseed", "template-catalog", "catalog.fixture.json"),
+    resolve(sdkRoot, "src", "treeseed", "template-catalog", "catalog.fixture.json")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error("Unable to resolve the bundled Treeseed template catalog fixture.");
+}
+function loadTemplateCatalog(config) {
+  const catalogPath = config.templateCatalogPath ?? resolveDefaultCatalogPath();
+  return parseTemplateCatalogResponse(JSON.parse(readFileSync(catalogPath, "utf8")));
+}
+export {
+  loadTemplateCatalog
+};

package/dist/api/types.d.ts

@@ -0,0 +1,237 @@
+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;
+export interface ApiAuthProvider {
+    readonly id: string;
+    startDeviceFlow(request: DeviceCodeStartRequest): Promise<DeviceCodeStartResponse>;
+    pollDeviceFlow(request: DeviceCodePollRequest): Promise<DeviceCodePollResponse>;
+    refreshAccessToken(request: TokenRefreshRequest): Promise<TokenRefreshResponse>;
+    approveDeviceFlow(request: DeviceCodeApproveRequest): Promise<{
+        ok: true;
+    }>;
+    authenticateBearerToken(token: string): Promise<{
+        principal: ApiPrincipal;
+        credential: ApiCredential;
+    } | null>;
+    authenticateServiceCredential(serviceId: string, secret: string): Promise<{
+        principal: ApiPrincipal;
+        credential: ApiCredential;
+    } | null>;
+    createPersonalAccessToken(userId: string, input: {
+        name: string;
+        scopes?: string[];
+        expiresAt?: string | null;
+    }): Promise<{
+        id: string;
+        token: string;
+        prefix: string;
+        name: string;
+        expiresAt: string | null;
+    }>;
+    listPersonalAccessTokens(userId: string): Promise<Array<{
+        id: string;
+        name: string;
+        token_prefix: string;
+        expires_at: string | null;
+        last_used_at: string | null;
+        revoked_at: string | null;
+        created_at: string;
+    }>>;
+    revokePersonalAccessToken(userId: string, tokenId: string): Promise<void>;
+    syncUserIdentity(identity: UserIdentityProfileInput): Promise<{
+        principal: ApiPrincipal;
+        userId: string;
+        identityId: string | null;
+    }>;
+    createUser?(input: {
+        email?: string | null;
+        username?: string | null;
+        displayName?: string | null;
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        principal: ApiPrincipal;
+        userId: string;
+    }>;
+    setUserRoles?(userId: string, roles: string[]): Promise<{
+        principal: ApiPrincipal;
+        userId: string;
+    }>;
+    createServiceToken(input: {
+        serviceId: string;
+        name: string;
+        roles?: string[];
+        permissions?: string[];
+    }): Promise<{
+        id: string;
+        serviceId: string;
+        secret: string;
+    }>;
+    rotateServiceToken(serviceId: string): Promise<{
+        id: string;
+        serviceId: string;
+        secret: string;
+    }>;
+    createTrustedUserAssertion(claims: TrustedUserAssertionClaims): string;
+    verifyTrustedUserAssertion(assertion: string): TrustedUserAssertionClaims | null;
+    exchangeTrustedUserAssertion(claims: TrustedUserAssertionClaims): Promise<{
+        ok: true;
+        accessToken: string;
+        tokenType: 'Bearer';
+        expiresAt: string;
+        expiresInSeconds: number;
+        principal: ApiPrincipal;
+    }>;
+}
+export type ApiRuntimeProviderSelections = {
+    auth: string;
+    agents: {
+        execution: string;
+        queue: string;
+        notification: string;
+        repository: string;
+        verification: string;
+    };
+};
+export interface ApiConfig {
+    name: string;
+    host: string;
+    port: number;
+    baseUrl: string;
+    issuer: string;
+    repoRoot: string;
+    projectId: string;
+    authSecret: string;
+    projectApiKey?: string;
+    projectApiLabel: string;
+    projectApiPermissions: string[];
+    cloudflareAccountId?: string;
+    cloudflareApiToken?: 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;
+    providers: ApiRuntimeProviderSelections;
+}
+export interface AppVariables {
+    requestId: string;
+    config: ApiConfig;
+    principal: ApiPrincipal | null;
+    actingUser: ApiPrincipal | null;
+    credential: ApiCredential | null;
+    actorType: 'anonymous' | 'user' | 'service' | 'project';
+    permissionGrants: string[];
+}
+export interface ApiCredential {
+    type: 'access_token' | 'personal_access_token' | 'service_secret' | 'service_token' | 'project_api_key' | 'team_api_key';
+    id: string;
+    label?: string;
+}
+export interface TrustedUserAssertionClaims {
+    userId: string;
+    sessionId: string;
+    identityId?: string | null;
+    teamId?: string | null;
+    projectId?: string | null;
+    membershipId?: string | null;
+    teamRoles?: string[];
+    teamCapabilities?: string[];
+    authTime: string;
+    expiresAt: string;
+    nonce: string;
+}
+export interface UserIdentityProfileInput {
+    provider: string;
+    providerSubject: string;
+    email?: string | null;
+    emailVerified?: boolean;
+    username?: string | null;
+    displayName?: string | null;
+    profile?: Record<string, unknown>;
+}
+export type ApiProviderFactory<T> = (options: {
+    config: ApiConfig;
+}) => T;
+export interface ApiRuntimeProviders {
+    auth?: Record<string, ApiProviderFactory<ApiAuthProvider>>;
+    agentExecution?: Record<string, unknown>;
+    agentQueue?: Record<string, unknown>;
+    agentNotification?: Record<string, unknown>;
+    agentRepository?: Record<string, unknown>;
+    agentVerification?: Record<string, unknown>;
+}
+export interface ResolvedApiRuntimeProviders {
+    auth: ApiAuthProvider;
+    registries: {
+        auth: Map<string, ApiProviderFactory<ApiAuthProvider>>;
+        agentExecution: Map<string, unknown>;
+        agentQueue: Map<string, unknown>;
+        agentNotification: Map<string, unknown>;
+        agentRepository: Map<string, unknown>;
+        agentVerification: Map<string, unknown>;
+    };
+    selections: ApiRuntimeProviderSelections;
+}
+export interface ApiResolvedSettings {
+    config: ApiConfig;
+    surfaces: {
+        auth: boolean;
+        templates: boolean;
+        sdk: boolean;
+        agent: boolean;
+        operations: boolean;
+        project: boolean;
+    };
+    scopes: {
+        authMe: ApiScope;
+        sdk: ApiScope;
+        agent: ApiScope;
+        operations: ApiScope;
+    };
+}
+export interface ApiAppRuntime {
+    resolved: ApiResolvedSettings;
+    runtimeProviders: ResolvedApiRuntimeProviders;
+    sharedSdk: AgentSdk;
+    internalPrefix: string;
+}
+export type TreeseedApiContext = ApiAppRuntime;
+export interface TreeseedApiExtension {
+    name: string;
+    mount(app: Hono<any>, context: TreeseedApiContext): void | Promise<void>;
+}
+export interface ApiServerOptions {
+    config?: Partial<ApiConfig>;
+    runtimeProviders?: ApiRuntimeProviders;
+    sdk?: AgentSdk;
+    workflowExecutor?: (operation: string, request: WorkflowHttpOperationRequest) => Promise<ApiWorkflowOperationResponse>;
+    surfaces?: Partial<{
+        auth: boolean;
+        templates: boolean;
+        sdk: boolean;
+        agent: boolean;
+        operations: boolean;
+        project: boolean;
+    }>;
+    scopes?: Partial<{
+        authMe: ApiScope;
+        sdk: ApiScope;
+        agent: ApiScope;
+        operations: ApiScope;
+    }>;
+    internalPrefix?: string;
+    extensions?: TreeseedApiExtension[];
+    extendApp?: (app: Hono<any>, runtime: ApiAppRuntime) => void;
+    log?: (message: string, details?: Record<string, unknown>) => void;
+}