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

package/tests/agents.test.ts

@@ -1,164 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { buildServer } from '../src/server.js';
-import { InMemoryRunStore } from '@studio-foundation/engine';
-import type { IntegrationRuntime } from '../src/integration-runtime.js';
-import type { IntegrationStore } from '../src/integration-store.js';
-
-const TMP = resolve('/tmp', `.studio-agents-test-${Date.now()}`);
-const AGENTS_DIR = resolve(TMP, 'agents');
-
-const nullIntegrationRuntime = { registerRoutes: () => {} } as unknown as IntegrationRuntime;
-const nullIntegrationStore = {} as unknown as IntegrationStore;
-
-function makeServer() {
-  return buildServer({
-    store: new InMemoryRunStore(),
-    launcher: { launch: async () => ({ run_id: 'x' }), cancel: async () => {} },
-    configsDir: TMP,
-    projectName: 'test-project',
-    apiConfig: {},
-    studioVersion: '0.0.0-test',
-    maskedConfig: { providers: [] },
-    integrationRuntime: nullIntegrationRuntime,
-    integrationStore: nullIntegrationStore,
-  });
-}
-
-beforeAll(() => {
-  mkdirSync(AGENTS_DIR, { recursive: true });
-  writeFileSync(
-    resolve(AGENTS_DIR, 'analyst.agent.yaml'),
-    'name: analyst\nprovider: anthropic\nmodel: claude-sonnet-4-20250514\n'
-  );
-  writeFileSync(
-    resolve(AGENTS_DIR, 'coder.agent.yaml'),
-    'name: coder\nprovider: anthropic\nmodel: claude-sonnet-4-20250514\ntemperature: 0.2\n'
-  );
-  writeFileSync(resolve(AGENTS_DIR, 'ignored.yaml'), ''); // must be ignored
-});
-
-afterAll(() => {
-  rmSync(TMP, { recursive: true, force: true });
-});
-
-describe('GET /api/agents', () => {
-  it('returns only *.agent.yaml files as agent names', async () => {
-    const server = makeServer();
-    const res = await server.inject({ method: 'GET', url: '/api/agents' });
-    expect(res.statusCode).toBe(200);
-    const { agents } = res.json() as { agents: string[] };
-    expect(agents).toContain('analyst');
-    expect(agents).toContain('coder');
-    expect(agents).not.toContain('ignored');
-    expect(agents).not.toContain('analyst.agent.yaml');
-  });
-
-  it('returns empty array when agents dir is missing', async () => {
-    const server = buildServer({
-      store: new InMemoryRunStore(),
-      launcher: { launch: async () => ({ run_id: 'x' }), cancel: async () => {} },
-      configsDir: resolve('/tmp', `.studio-no-agents-${Date.now()}`),
-      projectName: 'test-project',
-      apiConfig: {},
-      studioVersion: '0.0.0-test',
-      maskedConfig: { providers: [] },
-      integrationRuntime: nullIntegrationRuntime,
-      integrationStore: nullIntegrationStore,
-    });
-    const res = await server.inject({ method: 'GET', url: '/api/agents' });
-    expect(res.statusCode).toBe(200);
-    expect((res.json() as { agents: string[] }).agents).toEqual([]);
-  });
-});
-
-describe('GET /api/agents/:name', () => {
-  it('returns parsed agent content as JSON', async () => {
-    const server = makeServer();
-    const res = await server.inject({ method: 'GET', url: '/api/agents/analyst' });
-    expect(res.statusCode).toBe(200);
-    const body = res.json() as { name: string; provider: string; model: string };
-    expect(body.name).toBe('analyst');
-    expect(body.provider).toBe('anthropic');
-    expect(body.model).toBe('claude-sonnet-4-20250514');
-  });
-
-  it('returns nested fields from YAML', async () => {
-    const server = makeServer();
-    const res = await server.inject({ method: 'GET', url: '/api/agents/coder' });
-    expect(res.statusCode).toBe(200);
-    const body = res.json() as { temperature: number };
-    expect(body.temperature).toBe(0.2);
-  });
-
-  it('returns 404 for unknown agent', async () => {
-    const server = makeServer();
-    const res = await server.inject({ method: 'GET', url: '/api/agents/nonexistent' });
-    expect(res.statusCode).toBe(404);
-    expect((res.json() as { error: string }).error).toBe('Agent not found');
-  });
-});
-
-describe('PUT /api/agents/:name', () => {
-  it('creates a new agent file', async () => {
-    const server = makeServer();
-    const res = await server.inject({
-      method: 'PUT',
-      url: '/api/agents/new-agent',
-      payload: { name: 'new-agent', provider: 'anthropic', model: 'claude-haiku-4-5-20251001' },
-    });
-    expect(res.statusCode).toBe(200);
-    // Verify it can be read back
-    const getRes = await server.inject({ method: 'GET', url: '/api/agents/new-agent' });
-    expect(getRes.statusCode).toBe(200);
-    expect((getRes.json() as { model: string }).model).toBe('claude-haiku-4-5-20251001');
-  });
-
-  it('updates an existing agent', async () => {
-    const server = makeServer();
-    const res = await server.inject({
-      method: 'PUT',
-      url: '/api/agents/analyst',
-      payload: { name: 'analyst', provider: 'anthropic', model: 'claude-opus-4-6' },
-    });
-    expect(res.statusCode).toBe(200);
-    // Verify model updated
-    const getRes = await server.inject({ method: 'GET', url: '/api/agents/analyst' });
-    expect((getRes.json() as { model: string }).model).toBe('claude-opus-4-6');
-  });
-
-  it('returns 400 when name field is missing', async () => {
-    const server = makeServer();
-    const res = await server.inject({
-      method: 'PUT',
-      url: '/api/agents/foo',
-      payload: { provider: 'anthropic' },
-    });
-    expect(res.statusCode).toBe(400);
-  });
-});
-
-describe('DELETE /api/agents/:name', () => {
-  it('deletes an agent and returns 204', async () => {
-    const server = makeServer();
-    // Create it first via PUT
-    await server.inject({
-      method: 'PUT',
-      url: '/api/agents/to-delete',
-      payload: { name: 'to-delete', provider: 'anthropic', model: 'claude-haiku-4-5-20251001' },
-    });
-    const res = await server.inject({ method: 'DELETE', url: '/api/agents/to-delete' });
-    expect(res.statusCode).toBe(204);
-    // Verify it's gone
-    const getRes = await server.inject({ method: 'GET', url: '/api/agents/to-delete' });
-    expect(getRes.statusCode).toBe(404);
-  });
-
-  it('returns 404 for nonexistent agent', async () => {
-    const server = makeServer();
-    const res = await server.inject({ method: 'DELETE', url: '/api/agents/nonexistent' });
-    expect(res.statusCode).toBe(404);
-    expect((res.json() as { error: string }).error).toBe('Agent not found');
-  });
-});

package/tests/cancel.test.ts

@@ -1,120 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { buildServer } from '../src/server.js';
-import { InMemoryRunStore } from '@studio-foundation/engine';
-import type { RunLauncher } from '../src/launcher.js';
-import type { PipelineRun } from '@studio-foundation/contracts';
-import type { IntegrationRuntime } from '../src/integration-runtime.js';
-import type { IntegrationStore } from '../src/integration-store.js';
-
-function makeRun(overrides: Partial<PipelineRun> = {}): PipelineRun {
-  return {
-    id: 'run-abc',
-    pipeline_name: 'test-pipeline',
-    status: 'running',
-    started_at: '2026-01-01T10:00:00Z',
-    stages: [],
-    ...overrides,
-  } as PipelineRun;
-}
-
-const nullIntegrationRuntime = { registerRoutes: () => {} } as unknown as IntegrationRuntime;
-const nullIntegrationStore = {} as unknown as IntegrationStore;
-
-function makeServer(store = new InMemoryRunStore(), launcher?: Partial<RunLauncher>) {
-  return buildServer({
-    store,
-    launcher: {
-      launch: vi.fn().mockResolvedValue({ run_id: 'new-run' }),
-      cancel: vi.fn().mockResolvedValue(undefined),
-      subscribe: vi.fn().mockReturnValue(() => {}),
-      ...launcher,
-    } as RunLauncher,
-    configsDir: '/tmp/.studio',
-    projectName: 'test',
-    apiConfig: {},
-    integrationRuntime: nullIntegrationRuntime,
-    integrationStore: nullIntegrationStore,
-  } as any);
-}
-
-describe('POST /api/runs/:id/cancel', () => {
-  it('returns 200 with run_id when run is running', async () => {
-    const store = new InMemoryRunStore();
-    const cancelFn = vi.fn().mockResolvedValue(undefined);
-    store.savePipelineRun(makeRun({ id: 'run-1', status: 'running' }));
-    const server = makeServer(store, { cancel: cancelFn });
-
-    const res = await server.inject({ method: 'POST', url: '/api/runs/run-1/cancel' });
-
-    expect(res.statusCode).toBe(200);
-    expect(res.json()).toEqual({ run_id: 'run-1' });
-    expect(cancelFn).toHaveBeenCalledWith('run-1');
-  });
-
-  it('returns 404 when run does not exist', async () => {
-    const server = makeServer();
-
-    const res = await server.inject({ method: 'POST', url: '/api/runs/nonexistent/cancel' });
-
-    expect(res.statusCode).toBe(404);
-    expect(res.json().error).toMatch(/not found/i);
-  });
-
-  it('returns 409 when run is already success', async () => {
-    const store = new InMemoryRunStore();
-    store.savePipelineRun(makeRun({ id: 'run-done', status: 'success' }));
-    const server = makeServer(store);
-
-    const res = await server.inject({ method: 'POST', url: '/api/runs/run-done/cancel' });
-
-    expect(res.statusCode).toBe(409);
-    expect(res.json().error).toMatch(/not cancellable/i);
-  });
-
-  it('returns 409 for failed and cancelled statuses', async () => {
-    for (const status of ['failed', 'cancelled'] as const) {
-      const store = new InMemoryRunStore();
-      store.savePipelineRun(makeRun({ id: 'run-x', status }));
-      const server = makeServer(store);
-
-      const res = await server.inject({ method: 'POST', url: '/api/runs/run-x/cancel' });
-
-      expect(res.statusCode).toBe(409);
-    }
-  });
-});
-
-describe('DELETE /api/runs/:id', () => {
-  it('returns 200 with run_id when run is running', async () => {
-    const store = new InMemoryRunStore();
-    const cancelFn = vi.fn().mockResolvedValue(undefined);
-    store.savePipelineRun(makeRun({ id: 'run-del-1', status: 'running' }));
-    const server = makeServer(store, { cancel: cancelFn });
-
-    const res = await server.inject({ method: 'DELETE', url: '/api/runs/run-del-1' });
-
-    expect(res.statusCode).toBe(200);
-    expect(res.json()).toEqual({ run_id: 'run-del-1' });
-    expect(cancelFn).toHaveBeenCalledWith('run-del-1');
-  });
-
-  it('returns 404 when run does not exist', async () => {
-    const server = makeServer();
-
-    const res = await server.inject({ method: 'DELETE', url: '/api/runs/nonexistent' });
-
-    expect(res.statusCode).toBe(404);
-    expect(res.json().error).toMatch(/not found/i);
-  });
-
-  it('returns 409 when run is already terminal', async () => {
-    const store = new InMemoryRunStore();
-    store.savePipelineRun(makeRun({ id: 'run-done', status: 'success' }));
-    const server = makeServer(store);
-
-    const res = await server.inject({ method: 'DELETE', url: '/api/runs/run-done' });
-
-    expect(res.statusCode).toBe(409);
-    expect(res.json().error).toMatch(/not cancellable/i);
-  });
-});

package/tests/config.test.ts

@@ -1,196 +0,0 @@
-import { describe, it, expect, beforeEach, afterAll } from 'vitest';
-import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { buildServer } from '../src/server.js';
-import { InMemoryRunStore } from '@studio-foundation/engine';
-import type { IntegrationRuntime } from '../src/integration-runtime.js';
-import type { IntegrationStore } from '../src/integration-store.js';
-
-const BASE_CONFIG_YAML = `providers:
-  anthropic:
-    apiKey: \${ANTHROPIC_API_KEY}
-  openai:
-    apiKey: \${OPENAI_API_KEY}
-defaults:
-  provider: anthropic
-  model: claude-sonnet-4-20250514
-`;
-
-// Each describe block uses its own dir to avoid cross-test mutation
-const GET_TMP = resolve('/tmp', `.studio-config-get-test-${Date.now()}`);
-const PATCH_TMP = resolve('/tmp', `.studio-config-patch-test-${Date.now()}`);
-const POST_TMP = resolve('/tmp', `.studio-config-post-test-${Date.now()}`);
-
-const nullIntegrationRuntime = { registerRoutes: () => {} } as unknown as IntegrationRuntime;
-const nullIntegrationStore = {} as unknown as IntegrationStore;
-
-function makeServer(configsDir: string) {
-  return buildServer({
-    store: new InMemoryRunStore(),
-    launcher: { launch: async () => ({ run_id: 'x' }), cancel: async () => {} },
-    configsDir,
-    projectName: 'test-project',
-    apiConfig: {},
-    studioVersion: '0.0.0-test',
-    maskedConfig: { providers: [] },
-    integrationRuntime: nullIntegrationRuntime,
-    integrationStore: nullIntegrationStore,
-  });
-}
-
-function writeConfig(dir: string, content = BASE_CONFIG_YAML) {
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(resolve(dir, 'config.yaml'), content);
-}
-
-afterAll(() => {
-  for (const dir of [GET_TMP, PATCH_TMP, POST_TMP]) {
-    if (existsSync(dir)) rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe('GET /api/config', () => {
-  beforeEach(() => writeConfig(GET_TMP));
-
-  it('returns providers with API keys masked as ***', async () => {
-    const server = makeServer(GET_TMP);
-    const res = await server.inject({ method: 'GET', url: '/api/config' });
-    expect(res.statusCode).toBe(200);
-    const body = res.json() as { providers: Record<string, { apiKey: string }> };
-    expect(body.providers['anthropic'].apiKey).toBe('***');
-    expect(body.providers['openai'].apiKey).toBe('***');
-  });
-
-  it('returns defaults from config', async () => {
-    const server = makeServer(GET_TMP);
-    const res = await server.inject({ method: 'GET', url: '/api/config' });
-    const body = res.json() as { defaults: { provider: string; model: string } };
-    expect(body.defaults.provider).toBe('anthropic');
-    expect(body.defaults.model).toBe('claude-sonnet-4-20250514');
-  });
-
-  it('never exposes raw API key values in the response', async () => {
-    const server = makeServer(GET_TMP);
-    const res = await server.inject({ method: 'GET', url: '/api/config' });
-    // The env var reference itself must not appear — only *** is returned
-    expect(res.payload).not.toContain('ANTHROPIC_API_KEY');
-    expect(res.payload).not.toContain('OPENAI_API_KEY');
-  });
-
-  it('returns empty providers when config.yaml does not exist', async () => {
-    const emptyDir = resolve('/tmp', `.studio-no-config-${Date.now()}`);
-    const server = makeServer(emptyDir);
-    const res = await server.inject({ method: 'GET', url: '/api/config' });
-    expect(res.statusCode).toBe(200);
-    const body = res.json() as { providers: Record<string, unknown> };
-    expect(body.providers).toEqual({});
-  });
-});
-
-describe('PATCH /api/config', () => {
-  beforeEach(() => writeConfig(PATCH_TMP));
-
-  it('updates defaults and returns masked config', async () => {
-    const server = makeServer(PATCH_TMP);
-    const res = await server.inject({
-      method: 'PATCH',
-      url: '/api/config',
-      payload: { defaults: { provider: 'openai', model: 'gpt-4o' } },
-    });
-    expect(res.statusCode).toBe(200);
-    const body = res.json() as { defaults: { provider: string; model: string } };
-    expect(body.defaults.provider).toBe('openai');
-    expect(body.defaults.model).toBe('gpt-4o');
-  });
-
-  it('preserves providers when patching only defaults', async () => {
-    const server = makeServer(PATCH_TMP);
-    const res = await server.inject({
-      method: 'PATCH',
-      url: '/api/config',
-      payload: { defaults: { provider: 'openai', model: 'gpt-4o' } },
-    });
-    const body = res.json() as { providers: Record<string, { apiKey: string }> };
-    expect(body.providers['anthropic'].apiKey).toBe('***');
-    expect(body.providers['openai'].apiKey).toBe('***');
-  });
-
-  it('preserves unpatched fields within defaults', async () => {
-    const server = makeServer(PATCH_TMP);
-    const res = await server.inject({
-      method: 'PATCH',
-      url: '/api/config',
-      payload: { defaults: { model: 'claude-opus-4-6' } },
-    });
-    expect(res.statusCode).toBe(200);
-    const body = res.json() as { defaults: { provider: string; model: string } };
-    // model updated
-    expect(body.defaults.model).toBe('claude-opus-4-6');
-    // provider preserved
-    expect(body.defaults.provider).toBe('anthropic');
-  });
-
-  it('persists changes so a subsequent GET reflects them', async () => {
-    const server = makeServer(PATCH_TMP);
-    await server.inject({
-      method: 'PATCH',
-      url: '/api/config',
-      payload: { defaults: { provider: 'openai', model: 'gpt-4o' } },
-    });
-    const getRes = await server.inject({ method: 'GET', url: '/api/config' });
-    const body = getRes.json() as { defaults: { provider: string } };
-    expect(body.defaults.provider).toBe('openai');
-  });
-});
-
-describe('POST /api/config/providers', () => {
-  beforeEach(() => writeConfig(POST_TMP));
-
-  it('adds a provider with apiKey stored as env var reference', async () => {
-    const server = makeServer(POST_TMP);
-    const res = await server.inject({
-      method: 'POST',
-      url: '/api/config/providers',
-      payload: { provider: 'anthropic', apiKeyEnvVar: 'MY_ANTHROPIC_KEY' },
-    });
-    expect(res.statusCode).toBe(200);
-    const body = res.json() as { providers: Record<string, { apiKey: string }> };
-    expect(body.providers['anthropic'].apiKey).toBe('***');
-  });
-
-  it('never stores the env var name in plain text in the response', async () => {
-    const server = makeServer(POST_TMP);
-    const res = await server.inject({
-      method: 'POST',
-      url: '/api/config/providers',
-      payload: { provider: 'anthropic', apiKeyEnvVar: 'MY_ANTHROPIC_KEY' },
-    });
-    expect(res.payload).not.toContain('MY_ANTHROPIC_KEY');
-  });
-
-  it('updates an existing provider', async () => {
-    const server = makeServer(POST_TMP);
-    const res = await server.inject({
-      method: 'POST',
-      url: '/api/config/providers',
-      payload: { provider: 'openai', apiKeyEnvVar: 'OPENAI_NEW_KEY' },
-    });
-    expect(res.statusCode).toBe(200);
-    // GET should show openai still masked
-    const getRes = await server.inject({ method: 'GET', url: '/api/config' });
-    const body = getRes.json() as { providers: Record<string, { apiKey: string }> };
-    expect(body.providers['openai'].apiKey).toBe('***');
-  });
-
-  it('returns 400 for unknown provider', async () => {
-    const server = makeServer(POST_TMP);
-    const res = await server.inject({
-      method: 'POST',
-      url: '/api/config/providers',
-      payload: { provider: 'unknown-llm', apiKeyEnvVar: 'SOME_KEY' },
-    });
-    expect(res.statusCode).toBe(400);
-    const body = res.json() as { error: string };
-    expect(body.error).toBeTruthy();
-  });
-});