@slates/cli 1.0.0-rc.10

package/src/lib/oauth.ts

@@ -0,0 +1,162 @@
+import { checkbox } from '@inquirer/prompts';
+import { randomUUID } from 'crypto';
+import { createServer } from 'http';
+
+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)
+          : (scope.defaultChecked ?? true)
+    }))
+  })) as string[];
+};
+
+export let printBrowserUrl = (url: string) => {
+  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;
+      callbackParams: Record<string, 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');
+        let oauthError = url.searchParams.get('error');
+        let oauthErrorDescription = url.searchParams.get('error_description');
+        let oauthErrorUri = url.searchParams.get('error_uri');
+
+        if (oauthError) {
+          let description = oauthErrorDescription ?? 'No error description was provided.';
+          let errorMessage = `OAuth callback returned "${oauthError}": ${description}${
+            oauthErrorUri ? ` (${oauthErrorUri})` : ''
+          }`;
+
+          res.statusCode = 400;
+          res.end(errorMessage);
+          server.close();
+          settled = true;
+          waiter.reject(new Error(errorMessage));
+          return;
+        }
+
+        if (!code || !state) {
+          res.statusCode = 400;
+          res.end('Missing code or state.');
+          server.close();
+          settled = true;
+          waiter.reject(
+            new Error(
+              `OAuth callback did not include the required query parameters. Received path: ${url.pathname}${url.search}`
+            )
+          );
+          return;
+        }
+
+        res.end('Authentication complete. You can close this window.');
+        server.close();
+        settled = true;
+        waiter.resolve({
+          code,
+          state,
+          callbackParams: Object.fromEntries(url.searchParams.entries())
+        });
+      } catch (error) {
+        server.close();
+        settled = true;
+        waiter.reject(error);
+      }
+    });
+
+    let waiter = (() => {
+      let resolvePromise!: (value: {
+        code: string;
+        state: string;
+        callbackParams: Record<string, string>;
+      }) => void;
+      let rejectPromise!: (error: unknown) => void;
+      let promise = new Promise<{
+        code: string;
+        state: string;
+        callbackParams: Record<string, 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 type { 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;
+};