@syncular/cli 0.0.0-102 → 0.0.0-113

package/src/main.tsx

@@ -1,268 +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';
-import { maybeNotifyAboutUpdate } from './update-check';
-
-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 finalHelpOrVersionRequested =
-    args.flags.has('--help') ||
-    args.flags.has('--version') ||
-    args.command === 'help' ||
-    args.command === 'version';
-
-  if (!finalHelpOrVersionRequested) {
-    await maybeNotifyAboutUpdate(args.flags);
-  }
-
-  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',
-  }));
-}

package/src/targets/state.ts

@@ -1,99 +0,0 @@
-import { existsSync } from 'node:fs';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import { resolveDefaultSyncularConfigPath } from '../paths';
-import type { TargetId } from './types';
-import { TARGET_IDS } from './types';
-
-const TARGET_STATE_RELATIVE_PATH = '.syncular/target.json';
-const DEFAULT_TARGET_ID: TargetId = 'spaces';
-
-interface StoredTargetState {
-  target: TargetId;
-}
-
-export function listTargetIds(): readonly TargetId[] {
-  return TARGET_IDS;
-}
-
-export function isTargetId(value: string): value is TargetId {
-  return TARGET_IDS.includes(value as TargetId);
-}
-
-export function resolveTargetStatePath(cwd: string): string {
-  return resolve(cwd, TARGET_STATE_RELATIVE_PATH);
-}
-
-export async function readStoredTargetId(
-  cwd: string
-): Promise<TargetId | null> {
-  const statePath = resolveTargetStatePath(cwd);
-  if (!existsSync(statePath)) {
-    return null;
-  }
-
-  try {
-    const raw = await readFile(statePath, 'utf8');
-    const parsed = JSON.parse(raw) as Partial<StoredTargetState>;
-    if (typeof parsed.target !== 'string' || !isTargetId(parsed.target)) {
-      return null;
-    }
-    return parsed.target;
-  } catch {
-    return null;
-  }
-}
-
-export async function writeStoredTargetId(args: {
-  cwd: string;
-  targetId: TargetId;
-}): Promise<string> {
-  const statePath = resolveTargetStatePath(args.cwd);
-  await mkdir(resolve(args.cwd, '.syncular'), { recursive: true });
-  await writeFile(
-    statePath,
-    `${JSON.stringify({ target: args.targetId } satisfies StoredTargetState, null, 2)}\n`,
-    'utf8'
-  );
-  return statePath;
-}
-
-export async function resolveEffectiveTargetId(args: {
-  cwd: string;
-  explicitTargetId: string | null;
-}): Promise<{
-  source: 'flag' | 'state' | 'default';
-  targetId: TargetId;
-}> {
-  if (args.explicitTargetId) {
-    if (!isTargetId(args.explicitTargetId)) {
-      throw new Error(
-        `Unsupported --target "${args.explicitTargetId}". Supported targets: ${TARGET_IDS.join(', ')}.`
-      );
-    }
-    return {
-      source: 'flag',
-      targetId: args.explicitTargetId,
-    };
-  }
-
-  const storedTargetId = await readStoredTargetId(args.cwd);
-  if (storedTargetId) {
-    return {
-      source: 'state',
-      targetId: storedTargetId,
-    };
-  }
-
-  return {
-    source: 'default',
-    targetId: DEFAULT_TARGET_ID,
-  };
-}
-
-export function resolveTargetDefaultConfigPath(args: {
-  cwd: string;
-  targetId: TargetId;
-}): string {
-  return resolveDefaultSyncularConfigPath(args.cwd);
-}

package/src/targets/types.ts

@@ -1,8 +0,0 @@
-export const TARGET_IDS = ['spaces'] as const;
-export type TargetId = (typeof TARGET_IDS)[number];
-
-export interface TargetDefinition {
-  id: TargetId;
-  description: string;
-  defaultBuildpackId: 'contract-worker';
-}

package/src/templates/index.ts

@@ -1,2 +0,0 @@
-export * from './registry';
-export * from './syncular-types';

package/src/templates/registry.ts

@@ -1,42 +0,0 @@
-import { TEMPLATE_EXTENSION_MANIFEST } from '../extensions';
-
-type TemplateManifest = typeof TEMPLATE_EXTENSION_MANIFEST;
-function buildTemplateRegistry(manifest: TemplateManifest) {
-  const entries = Object.entries(manifest);
-  const seenTemplateIds = new Set<string>();
-
-  for (const [registryKey, manifestEntry] of entries) {
-    const templateId = manifestEntry.template.id;
-    if (templateId.length === 0) {
-      throw new Error(`Template "${registryKey}" has an empty id.`);
-    }
-
-    if (seenTemplateIds.has(templateId)) {
-      throw new Error(`Duplicate template id in manifest: "${templateId}".`);
-    }
-    seenTemplateIds.add(templateId);
-  }
-
-  return Object.freeze(
-    Object.fromEntries(
-      entries.map(([registryKey, manifestEntry]) => [
-        registryKey,
-        manifestEntry.template,
-      ])
-    )
-  ) as {
-    [K in keyof TemplateManifest]: TemplateManifest[K]['template'];
-  };
-}
-
-export const templateRegistry = buildTemplateRegistry(
-  TEMPLATE_EXTENSION_MANIFEST
-);
-
-const TEMPLATE_IDS = Object.freeze(
-  Object.values(templateRegistry).map((template) => template.id)
-) as readonly string[];
-
-export function listTemplateIds(): readonly string[] {
-  return TEMPLATE_IDS;
-}

package/src/templates/syncular-types.ts

@@ -1,10 +0,0 @@
-export type {
-  SyncularClientDialect,
-  SyncularElectronDialect,
-  SyncularLibrariesTarget,
-  SyncularServerDialect,
-} from '@syncular/cli-template-syncular-libraries';
-export {
-  DEFAULT_SYNCULAR_LIBRARIES_TARGETS,
-  SYNCULAR_LIBRARIES_TARGETS,
-} from '@syncular/cli-template-syncular-libraries';

package/src/types.ts

@@ -1,67 +0,0 @@
-export type RootCommand =
-  | 'help'
-  | 'version'
-  | 'doctor'
-  | 'console'
-  | 'login'
-  | 'logout'
-  | 'whoami'
-  | 'create-space'
-  | 'create'
-  | 'dev'
-  | 'typegen'
-  | 'migrate-status'
-  | 'migrate-up'
-  | 'build'
-  | 'eject'
-  | 'target'
-  | 'deploy'
-  | 'verify'
-  | 'rollback'
-  | 'deployments'
-  | 'interactive';
-
-export interface ParsedArgs {
-  command: RootCommand | null;
-  subcommand: string | null;
-  flags: Set<string>;
-  flagValues: Map<string, string>;
-  positionals: string[];
-}
-
-export interface InteractiveField {
-  id: string;
-  label: string;
-  kind?: 'string' | 'number' | 'boolean';
-  placeholder?: string;
-  required?: boolean;
-  defaultValue?: string;
-}
-
-export interface InteractiveCommand {
-  id:
-    | 'doctor'
-    | 'console'
-    | 'create'
-    | 'create-space'
-    | 'dev'
-    | 'typegen'
-    | 'migrate-status'
-    | 'migrate-up'
-    | 'build'
-    | 'eject'
-    | 'target'
-    | 'deploy'
-    | 'verify'
-    | 'deployments'
-    | 'rollback'
-    | 'login'
-    | 'logout'
-    | 'whoami'
-    | 'help'
-    | 'quit';
-  label: string;
-  description: string;
-  fields?: InteractiveField[];
-  buildArgv(values: Record<string, string>): string[] | null;
-}