@slates/cli 1.0.0-rc.2

package/src/lib/integration.ts

@@ -0,0 +1,134 @@
+import { access, readFile, readdir } from 'fs/promises';
+import path from 'path';
+import { resolveSlatesCliRoot } from '@slates/profiles';
+
+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 namedPath = path.join(rootDir, 'integrations', input);
+  if (!input.includes(path.sep) && !input.includes('/')) {
+    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 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 integrationsDir = path.join(rootDir, 'integrations');
+
+  if (!(await pathExists(integrationsDir))) {
+    return [];
+  }
+
+  let entries = await readdir(integrationsDir, { withFileTypes: true });
+  let integrations = 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;
+      })
+  );
+
+  return integrations
+    .filter((integration): integration is WorkspaceIntegrationSummary => integration !== null)
+    .sort((a, b) => a.name.localeCompare(b.name));
+};

package/src/lib/oauth.ts

@@ -0,0 +1,136 @@
+import { checkbox } from '@inquirer/prompts';
+import { execFile } from 'child_process';
+import { randomUUID } from 'crypto';
+import { createServer } from 'http';
+import { promisify } from 'util';
+
+let execFileAsync = promisify(execFile);
+let DEFAULT_OAUTH_CALLBACK_PORT = 45873;
+
+export let chooseScopes = async (
+  authMethod: any,
+  initialScopes: string[]
+): Promise<string[]> => {
+  let scopeIds = (authMethod.scopes ?? []).map((scope: any) => scope.id);
+  if (scopeIds.length === 0) {
+    return initialScopes;
+  }
+
+  return (await checkbox({
+    message: 'Choose OAuth scopes',
+    choices: authMethod.scopes.map((scope: any) => ({
+      name: `${scope.title} (${scope.id})`,
+      value: scope.id,
+      checked: initialScopes.length > 0 ? initialScopes.includes(scope.id) : true
+    }))
+  })) as string[];
+};
+
+export let openBrowser = async (url: string) => {
+  try {
+    if (process.platform === 'darwin') {
+      await execFileAsync('open', [url]);
+      return;
+    }
+
+    if (process.platform === 'win32') {
+      await execFileAsync('cmd', ['/c', 'start', '', url]);
+      return;
+    }
+
+    await execFileAsync('xdg-open', [url]);
+  } catch {
+    console.log(`Open this URL in your browser:\n${url}`);
+  }
+};
+
+export let createOAuthCallbackListener = async () => {
+  return new Promise<{
+    redirectUri: string;
+    state: string;
+    wait: () => Promise<{ code: string; state: string }>;
+  }>((resolve, reject) => {
+    let expectedState = randomUUID();
+    let settled = false;
+    let callbackPort = Number(process.env.SLATES_OAUTH_PORT ?? DEFAULT_OAUTH_CALLBACK_PORT);
+
+    let server = createServer((req, res) => {
+      try {
+        let url = new URL(req.url ?? '/', 'http://127.0.0.1');
+        let code = url.searchParams.get('code');
+        let state = url.searchParams.get('state');
+
+        if (!code || !state) {
+          res.statusCode = 400;
+          res.end('Missing code or state.');
+          return;
+        }
+
+        res.end('Authentication complete. You can close this window.');
+        server.close();
+        settled = true;
+        waiter.resolve({ code, state });
+      } catch (error) {
+        server.close();
+        settled = true;
+        waiter.reject(error);
+      }
+    });
+
+    let waiter = (() => {
+      let resolvePromise!: (value: { code: string; state: string }) => void;
+      let rejectPromise!: (error: unknown) => void;
+      let promise = new Promise<{ code: string; state: string }>((resolveFn, rejectFn) => {
+        resolvePromise = resolveFn;
+        rejectPromise = rejectFn;
+      });
+
+      return {
+        promise,
+        resolve: resolvePromise,
+        reject: rejectPromise
+      };
+    })();
+
+    let timeout = setTimeout(
+      () => {
+        if (settled) return;
+        server.close();
+        waiter.reject(new Error('Timed out waiting for the OAuth callback.'));
+      },
+      5 * 60 * 1000
+    );
+
+    server.on('close', () => clearTimeout(timeout));
+    server.on('error', error => {
+      if (settled) return;
+      settled = true;
+
+      let errno = error as NodeJS.ErrnoException;
+      if (errno.code === 'EADDRINUSE') {
+        reject(
+          new Error(
+            `OAuth callback port ${callbackPort} is already in use. Free that port or set SLATES_OAUTH_PORT to a different fixed port.`
+          )
+        );
+        return;
+      }
+
+      reject(error);
+    });
+
+    server.listen(callbackPort, '127.0.0.1', () => {
+      let address = server.address();
+      if (!address || typeof address === 'string') {
+        reject(new Error('Could not determine OAuth callback address.'));
+        return;
+      }
+
+      resolve({
+        redirectUri: `http://127.0.0.1:${address.port}/callback`,
+        state: expectedState,
+        wait: () => waiter.promise
+      });
+    });
+  });
+};

package/src/lib/prompts.ts

@@ -0,0 +1,159 @@
+import { checkbox, confirm, input, password, select } from '@inquirer/prompts';
+import { JsonObject } from './types';
+
+export let prettyJson = (value: unknown) => JSON.stringify(value, null, 2);
+
+export let parseJsonObject = (value: string | undefined, label: string): JsonObject | null => {
+  if (!value) return null;
+
+  let parsed = JSON.parse(value);
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(`${label} must be a JSON object.`);
+  }
+
+  return parsed;
+};
+
+export let parseList = (value: string | undefined) =>
+  (value ?? '')
+    .split(',')
+    .map(item => item.trim())
+    .filter(Boolean);
+
+export let print = (value: unknown) => {
+  console.log(prettyJson(value));
+};
+
+export let promptForString = async (d: {
+  message: string;
+  defaultValue?: string;
+  secret?: boolean;
+}) => {
+  if (d.secret) {
+    return password({
+      message: d.message,
+      mask: '*'
+    });
+  }
+
+  return input({
+    message: d.message,
+    default: d.defaultValue
+  });
+};
+
+export let promptForSchemaValue = async (d: {
+  key: string;
+  schema: any;
+  currentValue?: any;
+  required?: boolean;
+}): Promise<any> => {
+  let schema = d.schema ?? {};
+  let label = schema.title ?? d.key;
+
+  if (schema.enum && Array.isArray(schema.enum) && schema.enum.length > 0) {
+    return select({
+      message: label,
+      default: d.currentValue,
+      choices: schema.enum.map((value: string) => ({
+        name: value,
+        value
+      }))
+    });
+  }
+
+  if (schema.type === 'boolean') {
+    return confirm({
+      message: label,
+      default: d.currentValue ?? false
+    });
+  }
+
+  if (schema.type === 'array') {
+    if (Array.isArray(schema.items?.enum) && schema.items.enum.length > 0) {
+      return checkbox({
+        message: label,
+        choices: schema.items.enum.map((value: string) => ({
+          name: value,
+          value,
+          checked: Array.isArray(d.currentValue) ? d.currentValue.includes(value) : false
+        }))
+      });
+    }
+
+    let raw = await input({
+      message: `${label} (JSON array)`,
+      default: Array.isArray(d.currentValue) ? prettyJson(d.currentValue) : undefined
+    });
+
+    if (!raw.trim()) return [];
+    return JSON.parse(raw);
+  }
+
+  if (schema.type === 'number' || schema.type === 'integer') {
+    let raw = await input({
+      message: label,
+      default: d.currentValue !== undefined ? String(d.currentValue) : undefined
+    });
+
+    if (!raw.trim() && !d.required) return undefined;
+    return Number(raw);
+  }
+
+  if (schema.type === 'object') {
+    let raw = await input({
+      message: `${label} (JSON object)`,
+      default: d.currentValue ? prettyJson(d.currentValue) : '{}'
+    });
+
+    if (!raw.trim()) return {};
+    return JSON.parse(raw);
+  }
+
+  let isSecret = /secret|token|password/i.test(d.key);
+  let raw = await promptForString({
+    message: label,
+    defaultValue: typeof d.currentValue === 'string' ? d.currentValue : undefined,
+    secret: isSecret
+  });
+
+  if (!raw.trim() && !d.required) return undefined;
+  return raw;
+};
+
+export let promptForObjectSchema = async (schema: any, initialValue: JsonObject = {}) => {
+  let properties = schema?.properties ?? {};
+  let required = new Set<string>(schema?.required ?? []);
+  let keys = Object.keys(properties);
+
+  if (keys.length === 0) {
+    if (Object.keys(initialValue).length === 0) {
+      return {};
+    }
+
+    let raw = await input({
+      message: 'Enter JSON object',
+      default: Object.keys(initialValue).length > 0 ? prettyJson(initialValue) : '{}'
+    });
+
+    if (!raw.trim()) return {};
+    return parseJsonObject(raw, 'JSON input') ?? {};
+  }
+
+  let result: JsonObject = { ...initialValue };
+
+  for (let key of keys) {
+    let value = await promptForSchemaValue({
+      key,
+      schema: properties[key],
+      currentValue: initialValue[key],
+      required: required.has(key)
+    });
+
+    if (value !== undefined) {
+      result[key] = value;
+    }
+  }
+
+  return result;
+};

package/src/lib/types.ts

@@ -0,0 +1,10 @@
+export type JsonObject = Record<string, any>;
+
+export type WithProfile = {
+  integration: string;
+  profile?: string;
+};
+
+export type JsonInput = {
+  input?: string;
+};