@syncular/cli 0.0.0-44 → 0.0.0-48

package/src/interactive.tsx

@@ -1,306 +0,0 @@
-import { Box, Text, useApp, useInput } from 'ink';
-import type { ReactElement } from 'react';
-import { useMemo, useState } from 'react';
-import { listInteractiveCommands } from './command-registry';
-import { CLI_NAME, CLI_VERSION } from './constants';
-import type { InteractiveCommand, RootCommand } from './types';
-
-interface InteractiveAppProps {
-  initialCommand: RootCommand | null;
-  allowForms: boolean;
-  onSubmit(argv: string[]): void;
-}
-
-type Screen = 'menu' | 'form';
-
-function parseBooleanInput(value: string): boolean | null {
-  const normalized = value.trim().toLowerCase();
-  if (
-    normalized === 'true' ||
-    normalized === '1' ||
-    normalized === 'yes' ||
-    normalized === 'on'
-  ) {
-    return true;
-  }
-  if (
-    normalized === 'false' ||
-    normalized === '0' ||
-    normalized === 'no' ||
-    normalized === 'off'
-  ) {
-    return false;
-  }
-  return null;
-}
-
-function validateFields(
-  command: InteractiveCommand,
-  values: Record<string, string>
-): string | null {
-  for (const field of command.fields ?? []) {
-    const value = values[field.id] ?? '';
-    if (field.required && value.trim().length === 0) {
-      return `${field.label} is required.`;
-    }
-
-    if (field.kind === 'number' && value.trim().length > 0) {
-      const parsed = Number(value.trim());
-      if (!Number.isFinite(parsed)) {
-        return `${field.label} must be a number.`;
-      }
-    }
-
-    if (field.kind === 'boolean' && value.trim().length > 0) {
-      if (parseBooleanInput(value) === null) {
-        return `${field.label} must be true/false, yes/no, on/off, or 1/0.`;
-      }
-    }
-  }
-  return null;
-}
-
-export function InteractiveApp(props: InteractiveAppProps): ReactElement {
-  const { exit } = useApp();
-  const commands = useMemo(
-    () => listInteractiveCommands(props.initialCommand),
-    [props.initialCommand]
-  );
-  const [screen, setScreen] = useState<Screen>('menu');
-  const [selectedIndex, setSelectedIndex] = useState(0);
-  const [activeCommand, setActiveCommand] = useState<InteractiveCommand | null>(
-    null
-  );
-  const [activeFieldIndex, setActiveFieldIndex] = useState(0);
-  const [fieldValues, setFieldValues] = useState<Record<string, string>>({});
-  const [hint, setHint] = useState<string | null>(null);
-
-  const submitArgv = (argv: string[] | null): void => {
-    if (!argv) {
-      exit();
-      return;
-    }
-    props.onSubmit(argv);
-    exit();
-  };
-
-  const startForm = (command: InteractiveCommand): void => {
-    const initialValues: Record<string, string> = {};
-    for (const field of command.fields ?? []) {
-      initialValues[field.id] = field.defaultValue ?? '';
-    }
-    setActiveCommand(command);
-    setActiveFieldIndex(0);
-    setFieldValues(initialValues);
-    setHint(null);
-    setScreen('form');
-  };
-
-  const submitForm = (): void => {
-    if (!activeCommand) {
-      return;
-    }
-
-    const validationError = validateFields(activeCommand, fieldValues);
-    if (validationError) {
-      setHint(validationError);
-      return;
-    }
-
-    submitArgv(activeCommand.buildArgv(fieldValues));
-  };
-
-  useInput((input, key) => {
-    if (input.toLowerCase() === 'q') {
-      exit();
-      return;
-    }
-
-    if (screen === 'menu') {
-      if (key.upArrow) {
-        setSelectedIndex((index) =>
-          index === 0 ? commands.length - 1 : index - 1
-        );
-        return;
-      }
-
-      if (key.downArrow) {
-        setSelectedIndex((index) =>
-          index === commands.length - 1 ? 0 : index + 1
-        );
-        return;
-      }
-
-      if (!key.return) {
-        return;
-      }
-
-      const selected = commands[selectedIndex];
-      if (!selected) {
-        return;
-      }
-
-      if ((selected.fields?.length ?? 0) === 0) {
-        submitArgv(selected.buildArgv({}));
-        return;
-      }
-
-      if (!props.allowForms) {
-        submitArgv(selected.buildArgv({}));
-        return;
-      }
-
-      startForm(selected);
-      return;
-    }
-
-    if (!activeCommand || screen !== 'form') {
-      return;
-    }
-
-    if (key.escape) {
-      setScreen('menu');
-      setActiveCommand(null);
-      setHint(null);
-      return;
-    }
-
-    const fields = activeCommand.fields ?? [];
-    if (fields.length === 0) {
-      submitArgv(activeCommand.buildArgv(fieldValues));
-      return;
-    }
-
-    const activeField = fields[activeFieldIndex];
-    if (!activeField) {
-      return;
-    }
-
-    if (key.upArrow) {
-      setActiveFieldIndex((index) =>
-        index === 0 ? fields.length - 1 : index - 1
-      );
-      return;
-    }
-
-    if (key.downArrow || key.tab) {
-      setActiveFieldIndex((index) =>
-        index === fields.length - 1 ? 0 : index + 1
-      );
-      return;
-    }
-
-    if (key.ctrl && input.toLowerCase() === 'r') {
-      submitForm();
-      return;
-    }
-
-    if (key.backspace || key.delete) {
-      setFieldValues((current) => ({
-        ...current,
-        [activeField.id]: (current[activeField.id] ?? '').slice(0, -1),
-      }));
-      setHint(null);
-      return;
-    }
-
-    if (key.return) {
-      if (activeFieldIndex === fields.length - 1) {
-        submitForm();
-      } else {
-        setActiveFieldIndex((index) => index + 1);
-      }
-      return;
-    }
-
-    if (!input || key.ctrl || key.meta) {
-      return;
-    }
-
-    setFieldValues((current) => ({
-      ...current,
-      [activeField.id]: `${current[activeField.id] ?? ''}${input}`,
-    }));
-    setHint(null);
-  });
-
-  return (
-    <Box flexDirection="column">
-      <Box borderStyle="round" borderColor="cyan" paddingX={1} paddingY={0}>
-        <Text color="cyanBright">
-          {CLI_NAME} interactive {`v${CLI_VERSION}`}
-        </Text>
-      </Box>
-      <Text color="gray">
-        {screen === 'menu'
-          ? props.allowForms
-            ? 'Up/Down: select  Enter: open form  q: quit'
-            : 'Up/Down: select  Enter: run  q: quit  (use --forms for input forms)'
-          : 'Type to edit  Up/Down: field  Enter: next/run  Ctrl+R: run  Esc: back'}
-      </Text>
-      <Box marginTop={1}>
-        {screen === 'menu' ? (
-          <Box flexDirection="column" width={88}>
-            {commands.map((command, index) => {
-              const active = index === selectedIndex;
-              return (
-                <Box key={command.id}>
-                  <Text color={active ? 'greenBright' : undefined}>
-                    {active ? '> ' : '  '}
-                    {command.label.padEnd(18)}
-                  </Text>
-                  <Text color={active ? 'white' : 'gray'}>
-                    {command.description}
-                  </Text>
-                </Box>
-              );
-            })}
-          </Box>
-        ) : (
-          <Box
-            flexDirection="column"
-            borderStyle="single"
-            borderColor="green"
-            paddingX={1}
-            paddingY={0}
-            width={88}
-          >
-            <Text color="greenBright">{activeCommand?.label}</Text>
-            <Box marginTop={1} flexDirection="column">
-              {(activeCommand?.fields ?? []).map((field, index) => {
-                const active = index === activeFieldIndex;
-                const value = fieldValues[field.id] ?? '';
-                const required = field.required ? ' *' : '';
-                return (
-                  <Box key={field.id}>
-                    <Text color={active ? 'yellowBright' : 'cyan'}>
-                      {active ? '> ' : '  '}
-                      {field.label}
-                      {required}:{' '}
-                    </Text>
-                    <Text color={value.length > 0 ? 'white' : 'gray'}>
-                      {value.length > 0
-                        ? value
-                        : (field.placeholder ?? field.defaultValue ?? '')}
-                    </Text>
-                  </Box>
-                );
-              })}
-            </Box>
-            <Box marginTop={1}>
-              <Text color="gray">
-                command:{' '}
-                {(activeCommand?.buildArgv(fieldValues) ?? ['']).join(' ')}
-              </Text>
-            </Box>
-            {hint ? (
-              <Box marginTop={1}>
-                <Text color="redBright">{hint}</Text>
-              </Box>
-            ) : null}
-          </Box>
-        )}
-      </Box>
-    </Box>
-  );
-}

package/src/main.tsx

@@ -1,257 +0,0 @@
-import process from 'node:process';
-import { render } from 'ink';
-import { parseArgs, shouldRunInteractive } from './args';
-import { runLogin, runLogout, runWhoAmI } from './commands/auth';
-import { runBuild, runEject } from './commands/build';
-import { runConsole } from './commands/console';
-import {
-  runCreateSpace,
-  runDeploy,
-  runDeployments,
-  runRollback,
-  runVerify,
-} from './commands/demo';
-import { runDoctor } from './commands/doctor';
-import { runMigrateStatus, runMigrateUp } from './commands/migrate';
-import { runCreate, runDev } from './commands/project';
-import { runTarget } from './commands/target';
-import { runTypegen } from './commands/typegen';
-import { printHelp } from './help';
-import { InteractiveApp } from './interactive';
-import { printError, printHeader } from './output';
-import type { ParsedArgs } from './types';
-
-type CommandRunner = (flagValues: Map<string, string>) => Promise<number>;
-type LogError = (message: string) => void;
-
-export interface NonInteractiveHandlers {
-  printHelp: () => void;
-  printHeader: () => void;
-  printError: LogError;
-  runDoctor: () => Promise<number>;
-  runConsole: CommandRunner;
-  runLogin: CommandRunner;
-  runLogout: CommandRunner;
-  runWhoAmI: CommandRunner;
-  runCreateSpace: CommandRunner;
-  runCreate: CommandRunner;
-  runDev: CommandRunner;
-  runTypegen: CommandRunner;
-  runMigrateStatus: CommandRunner;
-  runMigrateUp: CommandRunner;
-  runBuild: CommandRunner;
-  runEject: CommandRunner;
-  runTarget: CommandRunner;
-  runDeploy: CommandRunner;
-  runVerify: CommandRunner;
-  runDeployments: CommandRunner;
-  runRollback: CommandRunner;
-}
-
-const defaultNonInteractiveHandlers: NonInteractiveHandlers = {
-  printHelp,
-  printHeader,
-  printError,
-  runDoctor,
-  runConsole,
-  runLogin,
-  runLogout,
-  runWhoAmI,
-  runCreateSpace,
-  runCreate,
-  runDev,
-  runTypegen,
-  runMigrateStatus,
-  runMigrateUp,
-  runBuild,
-  runEject,
-  runTarget,
-  runDeploy,
-  runVerify,
-  runDeployments,
-  runRollback,
-};
-
-interface RootRoute {
-  command:
-    | 'doctor'
-    | 'console'
-    | 'login'
-    | 'logout'
-    | 'whoami'
-    | 'create-space'
-    | 'create'
-    | 'dev'
-    | 'typegen'
-    | 'migrate-status'
-    | 'migrate-up'
-    | 'build'
-    | 'eject'
-    | 'target'
-    | 'deploy'
-    | 'verify'
-    | 'deployments'
-    | 'rollback';
-  run(
-    handlers: NonInteractiveHandlers,
-    flagValues: Map<string, string>
-  ): Promise<number>;
-}
-
-const ROOT_ROUTES: RootRoute[] = [
-  { command: 'doctor', run: (handlers) => handlers.runDoctor() },
-  { command: 'console', run: (handlers, flags) => handlers.runConsole(flags) },
-  { command: 'login', run: (handlers, flags) => handlers.runLogin(flags) },
-  { command: 'logout', run: (handlers, flags) => handlers.runLogout(flags) },
-  { command: 'whoami', run: (handlers, flags) => handlers.runWhoAmI(flags) },
-  {
-    command: 'create-space',
-    run: (handlers, flags) => handlers.runCreateSpace(flags),
-  },
-  { command: 'create', run: (handlers, flags) => handlers.runCreate(flags) },
-  { command: 'dev', run: (handlers, flags) => handlers.runDev(flags) },
-  { command: 'typegen', run: (handlers, flags) => handlers.runTypegen(flags) },
-  {
-    command: 'migrate-status',
-    run: (handlers, flags) => handlers.runMigrateStatus(flags),
-  },
-  {
-    command: 'migrate-up',
-    run: (handlers, flags) => handlers.runMigrateUp(flags),
-  },
-  { command: 'build', run: (handlers, flags) => handlers.runBuild(flags) },
-  { command: 'eject', run: (handlers, flags) => handlers.runEject(flags) },
-  { command: 'target', run: (handlers, flags) => handlers.runTarget(flags) },
-  { command: 'deploy', run: (handlers, flags) => handlers.runDeploy(flags) },
-  { command: 'verify', run: (handlers, flags) => handlers.runVerify(flags) },
-  {
-    command: 'deployments',
-    run: (handlers, flags) => handlers.runDeployments(flags),
-  },
-  {
-    command: 'rollback',
-    run: (handlers, flags) => handlers.runRollback(flags),
-  },
-];
-
-function findRootRoute(command: ParsedArgs['command']): RootRoute | null {
-  return ROOT_ROUTES.find((route) => route.command === command) ?? null;
-}
-
-export async function runNonInteractive(
-  args: ParsedArgs,
-  handlers: NonInteractiveHandlers = defaultNonInteractiveHandlers
-): Promise<number> {
-  if (args.flags.has('--help')) {
-    handlers.printHelp();
-    return 0;
-  }
-
-  if (args.flags.has('--version')) {
-    handlers.printHeader();
-    return 0;
-  }
-
-  if (args.command === 'help') {
-    handlers.printHelp();
-    return 0;
-  }
-
-  if (args.command === 'version') {
-    handlers.printHeader();
-    return 0;
-  }
-
-  const rootRoute = findRootRoute(args.command);
-  if (rootRoute) {
-    if (args.subcommand !== null) {
-      handlers.printError(
-        `Unexpected positional argument for "${rootRoute.command}": ${args.subcommand}`
-      );
-      handlers.printHelp();
-      return 1;
-    }
-    return rootRoute.run(handlers, args.flagValues);
-  }
-
-  if (args.command === 'interactive') {
-    handlers.printError('Interactive mode requires a TTY.');
-    return 1;
-  }
-
-  if (args.command === null && args.positionals.length > 0) {
-    handlers.printError(`Unknown command: ${args.positionals[0]}`);
-    handlers.printHelp();
-    return 1;
-  }
-
-  handlers.printHelp();
-  return 0;
-}
-
-async function runInteractive(
-  initialCommand: ParsedArgs['command'],
-  allowForms: boolean
-): Promise<string[] | null> {
-  return new Promise((resolve) => {
-    let settled = false;
-    const app = render(
-      <InteractiveApp
-        initialCommand={initialCommand}
-        allowForms={allowForms}
-        onSubmit={(argv) => {
-          if (settled) {
-            return;
-          }
-          settled = true;
-          resolve(argv);
-          app.unmount();
-        }}
-      />
-    );
-
-    void app.waitUntilExit().then(() => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      resolve(null);
-    });
-  });
-}
-
-export async function main(): Promise<void> {
-  const argv = process.argv.slice(2);
-  let args = parseArgs(argv);
-
-  const helpOrVersionRequested =
-    args.flags.has('--help') ||
-    args.flags.has('--version') ||
-    args.command === 'help' ||
-    args.command === 'version';
-
-  const interactiveRequested =
-    args.flags.has('--interactive') ||
-    args.command === 'interactive' ||
-    (args.command === null && args.positionals.length === 0) ||
-    (args.command === 'create' && !args.flagValues.has('--template'));
-
-  if (
-    !helpOrVersionRequested &&
-    interactiveRequested &&
-    shouldRunInteractive(args)
-  ) {
-    const selectedArgv = await runInteractive(
-      args.command,
-      args.flags.has('--forms')
-    );
-    if (selectedArgv === null) {
-      process.exit(0);
-    }
-
-    args = parseArgs(selectedArgv);
-  }
-
-  const exitCode = await runNonInteractive(args);
-  process.exit(exitCode);
-}

package/src/output.tsx

@@ -1,47 +0,0 @@
-import process from 'node:process';
-import { Box, renderToString, Text } from 'ink';
-import type { ReactElement } from 'react';
-import { CLI_NAME, CLI_VERSION } from './constants';
-
-function printInk(view: ReactElement): void {
-  const rendered = renderToString(view, {
-    columns: Math.max(process.stdout.columns ?? 120, 120),
-  });
-  process.stdout.write(rendered);
-  if (!rendered.endsWith('\n')) {
-    process.stdout.write('\n');
-  }
-}
-
-export function printHeader(): void {
-  printInk(
-    <Text color="cyanBright" bold>
-      {CLI_NAME} CLI v{CLI_VERSION}
-    </Text>
-  );
-}
-
-export function printInfo(message: string): void {
-  printInk(
-    <Box>
-      <Text color="cyan">info </Text>
-      <Text>{message}</Text>
-    </Box>
-  );
-}
-
-export function printError(message: string): void {
-  const rendered = renderToString(
-    <Box>
-      <Text color="redBright">error </Text>
-      <Text>{message}</Text>
-    </Box>,
-    {
-      columns: Math.max(process.stderr.columns ?? 120, 120),
-    }
-  );
-  process.stderr.write(rendered);
-  if (!rendered.endsWith('\n')) {
-    process.stderr.write('\n');
-  }
-}

package/src/paths.ts

@@ -1,11 +0,0 @@
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-export function resolveRepoRoot(): string {
-  const commandDir = dirname(fileURLToPath(import.meta.url));
-  return resolve(commandDir, '..', '..', '..');
-}
-
-export function resolveDefaultSyncularConfigPath(cwd: string): string {
-  return resolve(cwd, 'syncular.config.ts');
-}

package/src/spaces-config.ts

@@ -1,2 +0,0 @@
-export const DEFAULT_CONTROL_PLANE_API_BASE =
-  'https://api.spaces.syncular.dev/api/control';

package/src/targets/index.ts

@@ -1,13 +0,0 @@
-import { listTargetIds } from './state';
-import type { TargetDefinition } from './types';
-
-export * from './state';
-export * from './types';
-
-export function listTargetDefinitions(): TargetDefinition[] {
-  return listTargetIds().map((id) => ({
-    id,
-    description: 'Managed deploys for Spaces.',
-    defaultBuildpackId: 'contract-worker',
-  }));
-}