Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
12.6 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, test } from "bun:test";
import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { z } from "zod";

import { writeRuntimeOpencodeConfig } from "./runtime-opencode-config-store.js";
import { startServer } from "./server.js";
import type { ServerConfig } from "./types.js";

const CLIENT_TOKEN = "owt_connect_client_token";
const HOST_TOKEN = "owt_connect_host_token";

const actionSchema = z.object({
  extensionId: z.string(),
  action: z.string(),
}).passthrough();

const actionsResponseSchema = z.object({
  ok: z.literal(true),
  schemaVersion: z.literal(1),
  actions: z.array(actionSchema),
}).passthrough();

const apiErrorSchema = z.object({
  code: z.string(),
  message: z.string(),
}).passthrough();

const connectStateResponseSchema = z.object({
  ok: z.literal(true),
  schemaVersion: z.literal(1),
  status: z.enum(["available", "missing", "invalid", "unreadable"]),
  connectEnabled: z.boolean(),
  cloudMcpPresent: z.boolean(),
  googleWorkspace: z.object({ legacyConfigured: z.boolean() }),
}).passthrough();

const gatedCallSchema = z.object({
  ok: z.literal(false),
  error: z.literal("use_omnirush_cloud"),
  message: z.string(),
}).passthrough();

const googleWorkspaceStatusSchema = z.object({
  configured: z.boolean(),
  missing: z.array(z.string()),
  connected: z.boolean(),
  connect: z.object({
    enabled: z.literal(true),
    cloudMcpPresent: z.boolean(),
    guidance: z.string(),
  }).optional(),
}).passthrough();

const googleWorkspaceStatusActionSchema = z.object({
  ok: z.literal(true),
  extensionId: z.literal("google-workspace"),
  action: z.literal("status"),
  result: googleWorkspaceStatusSchema,
}).passthrough();

type ActionItem = z.infer<typeof actionSchema>;

const previousEnv = {
  runtimeDb: process.env.OMNIRUSH_RUNTIME_DB,
  googleClientSecret: process.env.GOOGLE_WORKSPACE_OAUTH_CLIENT_SECRET,
  legacyGoogleClientSecret: process.env.OMNIRUSH_GOOGLE_WORKSPACE_OAUTH_CLIENT_SECRET,
  tokenBrokerUrl: process.env.OMNIRUSH_GOOGLE_WORKSPACE_TOKEN_BROKER_URL,
  legacyTokenBrokerUrl: process.env.GOOGLE_WORKSPACE_TOKEN_BROKER_URL,
};

const stops: Array<() => void | Promise<void>> = [];
const dirs: string[] = [];

function restoreEnv(key: string, value: string | undefined) {
  if (typeof value === "string") process.env[key] = value;
  else delete process.env[key];
}

function clearLegacyGoogleWorkspaceEnv() {
  delete process.env.GOOGLE_WORKSPACE_OAUTH_CLIENT_SECRET;
  delete process.env.OMNIRUSH_GOOGLE_WORKSPACE_OAUTH_CLIENT_SECRET;
  delete process.env.OMNIRUSH_GOOGLE_WORKSPACE_TOKEN_BROKER_URL;
  delete process.env.GOOGLE_WORKSPACE_TOKEN_BROKER_URL;
}

function serverConfig(root: string): ServerConfig {
  return {
    host: "127.0.0.1",
    port: 0,
    token: CLIENT_TOKEN,
    hostToken: HOST_TOKEN,
    configPath: join(root, "server.json"),
    approval: { mode: "auto", timeoutMs: 1000 },
    corsOrigins: ["*"],
    workspaces: [{ id: "ws_1", name: "Test", path: root, preset: "starter", workspaceType: "local" }],
    authorizedRoots: [root],
    readOnly: false,
    startedAt: Date.now(),
    tokenSource: "generated",
    hostTokenSource: "generated",
    logFormat: "pretty",
    logRequests: false,
  };
}

async function boot() {
  const root = await mkdtemp(join(tmpdir(), "omnirush-connect-gating-"));
  dirs.push(root);
  process.env.OMNIRUSH_RUNTIME_DB = join(root, "runtime.sqlite");
  const config = serverConfig(root);
  const server = await startServer(config);
  stops.push(() => server.stop());
  return { base: `http://127.0.0.1:${server.port}`, config, root };
}

function clientHeaders() {
  return { authorization: `Bearer ${CLIENT_TOKEN}` };
}

function clientJsonHeaders() {
  return { ...clientHeaders(), "content-type": "application/json" };
}

function hostJsonHeaders() {
  return { "x-omnirush-host-token": HOST_TOKEN, "content-type": "application/json" };
}

async function readSchema<T>(response: Response, schema: z.ZodType<T>): Promise<T> {
  const body: unknown = await response.json();
  return schema.parse(body);
}

async function listActions(base: string): Promise<ActionItem[]> {
  const response = await fetch(`${base}/experimental/extensions/actions`, { headers: clientHeaders() });
  expect(response.status).toBe(200);
  return (await readSchema(response, actionsResponseSchema)).actions;
}

function actionKeys(actions: ActionItem[]): string[] {
  return actions.map((action) => `${action.extensionId}/${action.action}`).sort();
}

async function putConnectState(base: string, body: unknown): Promise<Response> {
  return fetch(`${base}/experimental/connect/state`, {
    method: "PUT",
    headers: hostJsonHeaders(),
    body: JSON.stringify(body),
  });
}

async function callCalendarListEvents(base: string): Promise<Response> {
  return fetch(`${base}/experimental/extensions/call`, {
    method: "POST",
    headers: clientJsonHeaders(),
    body: JSON.stringify({
      extensionId: "google-workspace",
      action: "calendar_list_events",
      args: {
        timeMin: "2026-01-01T00:00:00.000Z",
        timeMax: "2026-01-02T00:00:00.000Z",
      },
      context: {},
    }),
  });
}

async function callGoogleWorkspaceStatus(base: string): Promise<Response> {
  return fetch(`${base}/experimental/extensions/call`, {
    method: "POST",
    headers: clientJsonHeaders(),
    body: JSON.stringify({
      extensionId: "google-workspace",
      action: "status",
      args: {},
      context: {},
    }),
  });
}

async function expectLegacyCallPassesThrough(base: string) {
  const response = await callCalendarListEvents(base);
  expect(response.status).toBe(400);
  const body = await readSchema(response, apiErrorSchema);
  expect(body.code).toBe("google_workspace_not_connected");
}

function expectAllActions(actions: ActionItem[]) {
  expect(actions).toHaveLength(18);
  expect(actions.filter((action) => action.extensionId === "google-workspace")).toHaveLength(14);
  expect(actions.filter((action) => action.extensionId === "openai-image-generation")).toHaveLength(2);
  expect(actions.filter((action) => action.extensionId === "omnirush-cloud-uploads")).toHaveLength(2);
}

beforeEach(() => {
  clearLegacyGoogleWorkspaceEnv();
});

afterEach(async () => {
  while (stops.length) {
    await stops.pop()?.();
  }
  while (dirs.length) {
    const dir = dirs.pop();
    if (dir) await rm(dir, { recursive: true, force: true });
  }
  restoreEnv("OMNIRUSH_RUNTIME_DB", previousEnv.runtimeDb);
  restoreEnv("GOOGLE_WORKSPACE_OAUTH_CLIENT_SECRET", previousEnv.googleClientSecret);
  restoreEnv("OMNIRUSH_GOOGLE_WORKSPACE_OAUTH_CLIENT_SECRET", previousEnv.legacyGoogleClientSecret);
  restoreEnv("OMNIRUSH_GOOGLE_WORKSPACE_TOKEN_BROKER_URL", previousEnv.tokenBrokerUrl);
  restoreEnv("GOOGLE_WORKSPACE_TOKEN_BROKER_URL", previousEnv.legacyTokenBrokerUrl);
});

describe("Connect-aware legacy extension gating", () => {
  test("defaults to unchanged legacy extension behavior when no connect state file exists", async () => {
    const { base } = await boot();

    expectAllActions(await listActions(base));
    await expectLegacyCallPassesThrough(base);
  });

  test("keeps legacy extension behavior unchanged when connectEnabled is false", async () => {
    const { base } = await boot();
    const put = await putConnectState(base, { connectEnabled: false });
    expect(put.status).toBe(200);

    expectAllActions(await listActions(base));
    await expectLegacyCallPassesThrough(base);
    const statusAction = await readSchema(await callGoogleWorkspaceStatus(base), googleWorkspaceStatusActionSchema);
    expect(statusAction.result.connect).toBeUndefined();
  });

  test("keeps legacy extension behavior unchanged when legacy Google Workspace is configured", async () => {
    process.env.GOOGLE_WORKSPACE_OAUTH_CLIENT_SECRET = "test-secret";
    const { base } = await boot();
    const put = await putConnectState(base, { connectEnabled: true });
    expect(put.status).toBe(200);

    expectAllActions(await listActions(base));
    await expectLegacyCallPassesThrough(base);
    const statusAction = await readSchema(await callGoogleWorkspaceStatus(base), googleWorkspaceStatusActionSchema);
    expect(statusAction.result.connect).toBeUndefined();
    const state = await readSchema(
      await fetch(`${base}/experimental/connect/state`, { headers: clientHeaders() }),
      connectStateResponseSchema,
    );
    expect(state.googleWorkspace.legacyConfigured).toBe(true);
  });

  test("gates only non-status Google Workspace actions when Connect is enabled without legacy config", async () => {
    const { base, config } = await boot();
    const put = await putConnectState(base, { connectEnabled: true });
    expect(put.status).toBe(200);

    const actions = await listActions(base);
    expect(actionKeys(actions)).toEqual([
      "google-workspace/status",
      "omnirush-cloud-uploads/drive_upload_file",
      "omnirush-cloud-uploads/gmail_create_draft_with_attachments",
      "openai-image-generation/image_generate",
      "openai-image-generation/status",
    ]);

    const gated = await callCalendarListEvents(base);
    expect(gated.status).toBe(200);
    const gatedBody = await readSchema(gated, gatedCallSchema);
    expect(gatedBody.message).toContain("Settings > Connect");
    expect(gatedBody.message).toContain("Do not direct them to Settings > Extensions");

    const statusAction = await readSchema(await callGoogleWorkspaceStatus(base), googleWorkspaceStatusActionSchema);
    expect(statusAction.result.connect).toEqual({
      enabled: true,
      cloudMcpPresent: false,
      guidance: gatedBody.message,
    });

    await writeRuntimeOpencodeConfig(config, "ws_1", (current) => ({
      ...current,
      mcp: {
        ...current.mcp,
        "omnirush-cloud": { type: "remote", url: "https://cloud.example/mcp" },
      },
    }));

    const cloudGated = await callCalendarListEvents(base);
    const cloudBody = await readSchema(cloudGated, gatedCallSchema);
    expect(cloudBody.message).toContain("agent access needs attention for this workspace");
    expect(cloudBody.message).not.toContain("not ready");
    expect(cloudBody.message).not.toContain("Repair and test");
    expect(cloudBody.message).toContain("Settings > Connect");

    const cloudStatusAction = await readSchema(await callGoogleWorkspaceStatus(base), googleWorkspaceStatusActionSchema);
    expect(cloudStatusAction.result.connect).toEqual({
      enabled: true,
      cloudMcpPresent: false,
      guidance: cloudBody.message,
    });
  });

  test("validates and round-trips the persisted connect state route", async () => {
    const { base, root } = await boot();
    const initialState = await readSchema(
      await fetch(`${base}/experimental/connect/state`, { headers: clientHeaders() }),
      connectStateResponseSchema,
    );
    expect(initialState).toMatchObject({ status: "missing", connectEnabled: false });

    const statePath = join(root, "connect-state.json");
    await writeFile(statePath, "{not valid json", "utf8");
    const invalidState = await readSchema(
      await fetch(`${base}/experimental/connect/state`, { headers: clientHeaders() }),
      connectStateResponseSchema,
    );
    expect(invalidState).toMatchObject({ status: "invalid", connectEnabled: false });

    await rm(statePath);
    await mkdir(statePath);
    const unreadableState = await readSchema(
      await fetch(`${base}/experimental/connect/state`, { headers: clientHeaders() }),
      connectStateResponseSchema,
    );
    expect(unreadableState).toMatchObject({ status: "unreadable", connectEnabled: false });
    await rm(statePath, { recursive: true });

    const badType = await putConnectState(base, { connectEnabled: "true" });
    expect(badType.status).toBe(400);
    expect((await readSchema(badType, apiErrorSchema)).code).toBe("invalid_payload");

    const extraKey = await putConnectState(base, { connectEnabled: true, extra: false });
    expect(extraKey.status).toBe(400);

    const put = await putConnectState(base, { connectEnabled: true });
    expect(put.status).toBe(200);
    const putState = await readSchema(put, connectStateResponseSchema);
    expect(putState.status).toBe("available");
    expect(putState.connectEnabled).toBe(true);
    expect(putState.cloudMcpPresent).toBe(false);
    expect(putState.googleWorkspace.legacyConfigured).toBe(false);

    const get = await fetch(`${base}/experimental/connect/state`, { headers: clientHeaders() });
    expect(get.status).toBe(200);
    const getState = await readSchema(get, connectStateResponseSchema);
    expect(getState.status).toBe("available");
    expect(getState.connectEnabled).toBe(putState.connectEnabled);
    expect(getState.cloudMcpPresent).toBe(putState.cloudMcpPresent);
    expect(getState.googleWorkspace).toEqual(putState.googleWorkspace);
  });
});