@slates/cli 1.0.0-rc.2

package/src/commands/config.ts

@@ -0,0 +1,31 @@
+import { createClientContext } from '../lib/context';
+import { parseJsonObject, promptForObjectSchema } from '../lib/prompts';
+import { JsonInput, WithProfile } from '../lib/types';
+
+export let getConfig = async (opts: WithProfile) => {
+  let { profile } = await createClientContext(opts);
+  return profile.config;
+};
+
+export let getConfigSchema = async (opts: WithProfile) => {
+  let { client } = await createClientContext(opts);
+  return client.getConfigSchema();
+};
+
+export let setConfig = async (opts: WithProfile & JsonInput) => {
+  let { store, profile, client } = await createClientContext(opts);
+  let previousConfig = profile.config;
+  let schema = (await client.getConfigSchema()).schema;
+  let defaultConfig = (await client.getDefaultConfig()).config ?? {};
+  let desiredConfig =
+    parseJsonObject(opts.input, 'config input') ??
+    (await promptForObjectSchema(schema, previousConfig ?? defaultConfig));
+  let result = await client.updateConfig(previousConfig, desiredConfig);
+  let finalConfig = result.config ?? desiredConfig;
+  store.setProfileConfig(profile.id, finalConfig);
+  await store.save();
+  return {
+    ...result,
+    config: finalConfig
+  };
+};

package/src/commands/index.ts

@@ -0,0 +1,6 @@
+export * from './auth';
+export * from './config';
+export * from './profiles';
+export * from './repl';
+export * from './test';
+export * from './tools';

package/src/commands/profiles.ts

@@ -0,0 +1,143 @@
+import { input } from '@inquirer/prompts';
+import { createSlatesClientFromProfile, openSlatesCliStore } from '@slates/profiles';
+import path from 'path';
+import { chooseProfile, openIntegrationStore, syncProfileMetadata } from '../lib/context';
+import { WithProfile } from '../lib/types';
+
+let normalizeEntry = (rootDir: string, entry: string) => {
+  let absolute = path.isAbsolute(entry) ? entry : path.resolve(process.cwd(), entry);
+  let relative = path.relative(rootDir, absolute);
+  return relative && !relative.startsWith('..') && !path.isAbsolute(relative)
+    ? relative
+    : absolute;
+};
+
+let getNextSetupProfileName = async (store: Awaited<ReturnType<typeof openSlatesCliStore>>) => {
+  let names = new Set(store.listProfiles().map(profile => profile.name));
+  if (!names.has('default')) {
+    return 'default';
+  }
+
+  let suffix = 2;
+  while (names.has(`default-${suffix}`)) {
+    suffix += 1;
+  }
+
+  return `default-${suffix}`;
+};
+
+let createProfile = async (
+  opts: WithProfile & {
+    name?: string;
+    entry?: string;
+    exportName?: string;
+    useAsDefault?: boolean;
+    initializeConfig?: boolean;
+    interactive?: boolean;
+  }
+) => {
+  let { integration, store } = await openIntegrationStore(opts.integration);
+  let interactive = opts.interactive ?? true;
+
+  let defaultName =
+    opts.name ??
+    (opts.initializeConfig ? await getNextSetupProfileName(store) : `profile-${store.listProfiles().length + 1}`);
+  let name =
+    opts.name ??
+    (interactive ? await input({ message: 'Profile name', default: defaultName }) : defaultName);
+  let defaultEntry = opts.entry ?? integration.entry;
+  let entry =
+    opts.entry ??
+    (interactive
+      ? await input({
+          message: 'Local slate entry file',
+          default: defaultEntry
+        })
+      : defaultEntry);
+  let exportName =
+    opts.exportName ??
+    (interactive ? await input({ message: 'Export name (optional)', default: 'provider' }) : 'provider');
+
+  let profile = store.upsertProfile({
+    name,
+    target: {
+      type: 'local',
+      entry: normalizeEntry(store.rootDir, entry),
+      exportName: exportName.trim() ? exportName.trim() : undefined
+    }
+  });
+
+  let client = await createSlatesClientFromProfile(profile);
+  await syncProfileMetadata({ store, profile, client });
+
+  if (opts.initializeConfig) {
+    let defaultConfig = (await client.getDefaultConfig()).config ?? {};
+    let result = await client.updateConfig(null, defaultConfig);
+    store.setProfileConfig(profile.id, result.config ?? defaultConfig);
+  }
+
+  if (opts.useAsDefault ?? store.listProfiles().length === 1) {
+    store.setCurrentProfile(profile.id);
+  }
+
+  await store.save();
+
+  return profile;
+};
+
+export let addProfile = async (
+  opts: WithProfile & {
+    name?: string;
+    entry?: string;
+    exportName?: string;
+    useAsDefault?: boolean;
+  }
+) =>
+  createProfile({
+    ...opts,
+    interactive: true
+  });
+
+export let setupIntegration = async (
+  opts: WithProfile & {
+    name?: string;
+    exportName?: string;
+  }
+) =>
+  createProfile({
+    ...opts,
+    useAsDefault: true,
+    initializeConfig: true,
+    interactive: false
+  });
+
+export let listProfiles = async (opts: Pick<WithProfile, 'integration'>) => {
+  let { store } = await openIntegrationStore(opts.integration);
+  let current = store.getProfile();
+  return store.listProfiles().map(profile => ({
+    name: profile.name,
+    id: profile.id,
+    current: profile.id === current?.id,
+    entry: profile.target.type === 'local' ? profile.target.entry : null,
+    authMethods: Object.keys(profile.auth)
+  }));
+};
+
+export let getProfile = async (opts: WithProfile) => {
+  let { store } = await openIntegrationStore(opts.integration);
+  return store.requireProfile(opts.profile);
+};
+
+export let useProfile = async (opts: WithProfile) => {
+  let { store, profile } = await chooseProfile(opts);
+  store.setCurrentProfile(profile.id);
+  await store.save();
+  return profile;
+};
+
+export let removeProfile = async (opts: WithProfile) => {
+  let { store, profile } = await chooseProfile(opts);
+  store.removeProfile(profile.id);
+  await store.save();
+  return profile;
+};

package/src/commands/repl.ts

@@ -0,0 +1,95 @@
+import { input } from '@inquirer/prompts';
+import { print } from '../lib/prompts';
+import { WithProfile } from '../lib/types';
+import { listAuth, setupAuth } from './auth';
+import { getConfig, setConfig } from './config';
+import { getProfile } from './profiles';
+import { callTool, getTool, listTools } from './tools';
+
+let printHelp = () => {
+  console.log(
+    [
+      'Available commands:',
+      '  help',
+      '  tools',
+      '  tool <toolId>',
+      '  call <toolId>',
+      '  auth list',
+      '  auth setup [authMethodId]',
+      '  config get',
+      '  config set',
+      '  profile',
+      '  quit'
+    ].join('\n')
+  );
+};
+
+export let startRepl = async (opts: WithProfile) => {
+  let keepRunning = true;
+  printHelp();
+
+  while (keepRunning) {
+    let commandLine = await input({
+      message: 'slates>'
+    });
+    let [command, ...rest] = commandLine.trim().split(/\s+/).filter(Boolean);
+
+    if (!command) continue;
+
+    switch (command) {
+      case 'exit':
+      case 'quit':
+        keepRunning = false;
+        break;
+
+      case 'help':
+        printHelp();
+        break;
+
+      case 'tools':
+        print(await listTools(opts));
+        break;
+
+      case 'tool':
+        print(await getTool({ ...opts, toolId: rest[0] }));
+        break;
+
+      case 'call':
+        print(await callTool({ ...opts, toolId: rest[0] }));
+        break;
+
+      case 'auth':
+        if (rest[0] === 'list') {
+          print(await listAuth(opts));
+          break;
+        }
+
+        if (rest[0] === 'setup') {
+          print(await setupAuth({ ...opts, authMethodId: rest[1] }));
+          break;
+        }
+
+        throw new Error(`Unsupported auth command: ${rest.join(' ')}`);
+
+      case 'config':
+        if (rest[0] === 'get') {
+          print(await getConfig(opts));
+          break;
+        }
+
+        if (rest[0] === 'set') {
+          print(await setConfig(opts));
+          break;
+        }
+
+        throw new Error(`Unsupported config command: ${rest.join(' ')}`);
+
+      case 'profile':
+        print(await getProfile(opts));
+        break;
+
+      default:
+        throw new Error(`Unknown REPL command: ${command}`);
+    }
+  }
+};

package/src/commands/test.ts

@@ -0,0 +1,92 @@
+import { spawn } from 'child_process';
+import { writeFile } from 'fs/promises';
+import path from 'path';
+import { chooseProfile } from '../lib/context';
+import { listWorkspaceIntegrations } from '../lib/integration';
+import { WithProfile } from '../lib/types';
+
+let runVitest = async (opts: {
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  vitestArgs: string[];
+  label?: string;
+}) => {
+  let command = process.execPath;
+  let args = ['x', 'vitest', 'run', '--passWithNoTests', ...opts.vitestArgs];
+
+  if (opts.label) {
+    console.log(`\n==> ${opts.label}`);
+  }
+
+  await new Promise<void>((resolve, reject) => {
+    let child = spawn(command, args, {
+      cwd: opts.cwd,
+      stdio: 'inherit',
+      env: opts.env
+    });
+
+    child.on('error', reject);
+    child.on('exit', code => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+
+      reject(new Error(`Vitest exited with code ${code ?? 1}.`));
+    });
+  });
+};
+
+export let runVitestWithProfile = async (opts: WithProfile & { vitestArgs: string[] }) => {
+  let { integration, store, profile } = await chooseProfile(opts);
+  let contextPath = path.join(store.dirPath, 'test-runtime.json');
+
+  await writeFile(
+    contextPath,
+    JSON.stringify(
+      {
+        integration: integration.relativeDir,
+        profileId: profile.id,
+        storePath: store.storePath,
+        cliDir: store.dirPath
+      },
+      null,
+      2
+    ) + '\n',
+    'utf-8'
+  );
+
+  await runVitest({
+    cwd: integration.dirPath,
+    vitestArgs: opts.vitestArgs,
+    env: {
+      ...process.env,
+      SLATES_INTEGRATION: integration.relativeDir,
+      SLATES_PROFILE_ID: profile.id,
+      SLATES_CLI_DIR: store.dirPath,
+      SLATES_STORE_PATH: store.storePath,
+      SLATES_TEST_CONTEXT_PATH: contextPath
+    }
+  });
+};
+
+export let runAllIntegrationTests = async (opts: { cwd?: string; vitestArgs: string[] }) => {
+  let integrations = await listWorkspaceIntegrations({ cwd: opts.cwd });
+  if (integrations.length === 0) {
+    throw new Error('No integrations directory was found in the current repository.');
+  }
+
+  for (let integration of integrations) {
+    await runVitest({
+      cwd: integration.dirPath,
+      vitestArgs: opts.vitestArgs,
+      env: process.env,
+      label: integration.relativeDir
+    });
+  }
+
+  return {
+    success: true,
+    count: integrations.length
+  };
+};

package/src/commands/tools.ts

@@ -0,0 +1,57 @@
+import {
+  chooseTool,
+  createClientContext,
+  ensureProfileConfig,
+  syncProfileMetadata
+} from '../lib/context';
+import { parseJsonObject, promptForObjectSchema } from '../lib/prompts';
+import { JsonInput, WithProfile } from '../lib/types';
+
+export let listTools = async (opts: WithProfile) => {
+  let { store, profile, client } = await createClientContext(opts);
+  let tools = await client.listTools();
+  await syncProfileMetadata({ store, profile, client });
+  return tools.map(tool => `${tool.name} (${tool.id})`);
+};
+
+export let getTool = async (opts: WithProfile & { toolId?: string }) => {
+  let { client } = await createClientContext(opts);
+  return chooseTool({ client, toolId: opts.toolId });
+};
+
+export let callTool = async (
+  opts: WithProfile &
+    JsonInput & {
+      toolId?: string;
+      authMethodId?: string;
+    }
+) => {
+  let { store, profile, client } = await createClientContext(opts);
+  let tool = await chooseTool({ client, toolId: opts.toolId });
+
+  await ensureProfileConfig({ store, profile, client });
+
+  let authMethods = (await client.listAuthMethods()).authenticationMethods;
+  let storedAuth = store.getAuth(profile.id, opts.authMethodId);
+  if (!storedAuth && authMethods.length > 0) {
+    throw new Error(
+      `No stored authentication found for this profile. Run \`slates ${opts.integration} auth setup\` first.`
+    );
+  }
+
+  if (storedAuth) {
+    client.setAuth({
+      authenticationMethodId: storedAuth.authMethodId,
+      output: storedAuth.output
+    });
+  }
+
+  let toolInput =
+    parseJsonObject(opts.input, 'tool input') ??
+    (await promptForObjectSchema(tool.inputSchema, {}));
+
+  let result = await client.invokeTool(tool.id, toolInput);
+  store.setProfileSession(profile.id, client.state.session);
+  await store.save();
+  return result;
+};

package/src/lib/context.ts

@@ -0,0 +1,192 @@
+import { select } from '@inquirer/prompts';
+import { SlatesProtocolClient } from '@slates/client';
+import {
+  createSlatesClientFromProfile,
+  openSlatesCliStore,
+  SlatesProfileRecord,
+  type SlatesCliStore
+} from '@slates/profiles';
+import { resolveIntegration } from './integration';
+import { promptForObjectSchema } from './prompts';
+
+export let openIntegrationStore = async (integration: string) => {
+  let resolved = await resolveIntegration(integration);
+  let store = await openSlatesCliStore({
+    cwd: resolved.rootDir,
+    scope: {
+      key: resolved.relativeDir,
+      name: resolved.name
+    }
+  });
+
+  return {
+    integration: resolved,
+    store
+  };
+};
+
+export let chooseProfile = async (d: {
+  integration: string;
+  profile?: string;
+  message?: string;
+}) => {
+  let { integration, store } = await openIntegrationStore(d.integration);
+  if (d.profile) {
+    return {
+      integration,
+      store,
+      profile: store.requireProfile(d.profile)
+    };
+  }
+
+  let profiles = store.listProfiles();
+  if (profiles.length === 0) {
+    throw new Error(
+      `No Slates profiles found for ${integration.name}. Create one with \`slates ${d.integration} setup\`.`
+    );
+  }
+
+  let current = store.getProfile();
+  if (profiles.length === 1) {
+    return {
+      integration,
+      store,
+      profile: profiles[0]!
+    };
+  }
+
+  let profileId = await select({
+    message: d.message ?? 'Choose a profile',
+    default: current?.id,
+    choices: profiles.map(profile => ({
+      name: `${profile.name} (${profile.id})`,
+      value: profile.id
+    }))
+  });
+
+  return {
+    integration,
+    store,
+    profile: store.requireProfile(profileId)
+  };
+};
+
+export let createClientContext = async (opts: { integration: string; profile?: string }) => {
+  let { integration, store, profile } = await chooseProfile(opts);
+  let client = await createSlatesClientFromProfile(profile, { store });
+  return { integration, store, profile, client };
+};
+
+export let createIntegrationClientContext = async (opts: { integration: string }) => {
+  let { integration, store } = await openIntegrationStore(opts.integration);
+  let client = await createSlatesClientFromProfile(
+    {
+      id: `integration-${integration.name}`,
+      name: integration.name,
+      target: {
+        type: 'local',
+        entry: integration.entry,
+        exportName: 'provider'
+      },
+      config: null,
+      auth: {},
+      session: null,
+      metadata: {
+        provider: null,
+        actions: null
+      },
+      createdAt: new Date(0).toISOString(),
+      updatedAt: new Date(0).toISOString()
+    },
+    { store }
+  );
+
+  return { integration, store, client };
+};
+
+export let syncProfileMetadata = async (d: {
+  store: SlatesCliStore;
+  profile: SlatesProfileRecord;
+  client: SlatesProtocolClient;
+}) => {
+  let [provider, actions] = await Promise.all([d.client.identify(), d.client.listActions()]);
+  d.store.setProfileMetadata(d.profile.id, {
+    provider: provider.provider,
+    actions: actions.actions
+  });
+  await d.store.save();
+};
+
+export let ensureProfileConfig = async (d: {
+  store: SlatesCliStore;
+  profile: SlatesProfileRecord;
+  client: SlatesProtocolClient;
+}) => {
+  if (d.profile.config) {
+    d.client.setConfig(d.profile.config);
+    return d.profile.config;
+  }
+
+  let defaultConfig = (await d.client.getDefaultConfig()).config ?? {};
+  let schema = (await d.client.getConfigSchema()).schema;
+  let config = await promptForObjectSchema(schema, defaultConfig);
+  d.store.setProfileConfig(d.profile.id, config);
+  await d.store.save();
+  d.client.setConfig(config);
+  return config;
+};
+
+export let chooseTool = async (d: { client: SlatesProtocolClient; toolId?: string }) => {
+  if (d.toolId) {
+    return d.client.getTool(d.toolId);
+  }
+
+  let tools = await d.client.listTools();
+  if (tools.length === 0) {
+    throw new Error('This slate does not expose any tools.');
+  }
+
+  let toolId = await select({
+    message: 'Choose a tool',
+    choices: tools.map(tool => ({
+      name: `${tool.name} (${tool.id})`,
+      value: tool.id
+    }))
+  });
+
+  return d.client.getTool(toolId);
+};
+
+export let chooseAuthMethod = async (d: {
+  client: SlatesProtocolClient;
+  authMethodId?: string;
+  forcePrompt?: boolean;
+}) => {
+  let methods = (await d.client.listAuthMethods()).authenticationMethods;
+  if (methods.length === 0) {
+    throw new Error('This slate does not expose any authentication methods.');
+  }
+
+  if (d.authMethodId) {
+    let method = methods.find(item => item.id === d.authMethodId);
+    if (!method) {
+      throw new Error(`Unknown auth method: ${d.authMethodId}`);
+    }
+
+    return method;
+  }
+
+  if (methods.length === 1 && !d.forcePrompt) {
+    return methods[0]!;
+  }
+
+  let methodId = await select({
+    message: 'Choose an authentication method',
+    choices: methods.map(method => ({
+      name: `${method.name} (${method.type})`,
+      value: method.id
+    }))
+  });
+
+  return methods.find(method => method.id === methodId)!;
+};

package/src/lib/integration.test.ts

@@ -0,0 +1,76 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import path from 'path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { listWorkspaceIntegrations, resolveIntegration } from './integration';
+
+let tempDirs: string[] = [];
+
+let createTempDir = async () => {
+  let dir = await mkdtemp(path.join(tmpdir(), 'slates-cli-'));
+  tempDirs.push(dir);
+  return dir;
+};
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map(dir => rm(dir, { recursive: true, force: true })));
+});
+
+describe('resolveIntegration', () => {
+  it('resolves an integration by name from the integrations directory', async () => {
+    let cwd = await createTempDir();
+    let integrationDir = path.join(cwd, 'integrations', 'demo');
+    await mkdir(path.join(integrationDir, 'src'), { recursive: true });
+    await writeFile(
+      path.join(integrationDir, 'package.json'),
+      JSON.stringify({ main: 'src/index.ts' }, null, 2),
+      'utf-8'
+    );
+    await writeFile(path.join(integrationDir, 'src', 'index.ts'), 'export let provider = {};\n', 'utf-8');
+
+    let resolved = await resolveIntegration('demo', { cwd });
+
+    expect(resolved.name).toBe('demo');
+    expect(resolved.relativeDir).toBe('integrations/demo');
+    expect(resolved.entry).toBe('integrations/demo/src/index.ts');
+  });
+
+  it('resolves an integration from a relative path', async () => {
+    let cwd = await createTempDir();
+    let integrationDir = path.join(cwd, 'custom', 'demo');
+    await mkdir(path.join(integrationDir, 'src'), { recursive: true });
+    await writeFile(
+      path.join(integrationDir, 'package.json'),
+      JSON.stringify({ source: 'src/index.ts' }, null, 2),
+      'utf-8'
+    );
+    await writeFile(path.join(integrationDir, 'src', 'index.ts'), 'export let provider = {};\n', 'utf-8');
+
+    let resolved = await resolveIntegration('./custom/demo', { cwd });
+
+    expect(resolved.name).toBe('demo');
+    expect(resolved.relativeDir).toBe('custom/demo');
+    expect(resolved.entry).toBe('custom/demo/src/index.ts');
+  });
+
+  it('lists workspace integrations from the integrations directory', async () => {
+    let cwd = await createTempDir();
+    for (let name of ['beta', 'alpha']) {
+      let integrationDir = path.join(cwd, 'integrations', name);
+      await mkdir(integrationDir, { recursive: true });
+      await writeFile(
+        path.join(integrationDir, 'package.json'),
+        JSON.stringify({ main: 'src/index.ts' }, null, 2),
+        'utf-8'
+      );
+    }
+
+    let integrations = await listWorkspaceIntegrations({ cwd });
+
+    expect(integrations.map(integration => integration.name)).toEqual(['alpha', 'beta']);
+    expect(integrations.map(integration => integration.relativeDir)).toEqual([
+      'integrations/alpha',
+      'integrations/beta'
+    ]);
+  });
+});