@syncular/cli 0.0.0-44

package/src/interactive.tsx

@@ -0,0 +1,306 @@
+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

@@ -0,0 +1,257 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,11 @@
+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

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

package/src/targets/index.ts

@@ -0,0 +1,13 @@
+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',
+  }));
+}