@syncular/cli 0.0.0-44

package/src/commands/project.ts

@@ -0,0 +1,437 @@
+import { basename, resolve } from 'node:path';
+import process from 'node:process';
+import {
+  runSpaceDev,
+  type SpaceDatabaseProvider,
+  type SpaceDevLogger,
+} from '@syncular/cli-runtime-dev';
+import { CLI_NAME } from '../constants';
+import {
+  configureSpacesDevTelemetry,
+  createSpacesDevLogger,
+} from '../dev-logging';
+import { printError, printInfo } from '../output';
+import {
+  DEFAULT_SYNCULAR_LIBRARIES_TARGETS,
+  listTemplateIds,
+  SYNCULAR_LIBRARIES_TARGETS,
+  type SyncularClientDialect,
+  type SyncularElectronDialect,
+  type SyncularLibrariesTarget,
+  type SyncularServerDialect,
+  templateRegistry,
+} from '../templates';
+
+const DEFAULT_INIT_DIR = 'spaces-app';
+const DEFAULT_DEMO_INIT_DIR = 'spaces-demo';
+const DEFAULT_SYNCULAR_INIT_DIR = '.';
+const DEFAULT_DEV_PORT = 4312;
+const DEFAULT_DEV_HOST = '127.0.0.1';
+const DEFAULT_DEV_CONSOLE_TOKEN = 'spaces-dev-console-token';
+const SUPPORTED_CREATE_TEMPLATES = listTemplateIds();
+
+type CreateTemplateId = string;
+
+function optionalFlag(
+  flagValues: Map<string, string>,
+  flag: string,
+  fallback: string
+): string {
+  const value = flagValues.get(flag)?.trim();
+  return value && value.length > 0 ? value : fallback;
+}
+
+function optionalBooleanFlag(
+  flagValues: Map<string, string>,
+  flag: string,
+  fallback: boolean
+): boolean {
+  const value = flagValues.get(flag);
+  if (!value) {
+    return fallback;
+  }
+
+  const normalized = value.trim().toLowerCase();
+  if (
+    normalized === '1' ||
+    normalized === 'true' ||
+    normalized === 'yes' ||
+    normalized === 'on'
+  ) {
+    return true;
+  }
+
+  if (
+    normalized === '0' ||
+    normalized === 'false' ||
+    normalized === 'no' ||
+    normalized === 'off'
+  ) {
+    return false;
+  }
+
+  throw new Error(
+    `Invalid ${flag} value "${value}". Use true/false, yes/no, on/off, or 1/0.`
+  );
+}
+
+function optionalIntegerFlag(
+  flagValues: Map<string, string>,
+  flag: string,
+  fallback: number
+): number {
+  const raw = flagValues.get(flag)?.trim();
+  if (!raw) {
+    return fallback;
+  }
+
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Invalid ${flag} value: ${raw}`);
+  }
+
+  return parsed;
+}
+
+function parseCreateTemplateId(
+  flagValues: Map<string, string>
+): CreateTemplateId {
+  const rawValue = flagValues.get('--template')?.trim() || '';
+  if (rawValue.length === 0) {
+    return templateRegistry.syncularLibraries.id;
+  }
+
+  for (const templateId of SUPPORTED_CREATE_TEMPLATES) {
+    if (rawValue === templateId) {
+      return templateId;
+    }
+  }
+
+  throw new Error(
+    `Unsupported --template "${rawValue}". Supported templates: ${SUPPORTED_CREATE_TEMPLATES.join(', ')}.`
+  );
+}
+
+function parseSyncularTargets(
+  rawTargets: string | undefined
+): SyncularLibrariesTarget[] | { error: string } {
+  if (!rawTargets) {
+    return [...DEFAULT_SYNCULAR_LIBRARIES_TARGETS];
+  }
+
+  const parsed = rawTargets
+    .split(',')
+    .map((target) => target.trim())
+    .filter((target) => target.length > 0);
+
+  if (parsed.length === 0) {
+    return { error: 'At least one target is required for syncular-libraries.' };
+  }
+
+  const allowed = new Set<string>(SYNCULAR_LIBRARIES_TARGETS);
+  const invalid = parsed.find((target) => !allowed.has(target));
+  if (invalid) {
+    return {
+      error:
+        `Invalid --targets value "${invalid}". ` +
+        `Use: ${SYNCULAR_LIBRARIES_TARGETS.join(', ')}`,
+    };
+  }
+
+  return Array.from(new Set(parsed)) as SyncularLibrariesTarget[];
+}
+
+function parseSyncularServerDialect(
+  value: string | undefined
+): SyncularServerDialect | { error: string } {
+  if (!value || value === 'sqlite') {
+    return 'sqlite';
+  }
+  if (value === 'postgres') {
+    return 'postgres';
+  }
+  return { error: 'Invalid --server-dialect. Use sqlite or postgres.' };
+}
+
+function parseSyncularClientDialect(
+  value: string | undefined,
+  flagName: '--react-dialect' | '--vanilla-dialect'
+): SyncularClientDialect | { error: string } {
+  if (!value || value === 'wa-sqlite') {
+    return 'wa-sqlite';
+  }
+  if (
+    value === 'pglite' ||
+    value === 'bun-sqlite' ||
+    value === 'better-sqlite3' ||
+    value === 'sqlite3'
+  ) {
+    return value;
+  }
+  return {
+    error:
+      `Invalid ${flagName}. Use wa-sqlite, pglite, bun-sqlite, ` +
+      'better-sqlite3, or sqlite3.',
+  };
+}
+
+function parseSyncularElectronDialect(
+  value: string | undefined
+): SyncularElectronDialect | { error: string } {
+  if (!value || value === 'electron-sqlite') {
+    return 'electron-sqlite';
+  }
+  if (value === 'better-sqlite3') {
+    return value;
+  }
+  return {
+    error: 'Invalid --electron-dialect. Use electron-sqlite or better-sqlite3.',
+  };
+}
+
+async function runCreateSpacesApp(
+  flagValues: Map<string, string>,
+  overwrite: boolean
+): Promise<void> {
+  const targetDir = resolve(
+    process.cwd(),
+    optionalFlag(flagValues, '--dir', DEFAULT_INIT_DIR)
+  );
+  const explicitName = flagValues.get('--name')?.trim();
+  const inferredName = basename(targetDir) || 'spaces';
+  const projectName =
+    explicitName && explicitName.length > 0 ? explicitName : inferredName;
+
+  await templateRegistry.spacesApp.scaffold({
+    targetDir,
+    overwrite,
+    projectName,
+  });
+
+  printInfo('Scaffold created.');
+  console.log(`Template: ${templateRegistry.spacesApp.id}`);
+  console.log(`Project: ${projectName}`);
+  console.log(`Path: ${targetDir}`);
+  console.log('Next:');
+  console.log(`1. cd ${targetDir}`);
+  console.log('2. bun install');
+  console.log(`3. ${CLI_NAME} dev --port 4312`);
+}
+
+async function runCreateSpacesDemo(
+  flagValues: Map<string, string>,
+  overwrite: boolean
+): Promise<void> {
+  const targetDir = resolve(
+    process.cwd(),
+    optionalFlag(flagValues, '--dir', DEFAULT_DEMO_INIT_DIR)
+  );
+
+  await templateRegistry.spacesDemo.scaffold({
+    targetDir,
+    overwrite,
+  });
+
+  printInfo('Demo scaffold created.');
+  console.log(`Template: ${templateRegistry.spacesDemo.id}`);
+  console.log(`Path: ${targetDir}`);
+  console.log('Next:');
+  console.log(`1. cd ${targetDir}`);
+  console.log('2. bun install');
+  console.log(`3. bun ${CLI_NAME} dev --port 4330`);
+  console.log('4. bun dev');
+  console.log(`5. bun ${CLI_NAME} deploy --space <spaceId>`);
+}
+
+async function runCreateSyncularDemo(
+  flagValues: Map<string, string>,
+  overwrite: boolean
+): Promise<void> {
+  const targetDir = resolve(
+    process.cwd(),
+    optionalFlag(flagValues, '--dir', DEFAULT_SYNCULAR_INIT_DIR)
+  );
+
+  const result = await templateRegistry.syncularDemo.scaffold({
+    targetDir,
+    overwrite,
+  });
+
+  printInfo('Syncular demo scaffold created.');
+  console.log(`Template: ${templateRegistry.syncularDemo.id}`);
+  console.log(`Path: ${targetDir}`);
+  console.log('Files:');
+  for (const line of result.lines) {
+    console.log(`- ${line}`);
+  }
+}
+
+async function runCreateSyncularLibraries(
+  flagValues: Map<string, string>,
+  overwrite: boolean
+): Promise<void> {
+  const rawTargets = flagValues.get('--targets')?.trim();
+  const targets = parseSyncularTargets(rawTargets || undefined);
+  if (!Array.isArray(targets)) {
+    throw new Error(targets.error);
+  }
+
+  const serverDialect = parseSyncularServerDialect(
+    flagValues.get('--server-dialect')?.trim() || undefined
+  );
+  if (typeof serverDialect !== 'string') {
+    throw new Error(serverDialect.error);
+  }
+
+  const reactDialect = parseSyncularClientDialect(
+    flagValues.get('--react-dialect')?.trim() || undefined,
+    '--react-dialect'
+  );
+  if (typeof reactDialect !== 'string') {
+    throw new Error(reactDialect.error);
+  }
+
+  const vanillaDialect = parseSyncularClientDialect(
+    flagValues.get('--vanilla-dialect')?.trim() || undefined,
+    '--vanilla-dialect'
+  );
+  if (typeof vanillaDialect !== 'string') {
+    throw new Error(vanillaDialect.error);
+  }
+
+  const electronDialect = parseSyncularElectronDialect(
+    flagValues.get('--electron-dialect')?.trim() || undefined
+  );
+  if (typeof electronDialect !== 'string') {
+    throw new Error(electronDialect.error);
+  }
+
+  const targetDir = resolve(
+    process.cwd(),
+    optionalFlag(flagValues, '--dir', DEFAULT_SYNCULAR_INIT_DIR)
+  );
+  const result = await templateRegistry.syncularLibraries.scaffold({
+    targetDir,
+    overwrite,
+    targets,
+    serverDialect,
+    reactDialect,
+    vanillaDialect,
+    electronDialect,
+  });
+
+  printInfo('Syncular libraries scaffold created.');
+  console.log(`Template: ${templateRegistry.syncularLibraries.id}`);
+  console.log(`Path: ${targetDir}`);
+  console.log('Summary:');
+  for (const line of result.lines) {
+    console.log(`- ${line}`);
+  }
+}
+
+export async function runCreate(
+  flagValues: Map<string, string>
+): Promise<number> {
+  try {
+    const templateId = parseCreateTemplateId(flagValues);
+    const overwrite = optionalBooleanFlag(flagValues, '--force', false);
+
+    if (templateId === templateRegistry.spacesApp.id) {
+      await runCreateSpacesApp(flagValues, overwrite);
+      return 0;
+    }
+
+    if (templateId === templateRegistry.spacesDemo.id) {
+      await runCreateSpacesDemo(flagValues, overwrite);
+      return 0;
+    }
+
+    if (templateId === templateRegistry.syncularDemo.id) {
+      await runCreateSyncularDemo(flagValues, overwrite);
+      return 0;
+    }
+
+    await runCreateSyncularLibraries(flagValues, overwrite);
+    return 0;
+  } catch (error: unknown) {
+    printError(
+      error instanceof Error ? error.message : 'Failed to scaffold project.'
+    );
+    return 1;
+  }
+}
+
+function parseDbProviderFlag(
+  value: string | null | undefined
+): SpaceDatabaseProvider | null {
+  if (!value) {
+    return null;
+  }
+
+  const normalized = value.trim().toLowerCase();
+  if (
+    normalized === 'sqlite' ||
+    normalized === 'neon' ||
+    normalized === 'postgres'
+  ) {
+    return normalized;
+  }
+
+  throw new Error(
+    `Invalid --db-provider value "${value}". Use sqlite, neon, or postgres.`
+  );
+}
+
+export async function runDev(flagValues: Map<string, string>): Promise<number> {
+  let restoreTelemetry: (() => void) | null = null;
+  try {
+    if (flagValues.has('--module')) {
+      throw new Error(
+        '--module has been removed. Run syncular dev from a project directory that contains syncular.config.ts.'
+      );
+    }
+
+    const cwd = process.cwd();
+    const host = optionalFlag(flagValues, '--host', DEFAULT_DEV_HOST);
+    const port = optionalIntegerFlag(flagValues, '--port', DEFAULT_DEV_PORT);
+    const watchEnabled = optionalBooleanFlag(flagValues, '--watch', true);
+    const openConsole = optionalBooleanFlag(flagValues, '--open', false);
+    const requestedDbProvider = parseDbProviderFlag(
+      flagValues.get('--db-provider') || null
+    );
+    const dbPath = flagValues.get('--db')?.trim() || null;
+    const connectionString =
+      flagValues.get('--connection-string')?.trim() || null;
+    const logger: SpaceDevLogger = createSpacesDevLogger({
+      openConsoleOnStarted: openConsole,
+    });
+    restoreTelemetry = configureSpacesDevTelemetry();
+
+    const exitCode = await runSpaceDev({
+      cwd,
+      host,
+      port,
+      watch: watchEnabled,
+      dbProvider: requestedDbProvider,
+      dbPath,
+      connectionString,
+      consoleToken:
+        flagValues.get('--console-token')?.trim() || DEFAULT_DEV_CONSOLE_TOKEN,
+      logger,
+    });
+    restoreTelemetry();
+    restoreTelemetry = null;
+    return exitCode;
+  } catch (error: unknown) {
+    if (restoreTelemetry) {
+      restoreTelemetry();
+      restoreTelemetry = null;
+    }
+    printError(
+      error instanceof Error
+        ? error.message
+        : 'Failed to start local dev runtime.'
+    );
+    return 1;
+  }
+}

package/src/commands/target.ts

@@ -0,0 +1,62 @@
+import process from 'node:process';
+import { CLI_NAME } from '../constants';
+import { printError, printInfo } from '../output';
+import {
+  isTargetId,
+  listTargetDefinitions,
+  readStoredTargetId,
+  resolveEffectiveTargetId,
+  resolveTargetStatePath,
+  writeStoredTargetId,
+} from '../targets';
+
+export async function runTarget(
+  flagValues: Map<string, string>
+): Promise<number> {
+  try {
+    const cwd = process.cwd();
+    const setValue = flagValues.get('--set')?.trim() || null;
+    if (setValue) {
+      if (!isTargetId(setValue)) {
+        throw new Error(
+          `Unsupported --set target "${setValue}". Supported targets: ${listTargetDefinitions()
+            .map((target) => target.id)
+            .join(', ')}.`
+        );
+      }
+
+      const statePath = await writeStoredTargetId({
+        cwd,
+        targetId: setValue,
+      });
+      printInfo('Default target updated.');
+      console.log(`Target: ${setValue}`);
+      console.log(`State file: ${statePath}`);
+      return 0;
+    }
+
+    const effectiveTarget = await resolveEffectiveTargetId({
+      cwd,
+      explicitTargetId: null,
+    });
+    const storedTargetId = await readStoredTargetId(cwd);
+    const definitions = listTargetDefinitions();
+
+    console.log(`Effective target: ${effectiveTarget.targetId}`);
+    console.log(`Source: ${effectiveTarget.source}`);
+    console.log(
+      `State file: ${resolveTargetStatePath(cwd)}${storedTargetId ? '' : ' (not set)'}`
+    );
+    console.log('Available targets:');
+    for (const definition of definitions) {
+      console.log(`- ${definition.id}: ${definition.description}`);
+    }
+    console.log(`Set default with: ${CLI_NAME} target --set <target-id>`);
+    return 0;
+  } catch (error: unknown) {
+    printError(
+      error instanceof Error ? error.message : 'Failed to resolve target.'
+    );
+    return 1;
+  }
+}