agent-relay 3.2.2 → 3.2.4

package/packages/sdk/src/__tests__/start-from.test.ts

@@ -0,0 +1,346 @@
+/**
+ * Tests for the startFrom workflow execution feature.
+ *
+ * Validates that callers can start a workflow from a specific step,
+ * skipping all predecessor steps and loading cached outputs when available.
+ */
+
+import { afterEach, describe, it, expect, vi, beforeEach } from 'vitest';
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import type { WorkflowDb } from '../workflows/runner.js';
+import type { RelayYamlConfig, WorkflowRunRow, WorkflowStepRow } from '../workflows/types.js';
+
+// ── Mock fetch ───────────────────────────────────────────────────────────────
+
+const mockFetch = vi.fn().mockResolvedValue({
+  ok: true,
+  json: () => Promise.resolve({ data: { api_key: 'rk_live_test', workspace_id: 'ws-test' } }),
+  text: () => Promise.resolve(''),
+});
+vi.stubGlobal('fetch', mockFetch);
+
+// ── Mock RelayCast SDK ───────────────────────────────────────────────────────
+
+const mockRelaycastAgent = {
+  send: vi.fn().mockResolvedValue(undefined),
+  heartbeat: vi.fn().mockResolvedValue(undefined),
+  channels: {
+    create: vi.fn().mockResolvedValue(undefined),
+    join: vi.fn().mockResolvedValue(undefined),
+    invite: vi.fn().mockResolvedValue(undefined),
+  },
+};
+
+const mockRelaycast = {
+  agents: {
+    register: vi.fn().mockResolvedValue({ token: 'token-1' }),
+  },
+  as: vi.fn().mockReturnValue(mockRelaycastAgent),
+};
+
+class MockRelayError extends Error {
+  code: string;
+  constructor(code: string, message: string, status = 400) {
+    super(message);
+    this.code = code;
+    this.name = 'RelayError';
+    (this as any).status = status;
+  }
+}
+
+vi.mock('@relaycast/sdk', () => ({
+  RelayCast: vi.fn().mockImplementation(() => mockRelaycast),
+  RelayError: MockRelayError,
+}));
+
+// ── Mock AgentRelay ──────────────────────────────────────────────────────────
+
+let waitForExitFn: (ms?: number) => Promise<'exited' | 'timeout' | 'released'>;
+
+const mockAgent = {
+  name: 'test-agent-abc',
+  get waitForExit() { return waitForExitFn; },
+  get waitForIdle() { return vi.fn().mockImplementation(() => new Promise(() => {})); },
+  release: vi.fn().mockResolvedValue(undefined),
+};
+
+const mockHuman = {
+  name: 'WorkflowRunner',
+  sendMessage: vi.fn().mockResolvedValue(undefined),
+};
+
+const mockRelayInstance = {
+  spawnPty: vi.fn().mockImplementation(async ({ name, task }: { name: string; task?: string }) => {
+    const stepComplete = task?.match(/STEP_COMPLETE:([^\n]+)/)?.[1]?.trim();
+    const isReview = task?.includes('REVIEW_DECISION: APPROVE or REJECT');
+    const output = isReview
+      ? 'REVIEW_DECISION: APPROVE\nREVIEW_REASON: looks good\n'
+      : stepComplete
+        ? `STEP_COMPLETE:${stepComplete}\n`
+        : 'STEP_COMPLETE:unknown\n';
+
+    queueMicrotask(() => {
+      if (typeof mockRelayInstance.onWorkerOutput === 'function') {
+        mockRelayInstance.onWorkerOutput({ name, chunk: output });
+      }
+    });
+
+    return { ...mockAgent, name };
+  }),
+  human: vi.fn().mockReturnValue(mockHuman),
+  shutdown: vi.fn().mockResolvedValue(undefined),
+  onBrokerStderr: vi.fn().mockReturnValue(() => {}),
+  onWorkerOutput: null as ((frame: { name: string; chunk: string }) => void) | null,
+  onMessageReceived: null as any,
+  onAgentSpawned: null as any,
+  onAgentReleased: null as any,
+  onAgentExited: null as any,
+  onAgentIdle: null as any,
+  onDeliveryUpdate: null as any,
+  listAgentsRaw: vi.fn().mockResolvedValue([]),
+};
+
+vi.mock('../relay.js', () => ({
+  AgentRelay: vi.fn().mockImplementation(() => mockRelayInstance),
+}));
+
+// Import after mocking
+const { WorkflowRunner } = await import('../workflows/runner.js');
+const { workflow } = await import('../workflows/builder.js');
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeDb(): WorkflowDb {
+  const runs = new Map<string, WorkflowRunRow>();
+  const steps = new Map<string, WorkflowStepRow>();
+
+  return {
+    insertRun: vi.fn(async (run: WorkflowRunRow) => {
+      runs.set(run.id, { ...run });
+    }),
+    updateRun: vi.fn(async (id: string, patch: Partial<WorkflowRunRow>) => {
+      const existing = runs.get(id);
+      if (existing) runs.set(id, { ...existing, ...patch });
+    }),
+    getRun: vi.fn(async (id: string) => {
+      const run = runs.get(id);
+      return run ? { ...run } : null;
+    }),
+    insertStep: vi.fn(async (step: WorkflowStepRow) => {
+      steps.set(step.id, { ...step });
+    }),
+    updateStep: vi.fn(async (id: string, patch: Partial<WorkflowStepRow>) => {
+      const existing = steps.get(id);
+      if (existing) steps.set(id, { ...existing, ...patch });
+    }),
+    getStepsByRunId: vi.fn(async (runId: string) => {
+      return [...steps.values()].filter((s) => s.runId === runId);
+    }),
+  };
+}
+
+function makeLinearConfig(): RelayYamlConfig {
+  return {
+    version: '1',
+    name: 'test-start-from',
+    swarm: { pattern: 'dag' },
+    agents: [
+      { name: 'agent-a', cli: 'claude' },
+    ],
+    workflows: [
+      {
+        name: 'default',
+        steps: [
+          { name: 'step-1', agent: 'agent-a', task: 'Do step 1' },
+          { name: 'step-2', agent: 'agent-a', task: 'Do step 2', dependsOn: ['step-1'] },
+          { name: 'step-3', agent: 'agent-a', task: 'Do step 3', dependsOn: ['step-2'] },
+        ],
+      },
+    ],
+    trajectories: false,
+  };
+}
+
+function makeDiamondConfig(): RelayYamlConfig {
+  return {
+    version: '1',
+    name: 'test-diamond',
+    swarm: { pattern: 'dag' },
+    agents: [
+      { name: 'agent-a', cli: 'claude' },
+    ],
+    workflows: [
+      {
+        name: 'default',
+        steps: [
+          { name: 'root', agent: 'agent-a', task: 'Root step' },
+          { name: 'left', agent: 'agent-a', task: 'Left branch', dependsOn: ['root'] },
+          { name: 'right', agent: 'agent-a', task: 'Right branch', dependsOn: ['root'] },
+          { name: 'merge', agent: 'agent-a', task: 'Merge', dependsOn: ['left', 'right'] },
+        ],
+      },
+    ],
+    trajectories: false,
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('startFrom', () => {
+  let db: WorkflowDb;
+  let runner: InstanceType<typeof WorkflowRunner>;
+  let tmpDir: string;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    waitForExitFn = vi.fn().mockResolvedValue('exited');
+    mockRelayInstance.onWorkerOutput = null;
+    tmpDir = mkdtempSync(path.join(os.tmpdir(), 'start-from-'));
+    db = makeDb();
+    runner = new WorkflowRunner({ db, workspaceId: 'ws-test', cwd: tmpDir });
+  });
+
+  it('should throw when startFrom step does not exist', async () => {
+    const config = makeLinearConfig();
+    await expect(
+      runner.execute(config, 'default', undefined, { startFrom: 'nonexistent' })
+    ).rejects.toThrow('startFrom step "nonexistent" not found in workflow');
+  });
+
+  it('should skip predecessor steps in a linear chain', async () => {
+    const config = makeLinearConfig();
+    const events: Array<{ type: string; stepName?: string }> = [];
+    runner.on((event) => {
+      if ('stepName' in event) {
+        events.push({ type: event.type, stepName: event.stepName });
+      }
+    });
+
+    const run = await runner.execute(config, 'default', undefined, { startFrom: 'step-3' });
+    expect(run.status, run.error).toBe('completed');
+
+    // step-1 and step-2 should NOT have step:started events (they were pre-completed)
+    const startedSteps = events.filter((e) => e.type === 'step:started').map((e) => e.stepName);
+    expect(startedSteps).not.toContain('step-1');
+    expect(startedSteps).not.toContain('step-2');
+    expect(startedSteps).toContain('step-3');
+  });
+
+  it('should skip all transitive deps in a diamond DAG', async () => {
+    const config = makeDiamondConfig();
+    const events: Array<{ type: string; stepName?: string }> = [];
+    runner.on((event) => {
+      if ('stepName' in event) {
+        events.push({ type: event.type, stepName: event.stepName });
+      }
+    });
+
+    const run = await runner.execute(config, 'default', undefined, { startFrom: 'merge' });
+    expect(run.status, run.error).toBe('completed');
+
+    const startedSteps = events.filter((e) => e.type === 'step:started').map((e) => e.stepName);
+    expect(startedSteps).not.toContain('root');
+    expect(startedSteps).not.toContain('left');
+    expect(startedSteps).not.toContain('right');
+    expect(startedSteps).toContain('merge');
+  });
+
+  it('should load cached output from disk for skipped steps', async () => {
+    const config = makeLinearConfig();
+
+    // Pre-create cached output for step-1 (simulating a prior run)
+    // We need to intercept the runId to write to the correct path.
+    // Instead, we'll verify updateStep was called with expected output.
+    const run = await runner.execute(config, 'default', undefined, { startFrom: 'step-2' });
+    expect(run.status, run.error).toBe('completed');
+
+    // step-1 should have been marked completed with empty string (no cached output)
+    const updateCalls = (db.updateStep as any).mock.calls as Array<[string, Partial<WorkflowStepRow>]>;
+    const step1Completion = updateCalls.find(
+      ([_, patch]) => patch.status === 'completed' && patch.output === ''
+    );
+    expect(step1Completion).toBeDefined();
+  });
+
+  it('should load cached output when available on disk via previousRunId', async () => {
+    const config = makeLinearConfig();
+
+    // Write cached output for step-1 under a known previous run ID
+    const prevRunId = 'prev-run-abc123';
+    const outputDir = path.join(tmpDir, '.agent-relay', 'step-outputs', prevRunId);
+    mkdirSync(outputDir, { recursive: true });
+    writeFileSync(path.join(outputDir, 'step-1.md'), 'cached-output-from-step-1');
+
+    const run = await runner.execute(config, 'default', undefined, {
+      startFrom: 'step-2',
+      previousRunId: prevRunId,
+    });
+    expect(run.status, run.error).toBe('completed');
+
+    // Verify step-1 was marked completed with the cached output
+    const updateCalls = (db.updateStep as any).mock.calls as Array<[string, Partial<WorkflowStepRow>]>;
+    const step1WithCachedOutput = updateCalls.find(
+      ([_, patch]) => patch.status === 'completed' && patch.output === 'cached-output-from-step-1'
+    );
+    expect(step1WithCachedOutput).toBeDefined();
+  });
+
+  it('should work when startFrom targets the first step (no deps to skip)', async () => {
+    const config = makeLinearConfig();
+    const events: Array<{ type: string; stepName?: string }> = [];
+    runner.on((event) => {
+      if ('stepName' in event) {
+        events.push({ type: event.type, stepName: event.stepName });
+      }
+    });
+
+    const run = await runner.execute(config, 'default', undefined, { startFrom: 'step-1' });
+    expect(run.status, run.error).toBe('completed');
+
+    // All 3 steps should start since step-1 has no deps
+    const startedSteps = events.filter((e) => e.type === 'step:started').map((e) => e.stepName);
+    expect(startedSteps).toContain('step-1');
+    expect(startedSteps).toContain('step-2');
+    expect(startedSteps).toContain('step-3');
+  });
+
+  it('should work with builder .startFrom() chainable method', () => {
+    const config = workflow('test')
+      .agent('worker', { cli: 'claude' })
+      .step('build', { agent: 'worker', task: 'Build' })
+      .step('test', { agent: 'worker', task: 'Test', dependsOn: ['build'] })
+      .step('deploy', { agent: 'worker', task: 'Deploy', dependsOn: ['test'] })
+      .startFrom('deploy')
+      .toConfig();
+
+    // toConfig() should still produce valid config — startFrom is a runtime option
+    expect(config.workflows![0].steps).toHaveLength(3);
+    expect(config.agents).toHaveLength(1);
+  });
+
+  it('should pass startFrom from WorkflowRunOptions', async () => {
+    const config = makeLinearConfig();
+    const events: Array<{ type: string; stepName?: string }> = [];
+
+    // Test via runner.execute directly with options
+    runner.on((event) => {
+      if ('stepName' in event) {
+        events.push({ type: event.type, stepName: event.stepName });
+      }
+    });
+
+    const run = await runner.execute(config, 'default', undefined, { startFrom: 'step-2' });
+    expect(run.status, run.error).toBe('completed');
+
+    const startedSteps = events.filter((e) => e.type === 'step:started').map((e) => e.stepName);
+    expect(startedSteps).not.toContain('step-1');
+    expect(startedSteps).toContain('step-2');
+    expect(startedSteps).toContain('step-3');
+  });
+
+  afterEach(() => {
+    try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  });
+});

package/packages/sdk/src/client.ts

@@ -6,6 +6,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
+import { getProjectPaths } from '@agent-relay/config';
+
 import {
   PROTOCOL_VERSION,
   type AgentRuntime,
@@ -886,3 +888,302 @@ function resolveDefaultBinaryPath(): string {
   // 4. Auto-install from GitHub releases
   return installBrokerBinary();
 }
+
+// ---------------------------------------------------------------------------
+// HTTP transport client — connects to an already-running broker's HTTP API
+// ---------------------------------------------------------------------------
+
+export interface HttpAgentRelayClientOptions {
+  port: number;
+  apiKey?: string;
+}
+
+export interface DiscoverAndConnectOptions {
+  cwd?: string;
+  apiKey?: string;
+  /** Auto-start the broker if not running (default: false). */
+  autoStart?: boolean;
+  /**
+   * Path to the broker binary for auto-start.
+   * If not provided, the SDK resolves it automatically via standard install locations
+   * (~/.agent-relay/bin, bundled platform binary, or Cargo release build).
+   * Only used when `autoStart: true`.
+   */
+  brokerBinaryPath?: string;
+}
+
+const DEFAULT_DASHBOARD_PORT = (() => {
+  const envPort = typeof process !== 'undefined' ? process.env.AGENT_RELAY_DASHBOARD_PORT : undefined;
+  if (envPort) {
+    const parsed = Number.parseInt(envPort, 10);
+    if (Number.isFinite(parsed) && parsed > 0) return parsed;
+  }
+  return 3888;
+})();
+const HTTP_MAX_PORT_SCAN = 25;
+const HTTP_AUTOSTART_TIMEOUT_MS = 10_000;
+const HTTP_AUTOSTART_POLL_MS = 250;
+
+function sanitizeBrokerName(name: string): string {
+  return name.replace(/[^\p{L}\p{N}-]/gu, '-');
+}
+
+function brokerPidFilename(projectRoot: string): string {
+  const brokerName = path.basename(projectRoot) || 'project';
+  return `broker-${sanitizeBrokerName(brokerName)}.pid`;
+}
+
+export class HttpAgentRelayClient {
+  private readonly port: number;
+  private readonly apiKey?: string;
+
+  constructor(options: HttpAgentRelayClientOptions) {
+    this.port = options.port;
+    this.apiKey = options.apiKey;
+  }
+
+  /**
+   * Connect to an already-running broker on the given port.
+   */
+  static async connectHttp(
+    port: number,
+    options?: { apiKey?: string }
+  ): Promise<HttpAgentRelayClient> {
+    const client = new HttpAgentRelayClient({ port, apiKey: options?.apiKey });
+    // Verify connectivity
+    await client.healthCheck();
+    return client;
+  }
+
+  /**
+   * Discover a running broker for the current project and connect to it.
+   * Reads the broker PID file, verifies the process is alive, scans ports
+   * for the HTTP API, and returns a connected client.
+   */
+  static async discoverAndConnect(
+    options?: DiscoverAndConnectOptions
+  ): Promise<HttpAgentRelayClient> {
+    const cwd = options?.cwd ?? process.cwd();
+    const apiKey = options?.apiKey ?? process.env.RELAY_BROKER_API_KEY?.trim();
+    const autoStart = options?.autoStart ?? false;
+    const paths = getProjectPaths(cwd);
+    const preferredApiPort = DEFAULT_DASHBOARD_PORT + 1;
+
+    // Try to find a running broker via PID file
+    const pidFilePath = path.join(paths.dataDir, brokerPidFilename(paths.projectRoot));
+    const legacyPidPath = path.join(paths.dataDir, 'broker.pid');
+    let brokerRunning = false;
+
+    for (const pidPath of [pidFilePath, legacyPidPath]) {
+      if (fs.existsSync(pidPath)) {
+        const pidStr = fs.readFileSync(pidPath, 'utf-8').trim();
+        const pid = Number.parseInt(pidStr, 10);
+        if (Number.isFinite(pid) && pid > 0) {
+          try {
+            process.kill(pid, 0);
+            brokerRunning = true;
+            break;
+          } catch {
+            // Process not running
+          }
+        }
+      }
+    }
+
+    if (brokerRunning) {
+      const port = await HttpAgentRelayClient.scanForBrokerPort(preferredApiPort);
+      if (port !== null) {
+        return new HttpAgentRelayClient({ port, apiKey });
+      }
+      throw new AgentRelayProcessError(
+        'broker is running for this project, but its local API is unavailable'
+      );
+    }
+
+    if (!autoStart) {
+      throw new AgentRelayProcessError('broker is not running for this project');
+    }
+
+    // Auto-start the broker using the resolved binary path (not process.argv[1],
+    // which only works from CLI context — breaks when SDK is imported by user apps).
+    // The broker binary requires the `init` subcommand with `--api-port` and
+    // `--persist` so it writes PID files for subsequent discovery.
+    const brokerBinary = options?.brokerBinaryPath ?? resolveDefaultBinaryPath();
+
+    const child = spawn(
+      brokerBinary,
+      ['init', '--persist', '--api-port', String(preferredApiPort)],
+      {
+        cwd: paths.projectRoot,
+        env: process.env,
+        detached: true,
+        stdio: 'ignore',
+      }
+    );
+    child.unref();
+
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < HTTP_AUTOSTART_TIMEOUT_MS) {
+      const port = await HttpAgentRelayClient.scanForBrokerPort(preferredApiPort);
+      if (port !== null) {
+        return new HttpAgentRelayClient({ port, apiKey });
+      }
+      await new Promise((resolve) => setTimeout(resolve, HTTP_AUTOSTART_POLL_MS));
+    }
+
+    throw new AgentRelayProcessError(
+      `broker did not become ready within ${HTTP_AUTOSTART_TIMEOUT_MS}ms`
+    );
+  }
+
+  private static async scanForBrokerPort(startPort: number): Promise<number | null> {
+    for (let i = 0; i < HTTP_MAX_PORT_SCAN; i++) {
+      const port = startPort + i;
+      try {
+        const res = await fetch(`http://127.0.0.1:${port}/health`);
+        if (!res.ok) continue;
+        const payload = (await res.json().catch(() => null)) as { service?: string } | null;
+        if (payload?.service === 'agent-relay-listen') {
+          return port;
+        }
+      } catch {
+        // Keep scanning
+      }
+    }
+    return null;
+  }
+
+  private async request<T = unknown>(pathname: string, init?: RequestInit): Promise<T> {
+    const headers = new Headers(init?.headers);
+    if (this.apiKey && !headers.has('x-api-key') && !headers.has('authorization')) {
+      headers.set('x-api-key', this.apiKey);
+    }
+
+    const response = await fetch(`http://127.0.0.1:${this.port}${pathname}`, {
+      ...init,
+      headers,
+    });
+
+    const text = await response.text();
+    let payload: unknown;
+    try {
+      payload = text ? JSON.parse(text) : undefined;
+    } catch {
+      payload = text;
+    }
+
+    if (!response.ok) {
+      const msg = HttpAgentRelayClient.extractErrorMessage(response, payload);
+      throw new AgentRelayProcessError(msg);
+    }
+
+    return payload as T;
+  }
+
+  private static extractErrorMessage(response: Response, payload: unknown): string {
+    if (typeof payload === 'string' && payload.trim()) return payload.trim();
+    const p = payload as Record<string, unknown> | undefined;
+    if (typeof p?.error === 'string') return p.error;
+    if (typeof (p?.error as Record<string, unknown>)?.message === 'string')
+      return (p!.error as Record<string, unknown>).message as string;
+    if (typeof p?.message === 'string' && (p.message as string).trim())
+      return (p.message as string).trim();
+    return `${response.status} ${response.statusText}`.trim();
+  }
+
+  async healthCheck(): Promise<{ service: string }> {
+    return this.request<{ service: string }>('/health');
+  }
+
+  /** No-op — broker is already running. */
+  async start(): Promise<void> {}
+
+  /** No-op — don't kill an externally-managed broker. */
+  async shutdown(): Promise<void> {}
+
+  async spawnPty(input: SpawnPtyInput): Promise<{ name: string; runtime: AgentRuntime }> {
+    const payload = await this.request<{ name?: string }>('/api/spawn', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        name: input.name,
+        cli: input.cli,
+        model: input.model,
+        args: input.args ?? [],
+        task: input.task,
+        channels: input.channels ?? [],
+        cwd: input.cwd,
+        team: input.team,
+        shadowOf: input.shadowOf,
+        shadowMode: input.shadowMode,
+        continueFrom: input.continueFrom,
+        idleThresholdSecs: input.idleThresholdSecs,
+        restartPolicy: input.restartPolicy,
+        skipRelayPrompt: input.skipRelayPrompt,
+      }),
+    });
+    return {
+      name: typeof payload?.name === 'string' ? payload.name : input.name,
+      runtime: 'pty',
+    };
+  }
+
+  async sendMessage(input: SendMessageInput): Promise<{ event_id: string; targets: string[] }> {
+    return this.request<{ event_id: string; targets: string[] }>('/api/send', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        to: input.to,
+        text: input.text,
+        from: input.from,
+        threadId: input.threadId,
+        workspaceId: input.workspaceId,
+        workspaceAlias: input.workspaceAlias,
+        priority: input.priority,
+        data: input.data,
+      }),
+    });
+  }
+
+  async listAgents(): Promise<ListAgent[]> {
+    const payload = await this.request<{ agents?: ListAgent[] }>('/api/spawned', { method: 'GET' });
+    return Array.isArray(payload?.agents) ? payload.agents : [];
+  }
+
+  async release(name: string, reason?: string): Promise<{ name: string }> {
+    const payload = await this.request<{ name?: string }>(
+      `/api/spawned/${encodeURIComponent(name)}`,
+      {
+        method: 'DELETE',
+        ...(reason
+          ? { headers: { 'content-type': 'application/json' }, body: JSON.stringify({ reason }) }
+          : {}),
+      }
+    );
+    return { name: typeof payload?.name === 'string' ? payload.name : name };
+  }
+
+  async setModel(
+    name: string,
+    model: string,
+    opts?: { timeoutMs?: number }
+  ): Promise<{ name: string; model: string; success: boolean }> {
+    const payload = await this.request<{ success?: boolean; model?: string }>(
+      `/api/spawned/${encodeURIComponent(name)}/model`,
+      {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ model, timeoutMs: opts?.timeoutMs }),
+      }
+    );
+    return {
+      name,
+      model: typeof payload?.model === 'string' ? payload.model : model,
+      success: payload?.success !== false,
+    };
+  }
+
+  async getConfig(): Promise<{ workspace_key?: string }> {
+    return this.request<{ workspace_key?: string }>('/api/config');
+  }
+}