Skip to content

Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

9.7 KB
Raw Blame
import path from 'node:path';
import * as tempy from 'tempy';
import fs from 'node:fs';
import { describe, it, vi } from '@effect/vitest';
import { assertEquals } from '@effect/vitest/utils';
import * as FileSystem from '@effect/platform/FileSystem';
import * as BunFileSystem from '@effect/platform-bun/BunFileSystem';
import * as BunPath from '@effect/platform-bun/BunPath';
import { ConfigProvider, Effect, Layer } from 'effect';
import { extendConfigProvider } from 'src/services/config';
import { defaultNodeOs, NodeOs } from 'src/services/node-os';
import { ComposioCliUserConfig, ComposioCliUserConfigLive } from 'src/services/cli-user-config';

describe('ComposioCliUserConfig', () => {
  const withMapConfigProvider = (map: Map<string, string>) =>
    Layer.setConfigProvider(extendConfigProvider(ConfigProvider.fromMap(map)));

  it.scoped('defaults experimental features off in stable releases', () => {
    const cwd = tempy.temporaryDirectory();
    const map = new Map([['DEBUG_OVERRIDE_VERSION', '1.2.3']]) satisfies Map<string, string>;
    const NodeOsTest = Layer.succeed(NodeOs, defaultNodeOs({ homedir: cwd }));
    const CliUserConfigTest = Layer.provideMerge(
      ComposioCliUserConfigLive,
      Layer.mergeAll(BunFileSystem.layer, BunPath.layer, NodeOsTest, withMapConfigProvider(map))
    );

    return Effect.gen(function* () {
      const config = yield* ComposioCliUserConfig;
      assertEquals(config.channel, 'stable');
      assertEquals(config.data.developerModeEnabled, true);
      assertEquals(config.data.developerDangerousCommandsEnabled, false);
      assertEquals(config.data.experimentalFeatures.listen, undefined);
      assertEquals(config.isExperimentalFeatureEnabled('listen'), false);
      assertEquals(config.data.experimentalSubagentTarget, 'auto');
      assertEquals(config.data.artifactDirectory, undefined);

      const fs = yield* FileSystem.FileSystem;
      assertEquals(yield* fs.exists(path.join(cwd, '.composio', 'config.json')), true);
    }).pipe(Effect.provide(CliUserConfigTest));
  });

  it.scoped('uses installed beta release metadata for experimental defaults', () => {
    const cwd = tempy.temporaryDirectory();
    const installDir = tempy.temporaryDirectory();
    const fakeExecPath = path.join(installDir, 'composio');
    fs.writeFileSync(fakeExecPath, 'fake binary');
    fs.writeFileSync(path.join(installDir, 'release-tag.txt'), '@composio/[email protected]\n');
    const execPathSpy = vi.spyOn(process, 'execPath', 'get').mockReturnValue(fakeExecPath);
    const map = new Map() satisfies Map<string, string>;
    const NodeOsTest = Layer.succeed(NodeOs, defaultNodeOs({ homedir: cwd }));
    const CliUserConfigTest = Layer.provideMerge(
      ComposioCliUserConfigLive,
      Layer.mergeAll(BunFileSystem.layer, BunPath.layer, NodeOsTest, withMapConfigProvider(map))
    );

    return Effect.gen(function* () {
      try {
        const config = yield* ComposioCliUserConfig;
        assertEquals(config.channel, 'beta');
        assertEquals(config.isExperimentalFeatureEnabled('listen'), true);
        assertEquals(config.isExperimentalFeatureEnabled('local_tools'), true);
      } finally {
        execPathSpy.mockRestore();
      }
    }).pipe(Effect.provide(CliUserConfigTest));
  });

  it.scoped('defaults experimental features on in beta releases', () => {
    const cwd = tempy.temporaryDirectory();
    const map = new Map([['DEBUG_OVERRIDE_VERSION', '1.2.3-beta.4']]) satisfies Map<string, string>;
    const NodeOsTest = Layer.succeed(NodeOs, defaultNodeOs({ homedir: cwd }));
    const CliUserConfigTest = Layer.provideMerge(
      ComposioCliUserConfigLive,
      Layer.mergeAll(BunFileSystem.layer, BunPath.layer, NodeOsTest, withMapConfigProvider(map))
    );

    return Effect.gen(function* () {
      const config = yield* ComposioCliUserConfig;
      assertEquals(config.channel, 'beta');
      assertEquals(config.data.developerModeEnabled, true);
      assertEquals(config.data.developerDangerousCommandsEnabled, false);
      assertEquals(config.data.experimentalFeatures.listen, undefined);
      assertEquals(config.isExperimentalFeatureEnabled('listen'), true);
      assertEquals(config.data.experimentalSubagentTarget, 'auto');
    }).pipe(Effect.provide(CliUserConfigTest));
  });

  it.scoped('respects explicit persisted cli settings from config.json', () => {
    const cwd = tempy.temporaryDirectory();
    const map = new Map([['DEBUG_OVERRIDE_VERSION', '1.2.3-beta.4']]) satisfies Map<string, string>;
    fs.mkdirSync(path.join(cwd, '.composio'), { recursive: true });
    fs.writeFileSync(
      path.join(cwd, '.composio', 'config.json'),
      JSON.stringify({
        developer: {
          enabled: false,
          destructive_actions: true,
        },
        experimental_features: {
          listen: false,
          multi_account: false,
        },
        artifact_directory: '/tmp/composio-artifacts',
        experimental_subagent: {
          target: 'claude',
        },
      })
    );

    const NodeOsTest = Layer.succeed(NodeOs, defaultNodeOs({ homedir: cwd }));
    const CliUserConfigTest = Layer.provideMerge(
      ComposioCliUserConfigLive,
      Layer.mergeAll(BunFileSystem.layer, BunPath.layer, NodeOsTest, withMapConfigProvider(map))
    );

    return Effect.gen(function* () {
      const fileSystem = yield* FileSystem.FileSystem;
      const config = yield* ComposioCliUserConfig;
      assertEquals(config.data.developerModeEnabled, false);
      assertEquals(config.data.developerDangerousCommandsEnabled, true);
      assertEquals(config.data.experimentalFeatures.listen, false);
      assertEquals(config.isExperimentalFeatureEnabled('listen'), false);
      assertEquals(config.data.experimentalFeatures.multi_account, false);
      assertEquals(config.isExperimentalFeatureEnabled('multi_account'), false);
      assertEquals(config.data.artifactDirectory, '/tmp/composio-artifacts');
      assertEquals(config.data.experimentalSubagentTarget, 'claude');

      const persisted = yield* fileSystem.readFileString(
        path.join(cwd, '.composio', 'config.json'),
        'utf8'
      );
      const parsed = JSON.parse(persisted) as {
        developer: {
          enabled: boolean;
          destructive_actions: boolean;
        };
        experimental_features: { listen: boolean; multi_account: boolean };
        artifact_directory: string;
        experimental_subagent: { target: string };
      };

      assertEquals(parsed.developer.enabled, false);
      assertEquals(parsed.developer.destructive_actions, true);
      assertEquals(parsed.experimental_features.listen, false);
      assertEquals(parsed.experimental_features.multi_account, false);
      assertEquals(parsed.artifact_directory, '/tmp/composio-artifacts');
      assertEquals(parsed.experimental_subagent.target, 'claude');
    }).pipe(Effect.provide(CliUserConfigTest));
  });

  it.scoped('loads legacy flat developer keys and persists nested developer config', () => {
    const cwd = tempy.temporaryDirectory();
    const map = new Map([['DEBUG_OVERRIDE_VERSION', '1.2.3-beta.4']]) satisfies Map<string, string>;
    fs.mkdirSync(path.join(cwd, '.composio'), { recursive: true });
    fs.writeFileSync(
      path.join(cwd, '.composio', 'config.json'),
      JSON.stringify({
        developer_mode_enabled: false,
        developer_dangerous_commands_enabled: true,
      })
    );

    const NodeOsTest = Layer.succeed(NodeOs, defaultNodeOs({ homedir: cwd }));
    const CliUserConfigTest = Layer.provideMerge(
      ComposioCliUserConfigLive,
      Layer.mergeAll(BunFileSystem.layer, BunPath.layer, NodeOsTest, withMapConfigProvider(map))
    );

    return Effect.gen(function* () {
      const fileSystem = yield* FileSystem.FileSystem;
      const config = yield* ComposioCliUserConfig;
      assertEquals(config.data.developerModeEnabled, false);
      assertEquals(config.data.developerDangerousCommandsEnabled, true);

      yield* config.update({
        developer: {
          ...config.raw.developer,
          enabled: true,
        },
      });

      const persisted = yield* fileSystem.readFileString(
        path.join(cwd, '.composio', 'config.json'),
        'utf8'
      );
      const parsed = JSON.parse(persisted) as {
        developer: {
          enabled: boolean;
          destructive_actions: boolean;
        };
        developer_mode_enabled?: boolean;
        developer_dangerous_commands_enabled?: boolean;
      };

      assertEquals(parsed.developer.enabled, true);
      assertEquals(parsed.developer.destructive_actions, true);
      assertEquals(parsed.developer_mode_enabled, undefined);
      assertEquals(parsed.developer_dangerous_commands_enabled, undefined);
    }).pipe(Effect.provide(CliUserConfigTest));
  });

  it.scoped('replaces malformed persisted config with safe defaults', () => {
    const cwd = tempy.temporaryDirectory();
    const map = new Map([['DEBUG_OVERRIDE_VERSION', '1.2.3']]) satisfies Map<string, string>;
    fs.mkdirSync(path.join(cwd, '.composio'), { recursive: true });
    fs.writeFileSync(path.join(cwd, '.composio', 'config.json'), JSON.stringify(['not-an-object']));

    const NodeOsTest = Layer.succeed(NodeOs, defaultNodeOs({ homedir: cwd }));
    const CliUserConfigTest = Layer.provideMerge(
      ComposioCliUserConfigLive,
      Layer.mergeAll(BunFileSystem.layer, BunPath.layer, NodeOsTest, withMapConfigProvider(map))
    );

    return Effect.gen(function* () {
      const config = yield* ComposioCliUserConfig;
      assertEquals(config.data.developerModeEnabled, true);
      assertEquals(config.data.developerDangerousCommandsEnabled, false);
      assertEquals(config.data.security, 'auto');

      const persisted = fs.readFileSync(path.join(cwd, '.composio', 'config.json'), 'utf8');
      assertEquals(Array.isArray(JSON.parse(persisted)), false);
    }).pipe(Effect.provide(CliUserConfigTest));
  });
});