@slates/cli 1.0.0-rc.10

package/src/commands/repl.ts

@@ -0,0 +1,95 @@
+import { input } from '@inquirer/prompts';
+import { print } from '../lib/prompts';
+import type { 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,94 @@
+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 type { 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,
+        rootDir: store.rootDir,
+        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_ROOT_DIR: store.rootDir,
+      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 type { 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,199 @@
+import { select } from '@inquirer/prompts';
+import type { SlatesProtocolClient } from '@slates/client';
+import {
+  createSlatesClientFromProfile,
+  openSlatesCliStore,
+  type SlatesCliStore,
+  type SlatesProfileRecord
+} 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;
+  autoRefresh?: boolean;
+}) => {
+  let { integration, store, profile } = await chooseProfile(opts);
+  let client = await createSlatesClientFromProfile(profile, {
+    store,
+    autoRefresh: opts.autoRefresh
+  });
+  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,84 @@
+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'
+    ]);
+  });
+});

package/src/lib/integration.ts

@@ -0,0 +1,152 @@
+import { resolveSlatesCliRoot } from '@slates/profiles';
+import { access, readdir, readFile } from 'fs/promises';
+import path from 'path';
+
+export interface ResolvedIntegration {
+  input: string;
+  rootDir: string;
+  dirPath: string;
+  relativeDir: string;
+  name: string;
+  entry: string;
+}
+
+export interface WorkspaceIntegrationSummary {
+  rootDir: string;
+  dirPath: string;
+  relativeDir: string;
+  name: string;
+}
+
+let toPosixPath = (value: string) => value.replace(/\\/g, '/');
+
+let pathExists = async (targetPath: string) => {
+  try {
+    await access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+let isWithinRoot = (rootDir: string, targetPath: string) => {
+  let relative = path.relative(rootDir, targetPath);
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+};
+
+let resolveIntegrationDir = async (input: string, cwd: string) => {
+  let rootDir = resolveSlatesCliRoot(cwd);
+  let integrationRoots = [
+    path.join(rootDir, 'integrations'),
+    path.join(rootDir, 'test-integrations')
+  ];
+
+  if (!input.includes(path.sep) && !input.includes('/')) {
+    for (let root of integrationRoots) {
+      let namedPath = path.join(root, input);
+      if (await pathExists(path.join(namedPath, 'package.json'))) {
+        return { rootDir, dirPath: namedPath };
+      }
+    }
+  }
+
+  let candidate = path.resolve(cwd, input);
+  if (!(await pathExists(path.join(candidate, 'package.json')))) {
+    throw new Error(
+      `Could not resolve integration "${input}". Pass an integration name from \`integrations/\` or \`test-integrations/\`, or a relative path to an integration directory.`
+    );
+  }
+
+  if (!isWithinRoot(rootDir, candidate)) {
+    throw new Error(`Integration "${input}" must be inside the current repository.`);
+  }
+
+  return { rootDir, dirPath: candidate };
+};
+
+let resolveDefaultEntry = async (dirPath: string) => {
+  let packageJsonPath = path.join(dirPath, 'package.json');
+  let manifest = JSON.parse(await readFile(packageJsonPath, 'utf-8')) as {
+    main?: string;
+    source?: string;
+  };
+
+  let candidates = [
+    manifest.source,
+    manifest.main,
+    'src/index.ts',
+    'src/index.js',
+    'index.ts',
+    'index.js'
+  ].filter((candidate): candidate is string => Boolean(candidate));
+
+  for (let candidate of candidates) {
+    if (await pathExists(path.join(dirPath, candidate))) {
+      return candidate;
+    }
+  }
+
+  throw new Error(`Could not determine a default entry file for integration at ${dirPath}.`);
+};
+
+export let resolveIntegration = async (
+  input: string,
+  opts: { cwd?: string } = {}
+): Promise<ResolvedIntegration> => {
+  let cwd = opts.cwd ?? process.cwd();
+  let { rootDir, dirPath } = await resolveIntegrationDir(input, cwd);
+  let relativeDir = path.relative(rootDir, dirPath);
+
+  return {
+    input,
+    rootDir,
+    dirPath,
+    relativeDir: toPosixPath(relativeDir),
+    name: path.basename(dirPath),
+    entry: toPosixPath(path.join(relativeDir, await resolveDefaultEntry(dirPath)))
+  };
+};
+
+export let listWorkspaceIntegrations = async (opts: { cwd?: string } = {}) => {
+  let cwd = opts.cwd ?? process.cwd();
+  let rootDir = resolveSlatesCliRoot(cwd);
+  let integrationRoots = [
+    path.join(rootDir, 'integrations'),
+    path.join(rootDir, 'test-integrations')
+  ];
+
+  let integrations: WorkspaceIntegrationSummary[] = [];
+
+  for (let integrationsDir of integrationRoots) {
+    if (!(await pathExists(integrationsDir))) {
+      continue;
+    }
+
+    let entries = await readdir(integrationsDir, { withFileTypes: true });
+    let chunk = await Promise.all(
+      entries
+        .filter(entry => entry.isDirectory())
+        .map(async entry => {
+          let dirPath = path.join(integrationsDir, entry.name);
+          if (!(await pathExists(path.join(dirPath, 'package.json')))) {
+            return null;
+          }
+
+          return {
+            rootDir,
+            dirPath,
+            relativeDir: toPosixPath(path.relative(rootDir, dirPath)),
+            name: entry.name
+          } satisfies WorkspaceIntegrationSummary;
+        })
+    );
+
+    integrations.push(
+      ...chunk.filter(
+        (integration): integration is WorkspaceIntegrationSummary => integration !== null
+      )
+    );
+  }
+
+  return integrations.sort((a, b) => a.relativeDir.localeCompare(b.relativeDir));
+};