@studio-foundation/api 0.3.0-beta.1 → 0.3.0-beta.5

package/src/plans.ts

@@ -1,43 +0,0 @@
-// api/src/plans.ts
-// Plan configuration types and default plans
-
-export interface PlanLimits {
-  runs_per_day: number;          // -1 = unlimited
-  max_concurrent: number;
-  max_tokens_per_run: number;    // -1 = unlimited
-  rate_limit_per_minute: number;
-}
-
-export type PlansConfig = Record<string, PlanLimits>;
-
-export const DEFAULT_PLANS: PlansConfig = {
-  free: {
-    runs_per_day: 5,
-    max_concurrent: 1,
-    max_tokens_per_run: 50_000,
-    rate_limit_per_minute: 10,
-  },
-  pro: {
-    runs_per_day: 100,
-    max_concurrent: 5,
-    max_tokens_per_run: 500_000,
-    rate_limit_per_minute: 60,
-  },
-  unlimited: {
-    runs_per_day: -1,
-    max_concurrent: 20,
-    max_tokens_per_run: -1,
-    rate_limit_per_minute: 300,
-  },
-};
-
-/** Merge user-supplied partial plans with defaults. Unknown plans fall back to 'free'. */
-export function resolvePlans(configPlans?: Record<string, PlanLimits>): PlansConfig {
-  if (!configPlans) return DEFAULT_PLANS;
-  return { ...DEFAULT_PLANS, ...configPlans };
-}
-
-/** Get plan limits for a user, defaulting to 'free' if plan is unknown. */
-export function getPlanLimits(plans: PlansConfig, planName: string): PlanLimits {
-  return plans[planName] ?? plans.free ?? DEFAULT_PLANS.free;
-}

package/src/routes/agents.ts

@@ -1,131 +0,0 @@
-import { readdir, readFile, writeFile, unlink, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import * as yaml from 'js-yaml';
-import type { FastifyInstance } from 'fastify';
-import type { ServerDeps } from '../server.js';
-
-export async function agentsRoutes(
-  fastify: FastifyInstance,
-  options: { deps: ServerDeps }
-): Promise<void> {
-  const agentsDir = join(options.deps.configsDir, 'agents');
-
-  const errorSchema = { type: 'object', properties: { error: { type: 'string' } } };
-
-  // GET /api/agents
-  fastify.get('/agents', {
-    schema: {
-      tags: ['agents'],
-      summary: 'List all agent names',
-      response: {
-        200: {
-          type: 'object',
-          properties: {
-            agents: { type: 'array', items: { type: 'string' } },
-          },
-        },
-      },
-    },
-  }, async (_request, reply) => {
-    let entries: string[];
-    try {
-      entries = await readdir(agentsDir);
-    } catch {
-      return reply.send({ agents: [] });
-    }
-    const agents = entries
-      .filter(f => f.endsWith('.agent.yaml'))
-      .map(f => f.slice(0, -'.agent.yaml'.length));
-    return reply.send({ agents });
-  });
-
-  // GET /api/agents/:name
-  fastify.get<{ Params: { name: string } }>('/agents/:name', {
-    schema: {
-      tags: ['agents'],
-      summary: 'Get an agent by name',
-      params: {
-        type: 'object',
-        properties: { name: { type: 'string' } },
-        required: ['name'],
-      },
-      response: {
-        200: { type: 'object', additionalProperties: true },
-        404: errorSchema,
-      },
-    },
-  }, async (request, reply) => {
-    const filePath = join(agentsDir, `${request.params.name}.agent.yaml`);
-    let content: string;
-    try {
-      content = await readFile(filePath, 'utf-8');
-    } catch {
-      return reply.status(404).send({ error: 'Agent not found' });
-    }
-    return reply.send(yaml.load(content));
-  });
-
-  // PUT /api/agents/:name
-  fastify.put<{
-    Params: { name: string };
-    Body: Record<string, unknown>;
-  }>('/agents/:name', {
-    schema: {
-      tags: ['agents'],
-      summary: 'Create or update an agent',
-      params: {
-        type: 'object',
-        properties: { name: { type: 'string' } },
-        required: ['name'],
-      },
-      body: { type: 'object' },
-      response: {
-        200: {
-          type: 'object',
-          properties: {
-            name: { type: 'string' },
-            content: { type: 'object', additionalProperties: true },
-          },
-        },
-        400: errorSchema,
-      },
-    },
-  }, async (request, reply) => {
-    const body = request.body;
-
-    if (!body['name'] || typeof body['name'] !== 'string') {
-      return reply.status(400).send({ error: "Agent must have a 'name' field (string)" });
-    }
-
-    await mkdir(agentsDir, { recursive: true });
-    const filePath = join(agentsDir, `${request.params.name}.agent.yaml`);
-    await writeFile(filePath, yaml.dump(body), 'utf-8');
-
-    return reply.send({ name: request.params.name, content: body });
-  });
-
-  // DELETE /api/agents/:name
-  fastify.delete<{ Params: { name: string } }>('/agents/:name', {
-    schema: {
-      tags: ['agents'],
-      summary: 'Delete an agent',
-      params: {
-        type: 'object',
-        properties: { name: { type: 'string' } },
-        required: ['name'],
-      },
-      response: {
-        204: { type: 'null', description: 'No content' },
-        404: errorSchema,
-      },
-    },
-  }, async (request, reply) => {
-    const filePath = join(agentsDir, `${request.params.name}.agent.yaml`);
-    try {
-      await unlink(filePath);
-    } catch {
-      return reply.status(404).send({ error: 'Agent not found' });
-    }
-    return reply.status(204).send();
-  });
-}

package/src/routes/config.ts

@@ -1,154 +0,0 @@
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import * as yaml from 'js-yaml';
-import type { FastifyInstance } from 'fastify';
-import type { ServerDeps } from '../server.js';
-
-const KNOWN_PROVIDERS = new Set(['anthropic', 'openai', 'ollama']);
-
-interface RawConfig {
-  providers?: Record<string, { apiKey?: string }>;
-  defaults?: Record<string, unknown>;
-}
-
-async function readConfig(configsDir: string): Promise<RawConfig> {
-  try {
-    const content = await readFile(join(configsDir, 'config.yaml'), 'utf-8');
-    return (yaml.load(content) as RawConfig) ?? {};
-  } catch {
-    return {};
-  }
-}
-
-async function writeConfig(configsDir: string, config: RawConfig): Promise<void> {
-  await mkdir(configsDir, { recursive: true });
-  await writeFile(join(configsDir, 'config.yaml'), yaml.dump(config), 'utf-8');
-}
-
-function maskConfig(config: RawConfig): RawConfig {
-  if (!config.providers) return config;
-  const maskedProviders: Record<string, { apiKey: string }> = {};
-  for (const [name, provider] of Object.entries(config.providers)) {
-    maskedProviders[name] = { apiKey: provider.apiKey ? '***' : '' };
-  }
-  return { ...config, providers: maskedProviders };
-}
-
-export async function configRoutes(
-  fastify: FastifyInstance,
-  options: { deps: ServerDeps }
-): Promise<void> {
-  const { configsDir } = options.deps;
-
-  const configResponseSchema = {
-    type: 'object',
-    properties: {
-      providers: {
-        type: 'object',
-        additionalProperties: {
-          type: 'object',
-          properties: { apiKey: { type: 'string' } },
-        },
-      },
-      defaults: {
-        type: 'object',
-        properties: {
-          provider: { type: 'string' },
-          model: { type: 'string' },
-        },
-      },
-    },
-  };
-
-  // GET /api/config
-  fastify.get('/config', {
-    schema: {
-      tags: ['config'],
-      summary: 'Get current config',
-      response: {
-        200: configResponseSchema,
-      },
-    },
-  }, async (_request, reply) => {
-    const config = await readConfig(configsDir);
-    return reply.send({
-      providers: {},
-      ...maskConfig(config),
-    });
-  });
-
-  // PATCH /api/config
-  fastify.patch<{ Body: Partial<RawConfig> }>('/config', {
-    schema: {
-      tags: ['config'],
-      summary: 'Patch config (merge defaults and providers)',
-      body: { type: 'object' },
-      response: {
-        200: configResponseSchema,
-      },
-    },
-  }, async (request, reply) => {
-    const config = await readConfig(configsDir);
-    const patch = request.body;
-
-    if (patch.defaults) {
-      config.defaults = { ...config.defaults, ...patch.defaults };
-    }
-    if (patch.providers) {
-      config.providers = { ...config.providers, ...patch.providers };
-    }
-
-    await writeConfig(configsDir, config);
-    return reply.send({
-      providers: {},
-      ...maskConfig(config),
-    });
-  });
-
-  // POST /api/config/providers
-  fastify.post<{ Body: { provider: string; apiKeyEnvVar: string } }>(
-    '/config/providers',
-    {
-      schema: {
-        tags: ['config'],
-        summary: 'Add or update a provider',
-        body: {
-          type: 'object',
-          required: ['provider', 'apiKeyEnvVar'],
-          properties: {
-            provider: { type: 'string' },
-            apiKeyEnvVar: { type: 'string' },
-          },
-        },
-        response: {
-          200: configResponseSchema,
-          400: {
-            type: 'object',
-            properties: { error: { type: 'string' } },
-          },
-        },
-      },
-    },
-    async (request, reply) => {
-      const { provider, apiKeyEnvVar } = request.body;
-
-      if (!KNOWN_PROVIDERS.has(provider)) {
-        return reply.status(400).send({
-          error: `Unknown provider: '${provider}'. Supported: ${[...KNOWN_PROVIDERS].join(', ')}`,
-        });
-      }
-
-      const config = await readConfig(configsDir);
-      config.providers = {
-        ...config.providers,
-        [provider]: { apiKey: `\${${apiKeyEnvVar}}` },
-      };
-
-      await writeConfig(configsDir, config);
-      return reply.send({
-        providers: {},
-        ...maskConfig(config),
-      });
-    }
-  );
-}

package/src/routes/contracts.ts

@@ -1,205 +0,0 @@
-import { readdir, readFile, writeFile, unlink, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import * as yaml from 'js-yaml';
-import type { FastifyInstance } from 'fastify';
-import type { ServerDeps } from '../server.js';
-import { loadContract, validateOutput } from '@studio-foundation/engine';
-import type { ToolCall } from '@studio-foundation/contracts';
-
-export async function contractsRoutes(
-  fastify: FastifyInstance,
-  options: { deps: ServerDeps }
-): Promise<void> {
-  const contractsDir = join(options.deps.configsDir, 'contracts');
-  const errorSchema = { type: 'object', properties: { error: { type: 'string' } } };
-
-  // GET /api/contracts
-  fastify.get('/contracts', {
-    schema: {
-      tags: ['contracts'],
-      summary: 'List all contract names',
-      response: {
-        200: {
-          type: 'object',
-          properties: {
-            contracts: { type: 'array', items: { type: 'string' } },
-          },
-        },
-      },
-    },
-  }, async (_request, reply) => {
-    let entries: string[];
-    try {
-      entries = await readdir(contractsDir);
-    } catch {
-      return reply.send({ contracts: [] });
-    }
-    const contracts = entries
-      .filter(f => f.endsWith('.contract.yaml'))
-      .map(f => f.slice(0, -'.contract.yaml'.length));
-    return reply.send({ contracts });
-  });
-
-  // GET /api/contracts/:name
-  fastify.get<{ Params: { name: string } }>('/contracts/:name', {
-    schema: {
-      tags: ['contracts'],
-      summary: 'Get a contract by name',
-      params: {
-        type: 'object',
-        properties: { name: { type: 'string' } },
-        required: ['name'],
-      },
-      response: {
-        200: { type: 'object', additionalProperties: true },
-        404: errorSchema,
-      },
-    },
-  }, async (request, reply) => {
-    const filePath = join(contractsDir, `${request.params.name}.contract.yaml`);
-    let content: string;
-    try {
-      content = await readFile(filePath, 'utf-8');
-    } catch {
-      return reply.status(404).send({ error: 'Contract not found' });
-    }
-    return reply.send(yaml.load(content));
-  });
-
-  // PUT /api/contracts/:name
-  fastify.put<{
-    Params: { name: string };
-    Body: Record<string, unknown>;
-  }>('/contracts/:name', {
-    schema: {
-      tags: ['contracts'],
-      summary: 'Create or update a contract',
-      params: {
-        type: 'object',
-        properties: { name: { type: 'string' } },
-        required: ['name'],
-      },
-      body: { type: 'object' },
-      response: {
-        200: {
-          type: 'object',
-          properties: {
-            name: { type: 'string' },
-            content: { type: 'object', additionalProperties: true },
-          },
-        },
-        400: errorSchema,
-      },
-    },
-  }, async (request, reply) => {
-    const body = request.body;
-
-    if (!body['name'] || typeof body['name'] !== 'string') {
-      return reply.status(400).send({ error: "Contract must have a 'name' field (string)" });
-    }
-    if (body['version'] === undefined) {
-      return reply.status(400).send({ error: "Contract must have a 'version' field" });
-    }
-
-    await mkdir(contractsDir, { recursive: true });
-    const filePath = join(contractsDir, `${request.params.name}.contract.yaml`);
-    await writeFile(filePath, yaml.dump(body), 'utf-8');
-
-    return reply.send({ name: request.params.name, content: body });
-  });
-
-  // DELETE /api/contracts/:name
-  fastify.delete<{ Params: { name: string } }>('/contracts/:name', {
-    schema: {
-      tags: ['contracts'],
-      summary: 'Delete a contract',
-      params: {
-        type: 'object',
-        properties: { name: { type: 'string' } },
-        required: ['name'],
-      },
-      response: {
-        204: { type: 'null', description: 'No content' },
-        404: errorSchema,
-      },
-    },
-  }, async (request, reply) => {
-    const filePath = join(contractsDir, `${request.params.name}.contract.yaml`);
-    try {
-      await unlink(filePath);
-    } catch {
-      return reply.status(404).send({ error: 'Contract not found' });
-    }
-    return reply.status(204).send();
-  });
-
-  // POST /api/contracts/:name/validate
-  fastify.post<{
-    Params: { name: string };
-    Body: { output: unknown; tool_calls?: ToolCall[] };
-  }>('/contracts/:name/validate', {
-    schema: {
-      tags: ['contracts'],
-      summary: 'Validate an output against a contract without running a pipeline',
-      params: {
-        type: 'object',
-        properties: { name: { type: 'string' } },
-        required: ['name'],
-      },
-      body: {
-        type: 'object',
-        required: ['output'],
-        properties: {
-          output: { type: 'object', additionalProperties: true },
-          tool_calls: {
-            type: 'array',
-            items: {
-              type: 'object',
-              properties: {
-                id: { type: 'string' },
-                name: { type: 'string' },
-                arguments: { type: 'object', additionalProperties: true },
-                result: {},
-                error: { type: 'string' },
-              },
-              required: ['id', 'name'],
-            },
-          },
-        },
-      },
-      response: {
-        200: {
-          type: 'object',
-          required: ['valid', 'errors', 'warnings', 'post_validation'],
-          properties: {
-            valid: { type: 'boolean' },
-            errors: { type: 'array', items: { type: 'string' } },
-            warnings: { type: 'array', items: { type: 'string' } },
-            post_validation: {
-              type: 'object',
-              required: ['accepted'],
-              properties: {
-                accepted: { type: 'boolean' },
-                rejection_reason: { type: 'string' },
-                rejection_details: { type: 'array', items: { type: 'string' } },
-              },
-            },
-          },
-        },
-        400: errorSchema,
-        404: errorSchema,
-      },
-    },
-  }, async (request, reply) => {
-    let contract;
-    try {
-      contract = await loadContract(request.params.name, contractsDir);
-    } catch {
-      return reply.status(404).send({ error: 'Contract not found' });
-    }
-
-    const { output, tool_calls = [] } = request.body;
-    const result = validateOutput(contract, output, tool_calls);
-    return reply.send(result);
-  });
-}

package/src/routes/pipelines.ts

@@ -1,146 +0,0 @@
-import { readdir, readFile, writeFile, unlink } from 'node:fs/promises';
-import { join } from 'node:path';
-import yaml from 'js-yaml';
-import type { FastifyInstance } from 'fastify';
-import type { ServerDeps } from '../server.js';
-
-function pipelinePath(configsDir: string, name: string): string {
-  return join(configsDir, 'pipelines', `${name}.pipeline.yaml`);
-}
-
-export async function pipelinesRoutes(
-  fastify: FastifyInstance,
-  options: { deps: ServerDeps }
-): Promise<void> {
-  const { configsDir } = options.deps;
-
-  // GET /api/pipelines — list all pipeline names
-  fastify.get('/pipelines', {
-    schema: {
-      tags: ['pipelines'],
-      summary: 'List all pipeline names',
-      response: {
-        200: {
-          type: 'object',
-          properties: {
-            pipelines: { type: 'array', items: { type: 'string' } },
-          },
-        },
-      },
-    },
-  }, async (_request, reply) => {
-    const pipelinesDir = join(configsDir, 'pipelines');
-    let entries: string[];
-    try {
-      entries = await readdir(pipelinesDir);
-    } catch {
-      return reply.send({ pipelines: [] });
-    }
-    const pipelines = entries
-      .filter(f => f.endsWith('.pipeline.yaml'))
-      .map(f => f.replace('.pipeline.yaml', ''));
-    return reply.send({ pipelines });
-  });
-
-  const errorSchema = { type: 'object', properties: { error: { type: 'string' } } };
-
-  // GET /api/pipelines/:name — read a pipeline (YAML parsed to JSON)
-  fastify.get<{ Params: { name: string } }>('/pipelines/:name', {
-    schema: {
-      tags: ['pipelines'],
-      summary: 'Get a pipeline by name',
-      params: {
-        type: 'object',
-        properties: { name: { type: 'string' } },
-        required: ['name'],
-      },
-      response: {
-        200: { type: 'object', additionalProperties: true },
-        404: errorSchema,
-      },
-    },
-  }, async (request, reply) => {
-    const { name } = request.params;
-    let content: string;
-    try {
-      content = await readFile(pipelinePath(configsDir, name), 'utf-8');
-    } catch {
-      return reply.status(404).send({ error: `Pipeline '${name}' not found` });
-    }
-    const parsed = yaml.load(content);
-    return reply.send(parsed);
-  });
-
-  // PUT /api/pipelines/:name — create or update a pipeline (YAML or JSON body)
-  fastify.put<{ Params: { name: string }; Body: unknown }>(
-    '/pipelines/:name',
-    {
-      schema: {
-        tags: ['pipelines'],
-        summary: 'Create or update a pipeline (YAML text or JSON body)',
-        params: {
-          type: 'object',
-          properties: { name: { type: 'string' } },
-          required: ['name'],
-        },
-        body: { oneOf: [{ type: 'object', additionalProperties: true }, { type: 'string' }] },
-        response: {
-          200: {
-            type: 'object',
-            properties: { name: { type: 'string' } },
-          },
-          400: errorSchema,
-        },
-      },
-    },
-    async (request, reply) => {
-      const { name } = request.params;
-      const contentType = request.headers['content-type'] ?? '';
-
-      let yamlContent: string;
-      if (contentType.includes('application/json')) {
-        yamlContent = yaml.dump(request.body);
-      } else {
-        yamlContent = request.body as string;
-      }
-
-      try {
-        yaml.load(yamlContent);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : 'Invalid YAML';
-        return reply.status(400).send({ error: message });
-      }
-
-      await writeFile(pipelinePath(configsDir, name), yamlContent, 'utf-8');
-      return reply.send({ name });
-    }
-  );
-
-  // DELETE /api/pipelines/:name — delete a pipeline
-  fastify.delete<{ Params: { name: string } }>('/pipelines/:name', {
-    schema: {
-      tags: ['pipelines'],
-      summary: 'Delete a pipeline',
-      params: {
-        type: 'object',
-        properties: { name: { type: 'string' } },
-        required: ['name'],
-      },
-      response: {
-        200: {
-          type: 'object',
-          properties: { deleted: { type: 'string' } },
-        },
-        404: errorSchema,
-      },
-    },
-  }, async (request, reply) => {
-    const { name } = request.params;
-    try {
-      await unlink(pipelinePath(configsDir, name));
-    } catch {
-      return reply.status(404).send({ error: `Pipeline '${name}' not found` });
-    }
-    return reply.send({ deleted: name });
-  });
-}